grpc 1.44.0.pre2 → 1.45.0

data/src/core/ext/filters/client_channel/lb_policy/xds/cds.cc

@@ -366,9 +366,9 @@ bool CdsLb::GenerateDiscoveryMechanismForCluster(
       GPR_ASSERT(0);
       break;
   }
-  if (state.update->lrs_load_reporting_server_name.has_value()) {
-    mechanism["lrsLoadReportingServerName"] =
-        state.update->lrs_load_reporting_server_name.value();
+  if (state.update->lrs_load_reporting_server.has_value()) {
+    mechanism["lrsLoadReportingServer"] =
+        state.update->lrs_load_reporting_server->ToJson();
   }
   discovery_mechanisms->emplace_back(std::move(mechanism));
   return true;
@@ -403,9 +403,14 @@ void CdsLb::OnClusterChanged(const std::string& name,
   std::set<std::string> clusters_needed;
   if (GenerateDiscoveryMechanismForCluster(
           config_->cluster(), &discovery_mechanisms, &clusters_needed)) {
+    // LB policy is configured by aggregate cluster, not by the individual
+    // underlying cluster that we may be processing an update for.
+    auto it = watchers_.find(config_->cluster());
+    GPR_ASSERT(it != watchers_.end());
+    const std::string& lb_policy = it->second.update->lb_policy;
     // Construct config for child policy.
     Json::Object xds_lb_policy;
-    if (cluster_data.lb_policy == "RING_HASH") {
+    if (lb_policy == "RING_HASH") {
       xds_lb_policy["RING_HASH"] = Json::Object{
           {"min_ring_size", cluster_data.min_ring_size},
           {"max_ring_size", cluster_data.max_ring_size},

data/src/core/ext/filters/client_channel/lb_policy/xds/xds_cluster_impl.cc

@@ -119,14 +119,13 @@ class XdsClusterImplLbConfig : public LoadBalancingPolicy::Config {
   XdsClusterImplLbConfig(
       RefCountedPtr<LoadBalancingPolicy::Config> child_policy,
       std::string cluster_name, std::string eds_service_name,
-      absl::optional<std::string> lrs_load_reporting_server_name,
+      absl::optional<XdsBootstrap::XdsServer> lrs_load_reporting_server,
       uint32_t max_concurrent_requests,
       RefCountedPtr<XdsEndpointResource::DropConfig> drop_config)
       : child_policy_(std::move(child_policy)),
         cluster_name_(std::move(cluster_name)),
         eds_service_name_(std::move(eds_service_name)),
-        lrs_load_reporting_server_name_(
-            std::move(lrs_load_reporting_server_name)),
+        lrs_load_reporting_server_(std::move(lrs_load_reporting_server)),
         max_concurrent_requests_(max_concurrent_requests),
         drop_config_(std::move(drop_config)) {}
 
@@ -137,8 +136,9 @@ class XdsClusterImplLbConfig : public LoadBalancingPolicy::Config {
   }
   const std::string& cluster_name() const { return cluster_name_; }
   const std::string& eds_service_name() const { return eds_service_name_; }
-  const absl::optional<std::string>& lrs_load_reporting_server_name() const {
-    return lrs_load_reporting_server_name_;
+  const absl::optional<XdsBootstrap::XdsServer>& lrs_load_reporting_server()
+      const {
+    return lrs_load_reporting_server_;
   };
   uint32_t max_concurrent_requests() const { return max_concurrent_requests_; }
   RefCountedPtr<XdsEndpointResource::DropConfig> drop_config() const {
@@ -149,7 +149,7 @@ class XdsClusterImplLbConfig : public LoadBalancingPolicy::Config {
   RefCountedPtr<LoadBalancingPolicy::Config> child_policy_;
   std::string cluster_name_;
   std::string eds_service_name_;
-  absl::optional<std::string> lrs_load_reporting_server_name_;
+  absl::optional<XdsBootstrap::XdsServer> lrs_load_reporting_server_;
   uint32_t max_concurrent_requests_;
   RefCountedPtr<XdsEndpointResource::DropConfig> drop_config_;
 };
@@ -462,10 +462,19 @@ void XdsClusterImplLb::UpdateLocked(UpdateArgs args) {
   config_ = std::move(args.config);
   // On initial update, create drop stats.
   if (is_initial_update) {
-    if (config_->lrs_load_reporting_server_name().has_value()) {
+    if (config_->lrs_load_reporting_server().has_value()) {
       drop_stats_ = xds_client_->AddClusterDropStats(
-          config_->lrs_load_reporting_server_name().value(),
-          config_->cluster_name(), config_->eds_service_name());
+          config_->lrs_load_reporting_server().value(), config_->cluster_name(),
+          config_->eds_service_name());
+      if (drop_stats_ == nullptr) {
+        gpr_log(GPR_ERROR,
+                "[xds_cluster_impl_lb %p] Failed to get cluster drop stats for "
+                "LRS server %s, cluster %s, EDS service name %s, load "
+                "reporting for drops will not be done.",
+                this, config_->lrs_load_reporting_server()->server_uri.c_str(),
+                config_->cluster_name().c_str(),
+                config_->eds_service_name().c_str());
+      }
     }
     call_counter_ = g_call_counter_map->GetOrCreate(
         config_->cluster_name(), config_->eds_service_name());
@@ -475,8 +484,8 @@ void XdsClusterImplLb::UpdateLocked(UpdateArgs args) {
     // swapped out if that happens.
     GPR_ASSERT(config_->cluster_name() == old_config->cluster_name());
     GPR_ASSERT(config_->eds_service_name() == old_config->eds_service_name());
-    GPR_ASSERT(config_->lrs_load_reporting_server_name() ==
-               old_config->lrs_load_reporting_server_name());
+    GPR_ASSERT(config_->lrs_load_reporting_server() ==
+               old_config->lrs_load_reporting_server());
   }
   // Update picker if max_concurrent_requests has changed.
   if (is_initial_update || config_->max_concurrent_requests() !=
@@ -575,7 +584,7 @@ RefCountedPtr<SubchannelInterface> XdsClusterImplLb::Helper::CreateSubchannel(
   if (xds_cluster_impl_policy_->shutting_down_) return nullptr;
   // If load reporting is enabled, wrap the subchannel such that it
   // includes the locality stats object, which will be used by the EdsPicker.
-  if (xds_cluster_impl_policy_->config_->lrs_load_reporting_server_name()
+  if (xds_cluster_impl_policy_->config_->lrs_load_reporting_server()
           .has_value()) {
     RefCountedPtr<XdsLocalityName> locality_name;
     auto* attribute = address.GetAttribute(kXdsLocalityNameAttributeKey);
@@ -586,15 +595,26 @@ RefCountedPtr<SubchannelInterface> XdsClusterImplLb::Helper::CreateSubchannel(
     }
     RefCountedPtr<XdsClusterLocalityStats> locality_stats =
         xds_cluster_impl_policy_->xds_client_->AddClusterLocalityStats(
-            *xds_cluster_impl_policy_->config_
-                 ->lrs_load_reporting_server_name(),
+            xds_cluster_impl_policy_->config_->lrs_load_reporting_server()
+                .value(),
             xds_cluster_impl_policy_->config_->cluster_name(),
             xds_cluster_impl_policy_->config_->eds_service_name(),
             std::move(locality_name));
-    return MakeRefCounted<StatsSubchannelWrapper>(
-        xds_cluster_impl_policy_->channel_control_helper()->CreateSubchannel(
-            std::move(address), args),
-        std::move(locality_stats));
+    if (locality_stats != nullptr) {
+      return MakeRefCounted<StatsSubchannelWrapper>(
+          xds_cluster_impl_policy_->channel_control_helper()->CreateSubchannel(
+              std::move(address), args),
+          std::move(locality_stats));
+    }
+    gpr_log(GPR_ERROR,
+            "[xds_cluster_impl_lb %p] Failed to get locality stats object for "
+            "LRS server %s, cluster %s, EDS service name %s; load reports will "
+            "not be generated (not wrapping subchannel)",
+            this,
+            xds_cluster_impl_policy_->config_->lrs_load_reporting_server()
+                ->server_uri.c_str(),
+            xds_cluster_impl_policy_->config_->cluster_name().c_str(),
+            xds_cluster_impl_policy_->config_->eds_service_name().c_str());
   }
   // Load reporting not enabled, so don't wrap the subchannel.
   return xds_cluster_impl_policy_->channel_control_helper()->CreateSubchannel(
@@ -715,14 +735,21 @@ class XdsClusterImplLbFactory : public LoadBalancingPolicyFactory {
       }
     }
     // LRS load reporting server name.
-    absl::optional<std::string> lrs_load_reporting_server_name;
-    it = json.object_value().find("lrsLoadReportingServerName");
+    absl::optional<XdsBootstrap::XdsServer> lrs_load_reporting_server;
+    it = json.object_value().find("lrsLoadReportingServer");
     if (it != json.object_value().end()) {
-      if (it->second.type() != Json::Type::STRING) {
+      if (it->second.type() != Json::Type::OBJECT) {
         error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "field:lrsLoadReportingServerName error:type should be string"));
+            "field:lrsLoadReportingServer error:type should be object"));
       } else {
-        lrs_load_reporting_server_name = it->second.string_value();
+        grpc_error_handle parser_error;
+        lrs_load_reporting_server = XdsBootstrap::XdsServer::Parse(
+            it->second.object_value(), &parser_error);
+        if (parser_error != GRPC_ERROR_NONE) {
+          error_list.push_back(GRPC_ERROR_CREATE_FROM_CPP_STRING(
+              absl::StrCat("errors parsing lrs_load_reporting_server")));
+          error_list.push_back(parser_error);
+        }
       }
     }
     // Max concurrent requests.
@@ -758,7 +785,7 @@ class XdsClusterImplLbFactory : public LoadBalancingPolicyFactory {
     }
     return MakeRefCounted<XdsClusterImplLbConfig>(
         std::move(child_policy), std::move(cluster_name),
-        std::move(eds_service_name), std::move(lrs_load_reporting_server_name),
+        std::move(eds_service_name), std::move(lrs_load_reporting_server),
         max_concurrent_requests, std::move(drop_config));
   }
 

data/src/core/ext/filters/client_channel/lb_policy/xds/xds_cluster_manager.cc

@@ -487,7 +487,8 @@ void XdsClusterManagerLb::ClusterChild::DeactivateLocked() {
   Ref(DEBUG_LOCATION, "ClusterChild+timer").release();
   grpc_timer_init(&delayed_removal_timer_,
                   ExecCtx::Get()->Now() +
-                      GRPC_XDS_CLUSTER_MANAGER_CHILD_RETENTION_INTERVAL_MS,
+                      Duration::Milliseconds(
+                          GRPC_XDS_CLUSTER_MANAGER_CHILD_RETENTION_INTERVAL_MS),
                   &on_delayed_removal_timer_);
   delayed_removal_timer_callback_pending_ = true;
 }

data/src/core/ext/filters/client_channel/lb_policy/xds/xds_cluster_resolver.cc

@@ -34,11 +34,13 @@
 #include "src/core/ext/filters/client_channel/lb_policy_factory.h"
 #include "src/core/ext/filters/client_channel/lb_policy_registry.h"
 #include "src/core/ext/filters/client_channel/resolver/fake/fake_resolver.h"
+#include "src/core/ext/xds/xds_bootstrap.h"
 #include "src/core/ext/xds/xds_channel_args.h"
 #include "src/core/ext/xds/xds_client.h"
 #include "src/core/ext/xds/xds_client_stats.h"
 #include "src/core/ext/xds/xds_endpoint.h"
 #include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
@@ -65,7 +67,7 @@ class XdsClusterResolverLbConfig : public LoadBalancingPolicy::Config {
  public:
   struct DiscoveryMechanism {
     std::string cluster_name;
-    absl::optional<std::string> lrs_load_reporting_server_name;
+    absl::optional<XdsBootstrap::XdsServer> lrs_load_reporting_server;
     uint32_t max_concurrent_requests;
     enum DiscoveryMechanismType {
       EDS,
@@ -77,8 +79,7 @@ class XdsClusterResolverLbConfig : public LoadBalancingPolicy::Config {
 
     bool operator==(const DiscoveryMechanism& other) const {
       return (cluster_name == other.cluster_name &&
-              lrs_load_reporting_server_name ==
-                  other.lrs_load_reporting_server_name &&
+              lrs_load_reporting_server == other.lrs_load_reporting_server &&
               max_concurrent_requests == other.max_concurrent_requests &&
               type == other.type &&
               eds_service_name == other.eds_service_name &&
@@ -452,7 +453,7 @@ void XdsClusterResolverLb::LogicalDNSDiscoveryMechanism::Start() {
     target = absl::StrCat("dns:", target);
     args = grpc_channel_args_copy(parent()->args_);
   }
-  resolver_ = ResolverRegistry::CreateResolver(
+  resolver_ = CoreConfiguration::Get().resolver_registry().CreateResolver(
       target.c_str(), args, parent()->interested_parties(),
       parent()->work_serializer(),
       absl::make_unique<ResolverResultHandler>(
@@ -887,10 +888,10 @@ XdsClusterResolverLb::CreateChildPolicyConfigLocked() {
       xds_cluster_impl_config["edsServiceName"] = std::string(lrs_key.second);
     }
     if (config_->discovery_mechanisms()[discovery_index]
-            .lrs_load_reporting_server_name.has_value()) {
-      xds_cluster_impl_config["lrsLoadReportingServerName"] =
+            .lrs_load_reporting_server.has_value()) {
+      xds_cluster_impl_config["lrsLoadReportingServer"] =
           config_->discovery_mechanisms()[discovery_index]
-              .lrs_load_reporting_server_name.value();
+              .lrs_load_reporting_server->ToJson();
     }
     Json locality_picking_policy = Json::Array{Json::Object{
         {"xds_cluster_impl_experimental", std::move(xds_cluster_impl_config)},
@@ -1151,14 +1152,20 @@ class XdsClusterResolverLbFactory : public LoadBalancingPolicyFactory {
       discovery_mechanism->cluster_name = it->second.string_value();
     }
     // LRS load reporting server name.
-    it = json.object_value().find("lrsLoadReportingServerName");
+    it = json.object_value().find("lrsLoadReportingServer");
     if (it != json.object_value().end()) {
-      if (it->second.type() != Json::Type::STRING) {
+      if (it->second.type() != Json::Type::OBJECT) {
         error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "field:lrsLoadReportingServerName error:type should be string"));
+            "field:lrsLoadReportingServer error:type should be object"));
       } else {
-        discovery_mechanism->lrs_load_reporting_server_name.emplace(
-            it->second.string_value());
+        grpc_error_handle parse_error;
+        discovery_mechanism->lrs_load_reporting_server.emplace(
+            XdsBootstrap::XdsServer::Parse(it->second, &parse_error));
+        if (parse_error != GRPC_ERROR_NONE) {
+          error_list.push_back(GRPC_ERROR_CREATE_FROM_CPP_STRING(
+              absl::StrCat("errors parsing lrs_load_reporting_server")));
+          error_list.push_back(parse_error);
+        }
       }
     }
     // Max concurrent requests.

data/src/core/ext/filters/client_channel/resolver/binder/binder_resolver.cc

@@ -25,6 +25,7 @@
 
 #include "src/core/lib/address_utils/parse_address.h"
 #include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/resolver/resolver_registry.h"
 #include "src/core/lib/resolver/server_address.h"
@@ -59,6 +60,8 @@ class BinderResolver : public Resolver {
 
 class BinderResolverFactory : public ResolverFactory {
  public:
+  absl::string_view scheme() const override { return "binder"; }
+
   bool IsValidUri(const URI& uri) const override {
     return ParseUri(uri, nullptr);
   }
@@ -70,8 +73,6 @@ class BinderResolverFactory : public ResolverFactory {
                                           std::move(args));
   }
 
-  const char* scheme() const override { return "binder"; }
-
  private:
   static grpc_error_handle BinderAddrPopulate(
       absl::string_view path, grpc_resolved_address* resolved_addr) {
@@ -121,19 +122,12 @@ class BinderResolverFactory : public ResolverFactory {
 };
 
 }  // namespace
-}  // namespace grpc_core
 
-void grpc_resolver_binder_init() {
-  grpc_core::ResolverRegistry::Builder::RegisterResolverFactory(
-      absl::make_unique<grpc_core::BinderResolverFactory>());
+void RegisterBinderResolver(CoreConfiguration::Builder* builder) {
+  builder->resolver_registry()->RegisterResolverFactory(
+      absl::make_unique<BinderResolverFactory>());
 }
 
-void grpc_resolver_binder_shutdown() {}
-
-#else
-
-void grpc_resolver_binder_init() {}
-
-void grpc_resolver_binder_shutdown() {}
+}  // namespace grpc_core
 
 #endif

data/src/core/ext/filters/client_channel/resolver/dns/c_ares/dns_resolver_ares.cc

@@ -16,6 +16,8 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "src/core/lib/config/core_configuration.h"
+
 #if GRPC_ARES == 1
 
 #include <limits.h>
@@ -40,14 +42,13 @@
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gprpp/manual_constructor.h"
 #include "src/core/lib/iomgr/gethostname.h"
-#include "src/core/lib/iomgr/iomgr_custom.h"
 #include "src/core/lib/iomgr/resolve_address.h"
 #include "src/core/lib/iomgr/timer.h"
 #include "src/core/lib/iomgr/work_serializer.h"
 #include "src/core/lib/json/json.h"
 #include "src/core/lib/resolver/resolver_registry.h"
 #include "src/core/lib/resolver/server_address.h"
-#include "src/core/lib/service_config/service_config.h"
+#include "src/core/lib/service_config/service_config_impl.h"
 #include "src/core/lib/transport/error_utils.h"
 
 #define GRPC_DNS_INITIAL_CONNECT_BACKOFF_SECONDS 1
@@ -100,7 +101,7 @@ class AresClientChannelDNSResolver : public Resolver {
   // timeout in milliseconds for active DNS queries
   int query_timeout_ms_;
   /// min interval between DNS requests
-  grpc_millis min_time_between_resolutions_;
+  Duration min_time_between_resolutions_;
 
   /// closures used by the work_serializer
   grpc_closure on_next_resolution_;
@@ -113,7 +114,7 @@ class AresClientChannelDNSResolver : public Resolver {
   bool have_next_resolution_timer_ = false;
   grpc_timer next_resolution_timer_;
   /// timestamp of last DNS request
-  grpc_millis last_resolution_timestamp_ = -1;
+  absl::optional<Timestamp> last_resolution_timestamp_;
   /// retry backoff state
   BackOff backoff_;
   /// currently resolving backend addresses
@@ -140,16 +141,17 @@ AresClientChannelDNSResolver::AresClientChannelDNSResolver(ResolverArgs args)
       query_timeout_ms_(grpc_channel_args_find_integer(
           channel_args_, GRPC_ARG_DNS_ARES_QUERY_TIMEOUT_MS,
           {GRPC_DNS_ARES_DEFAULT_QUERY_TIMEOUT_MS, 0, INT_MAX})),
-      min_time_between_resolutions_(grpc_channel_args_find_integer(
-          channel_args_, GRPC_ARG_DNS_MIN_TIME_BETWEEN_RESOLUTIONS_MS,
-          {1000 * 30, 0, INT_MAX})),
-      backoff_(
-          BackOff::Options()
-              .set_initial_backoff(GRPC_DNS_INITIAL_CONNECT_BACKOFF_SECONDS *
-                                   1000)
-              .set_multiplier(GRPC_DNS_RECONNECT_BACKOFF_MULTIPLIER)
-              .set_jitter(GRPC_DNS_RECONNECT_JITTER)
-              .set_max_backoff(GRPC_DNS_RECONNECT_MAX_BACKOFF_SECONDS * 1000)) {
+      min_time_between_resolutions_(
+          Duration::Milliseconds(grpc_channel_args_find_integer(
+              channel_args_, GRPC_ARG_DNS_MIN_TIME_BETWEEN_RESOLUTIONS_MS,
+              {1000 * 30, 0, INT_MAX}))),
+      backoff_(BackOff::Options()
+                   .set_initial_backoff(Duration::Milliseconds(
+                       GRPC_DNS_INITIAL_CONNECT_BACKOFF_SECONDS))
+                   .set_multiplier(GRPC_DNS_RECONNECT_BACKOFF_MULTIPLIER)
+                   .set_jitter(GRPC_DNS_RECONNECT_JITTER)
+                   .set_max_backoff(Duration::Milliseconds(
+                       GRPC_DNS_RECONNECT_MAX_BACKOFF_SECONDS))) {
   // Closure initialization.
   GRPC_CLOSURE_INIT(&on_next_resolution_, OnNextResolution, this,
                     grpc_schedule_on_exec_ctx);
@@ -345,7 +347,7 @@ void AresClientChannelDNSResolver::OnResolvedLocked(grpc_error_handle error) {
           !service_config_string.empty()) {
         GRPC_CARES_TRACE_LOG("resolver:%p selected service config choice: %s",
                              this, service_config_string.c_str());
-        service_config = ServiceConfig::Create(
+        service_config = ServiceConfigImpl::Create(
             channel_args_, service_config_string, &service_config_error);
       }
       if (service_config_error != GRPC_ERROR_NONE) {
@@ -387,8 +389,8 @@ void AresClientChannelDNSResolver::OnResolvedLocked(grpc_error_handle error) {
     // in a loop while draining the currently-held WorkSerializer.
     // Also see https://github.com/grpc/grpc/issues/26079.
     ExecCtx::Get()->InvalidateNow();
-    grpc_millis next_try = backoff_.NextAttemptTime();
-    grpc_millis timeout = next_try - ExecCtx::Get()->Now();
+    Timestamp next_try = backoff_.NextAttemptTime();
+    Duration timeout = next_try - ExecCtx::Get()->Now();
     GRPC_CARES_TRACE_LOG("resolver:%p dns resolution failed (will retry): %s",
                          this, grpc_error_std_string(error).c_str());
     GPR_ASSERT(!have_next_resolution_timer_);
@@ -397,9 +399,9 @@ void AresClientChannelDNSResolver::OnResolvedLocked(grpc_error_handle error) {
     // new closure API is done, find a way to track this ref with the timer
     // callback as part of the type system.
     Ref(DEBUG_LOCATION, "retry-timer").release();
-    if (timeout > 0) {
+    if (timeout > Duration::Zero()) {
       GRPC_CARES_TRACE_LOG("resolver:%p retrying in %" PRId64 " milliseconds",
-                           this, timeout);
+                           this, timeout.millis());
     } else {
       GRPC_CARES_TRACE_LOG("resolver:%p retrying immediately", this);
     }
@@ -413,29 +415,30 @@ void AresClientChannelDNSResolver::MaybeStartResolvingLocked() {
   // If there is an existing timer, the time it fires is the earliest time we
   // can start the next resolution.
   if (have_next_resolution_timer_) return;
-  if (last_resolution_timestamp_ >= 0) {
+  if (last_resolution_timestamp_.has_value()) {
     // InvalidateNow to avoid getting stuck re-initializing this timer
     // in a loop while draining the currently-held WorkSerializer.
     // Also see https://github.com/grpc/grpc/issues/26079.
     ExecCtx::Get()->InvalidateNow();
-    const grpc_millis earliest_next_resolution =
-        last_resolution_timestamp_ + min_time_between_resolutions_;
-    const grpc_millis ms_until_next_resolution =
+    const Timestamp earliest_next_resolution =
+        *last_resolution_timestamp_ + min_time_between_resolutions_;
+    const Duration time_until_next_resolution =
         earliest_next_resolution - ExecCtx::Get()->Now();
-    if (ms_until_next_resolution > 0) {
-      const grpc_millis last_resolution_ago =
-          ExecCtx::Get()->Now() - last_resolution_timestamp_;
+    if (time_until_next_resolution > Duration::Zero()) {
+      const Duration last_resolution_ago =
+          ExecCtx::Get()->Now() - *last_resolution_timestamp_;
       GRPC_CARES_TRACE_LOG(
           "resolver:%p In cooldown from last resolution (from %" PRId64
           " ms ago). Will resolve again in %" PRId64 " ms",
-          this, last_resolution_ago, ms_until_next_resolution);
+          this, last_resolution_ago.millis(),
+          time_until_next_resolution.millis());
       have_next_resolution_timer_ = true;
       // TODO(roth): We currently deal with this ref manually.  Once the
       // new closure API is done, find a way to track this ref with the timer
       // callback as part of the type system.
       Ref(DEBUG_LOCATION, "next_resolution_timer_cooldown").release();
       grpc_timer_init(&next_resolution_timer_,
-                      ExecCtx::Get()->Now() + ms_until_next_resolution,
+                      ExecCtx::Get()->Now() + time_until_next_resolution,
                       &on_next_resolution_);
       return;
     }
@@ -467,6 +470,8 @@ void AresClientChannelDNSResolver::StartResolvingLocked() {
 //
 class AresClientChannelDNSResolverFactory : public ResolverFactory {
  public:
+  absl::string_view scheme() const override { return "dns"; }
+
   bool IsValidUri(const URI& uri) const override {
     if (absl::StripPrefix(uri.path(), "/").empty()) {
       gpr_log(GPR_ERROR, "no server name supplied in dns URI");
@@ -478,8 +483,6 @@ class AresClientChannelDNSResolverFactory : public ResolverFactory {
   OrphanablePtr<Resolver> CreateResolver(ResolverArgs args) const override {
     return MakeOrphanable<AresClientChannelDNSResolver>(std::move(args));
   }
-
-  const char* scheme() const override { return "dns"; }
 };
 
 class AresDNSResolver : public DNSResolver {
@@ -522,7 +525,9 @@ class AresDNSResolver : public DNSResolver {
         absl::MutexLock lock(&mu_);
         GRPC_CARES_TRACE_LOG("AresRequest:%p Orphan ares_request_:%p", this,
                              ares_request_.get());
-        grpc_cancel_ares_request(ares_request_.get());
+        if (ares_request_ != nullptr) {
+          grpc_cancel_ares_request(ares_request_.get());
+        }
       }
       Unref();
     }
@@ -603,25 +608,33 @@ class AresDNSResolver : public DNSResolver {
 };
 
 bool ShouldUseAres(const char* resolver_env) {
-  // TODO(lidiz): Remove the "g_custom_iomgr_enabled" flag once c-ares support
-  // custom IO managers (e.g. gevent).
-  return !g_custom_iomgr_enabled &&
-         (resolver_env == nullptr || strlen(resolver_env) == 0 ||
-          gpr_stricmp(resolver_env, "ares") == 0);
+  return resolver_env == nullptr || strlen(resolver_env) == 0 ||
+         gpr_stricmp(resolver_env, "ares") == 0;
 }
 
-bool g_use_ares_dns_resolver;
+bool UseAresDnsResolver() {
+  static const bool result = []() {
+    UniquePtr<char> resolver = GPR_GLOBAL_CONFIG_GET(grpc_dns_resolver);
+    bool result = ShouldUseAres(resolver.get());
+    if (result) gpr_log(GPR_DEBUG, "Using ares dns resolver");
+    return result;
+  }();
+  return result;
+}
 
 }  // namespace
 
+void RegisterAresDnsResolver(CoreConfiguration::Builder* builder) {
+  if (UseAresDnsResolver()) {
+    builder->resolver_registry()->RegisterResolverFactory(
+        absl::make_unique<AresClientChannelDNSResolverFactory>());
+  }
+}
+
 }  // namespace grpc_core
 
 void grpc_resolver_dns_ares_init() {
-  grpc_core::UniquePtr<char> resolver =
-      GPR_GLOBAL_CONFIG_GET(grpc_dns_resolver);
-  if (grpc_core::ShouldUseAres(resolver.get())) {
-    grpc_core::g_use_ares_dns_resolver = true;
-    gpr_log(GPR_DEBUG, "Using ares dns resolver");
+  if (grpc_core::UseAresDnsResolver()) {
     address_sorting_init();
     grpc_error_handle error = grpc_ares_init();
     if (error != GRPC_ERROR_NONE) {
@@ -629,15 +642,11 @@ void grpc_resolver_dns_ares_init() {
       return;
     }
     grpc_core::SetDNSResolver(grpc_core::AresDNSResolver::GetOrCreate());
-    grpc_core::ResolverRegistry::Builder::RegisterResolverFactory(
-        absl::make_unique<grpc_core::AresClientChannelDNSResolverFactory>());
-  } else {
-    grpc_core::g_use_ares_dns_resolver = false;
   }
 }
 
 void grpc_resolver_dns_ares_shutdown() {
-  if (grpc_core::g_use_ares_dns_resolver) {
+  if (grpc_core::UseAresDnsResolver()) {
     address_sorting_shutdown();
     grpc_ares_cleanup();
   }
@@ -645,8 +654,12 @@ void grpc_resolver_dns_ares_shutdown() {
 
 #else /* GRPC_ARES == 1 */
 
-void grpc_resolver_dns_ares_init(void) {}
+namespace grpc_core {
+void RegisterAresDnsResolver(CoreConfiguration::Builder*) {}
+}  // namespace grpc_core
+
+void grpc_resolver_dns_ares_init() {}
 
-void grpc_resolver_dns_ares_shutdown(void) {}
+void grpc_resolver_dns_ares_shutdown() {}
 
 #endif /* GRPC_ARES == 1 */