src/core/ext/filters/client_channel/resolver/dns/c_ares/dns_resolver_ares.cc - external/github.com/grpc/grpc - Git at Google

 /*
  *
  * Copyright 2015 gRPC authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  *
  */

 #include <grpc/support/port_platform.h>

 #if GRPC_ARES == 1

 #include <limits.h>
 #include <stdio.h>
 #include <string.h>

 #include <grpc/support/alloc.h>
 #include <grpc/support/string_util.h>

 #include <address_sorting/address_sorting.h>

 #include "src/core/ext/filters/client_channel/http_connect_handshaker.h"
 #include "src/core/ext/filters/client_channel/lb_policy_registry.h"
 #include "src/core/ext/filters/client_channel/resolver/dns/c_ares/grpc_ares_wrapper.h"
 #include "src/core/ext/filters/client_channel/resolver/dns/dns_resolver_selection.h"
 #include "src/core/ext/filters/client_channel/resolver_registry.h"
 #include "src/core/ext/filters/client_channel/server_address.h"
 #include "src/core/ext/filters/client_channel/service_config.h"
 #include "src/core/lib/backoff/backoff.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gprpp/manual_constructor.h"
 #include "src/core/lib/iomgr/combiner.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/json/json.h"

 #define GRPC_DNS_INITIAL_CONNECT_BACKOFF_SECONDS 1
 #define GRPC_DNS_RECONNECT_BACKOFF_MULTIPLIER 1.6
 #define GRPC_DNS_RECONNECT_MAX_BACKOFF_SECONDS 120
 #define GRPC_DNS_RECONNECT_JITTER 0.2

 namespace grpc_core {

 namespace {

 const char kDefaultPort[] = "https";

 class AresDnsResolver : public Resolver {
  public:
   explicit AresDnsResolver(ResolverArgs args);

   void StartLocked() override;

   void RequestReresolutionLocked() override;

   void ResetBackoffLocked() override;

   void ShutdownLocked() override;

  private:
   virtual ~AresDnsResolver();

   void MaybeStartResolvingLocked();
   void StartResolvingLocked();

   static void OnNextResolutionLocked(void* arg, grpc_error* error);
   static void OnResolvedLocked(void* arg, grpc_error* error);

   /// DNS server to use (if not system default)
   char* dns_server_;
   /// name to resolve (usually the same as target_name)
   char* name_to_resolve_;
   /// channel args
   grpc_channel_args* channel_args_;
   /// whether to request the service config
   bool request_service_config_;
   /// pollset_set to drive the name resolution process
   grpc_pollset_set* interested_parties_;
   /// closures used by the combiner
   grpc_closure on_next_resolution_;
   grpc_closure on_resolved_;
   /// are we currently resolving?
   bool resolving_ = false;
   /// the pending resolving request
   grpc_ares_request* pending_request_ = nullptr;
   /// next resolution timer
   bool have_next_resolution_timer_ = false;
   grpc_timer next_resolution_timer_;
   /// min interval between DNS requests
   grpc_millis min_time_between_resolutions_;
   /// timestamp of last DNS request
   grpc_millis last_resolution_timestamp_ = -1;
   /// retry backoff state
   BackOff backoff_;
   /// currently resolving addresses
   UniquePtr<ServerAddressList> addresses_;
   /// currently resolving service config
   char* service_config_json_ = nullptr;
   // has shutdown been initiated
   bool shutdown_initiated_ = false;
   // timeout in milliseconds for active DNS queries
   int query_timeout_ms_;
   // whether or not to enable SRV DNS queries
   bool enable_srv_queries_;
 };

 AresDnsResolver::AresDnsResolver(ResolverArgs args)
     : Resolver(args.combiner, std::move(args.result_handler)),
       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)) {
   // Get name to resolve from URI path.
   const char* path = args.uri->path;
   if (path[0] == '/') ++path;
   name_to_resolve_ = gpr_strdup(path);
   // Get DNS server from URI authority.
   dns_server_ = nullptr;
   if (0 != strcmp(args.uri->authority, "")) {
     dns_server_ = gpr_strdup(args.uri->authority);
   }
   channel_args_ = grpc_channel_args_copy(args.args);
   // Disable service config option
   const grpc_arg* arg = grpc_channel_args_find(
       channel_args_, GRPC_ARG_SERVICE_CONFIG_DISABLE_RESOLUTION);
   request_service_config_ = !grpc_channel_arg_get_bool(arg, true);
   // Min time b/t resolutions option
   arg = grpc_channel_args_find(channel_args_,
                                GRPC_ARG_DNS_MIN_TIME_BETWEEN_RESOLUTIONS_MS);
   min_time_between_resolutions_ =
       grpc_channel_arg_get_integer(arg, {1000 * 30, 0, INT_MAX});
   // Enable SRV queries option
   arg = grpc_channel_args_find(channel_args_, GRPC_ARG_DNS_ENABLE_SRV_QUERIES);
   enable_srv_queries_ = grpc_channel_arg_get_bool(arg, false);
   interested_parties_ = grpc_pollset_set_create();
   if (args.pollset_set != nullptr) {
     grpc_pollset_set_add_pollset_set(interested_parties_, args.pollset_set);
   }
   GRPC_CLOSURE_INIT(&on_next_resolution_, OnNextResolutionLocked, this,
                     grpc_combiner_scheduler(combiner()));
   GRPC_CLOSURE_INIT(&on_resolved_, OnResolvedLocked, this,
                     grpc_combiner_scheduler(combiner()));
   const grpc_arg* query_timeout_ms_arg =
       grpc_channel_args_find(channel_args_, GRPC_ARG_DNS_ARES_QUERY_TIMEOUT_MS);
   query_timeout_ms_ = grpc_channel_arg_get_integer(
       query_timeout_ms_arg,
       {GRPC_DNS_ARES_DEFAULT_QUERY_TIMEOUT_MS, 0, INT_MAX});
 }

 AresDnsResolver::~AresDnsResolver() {
   GRPC_CARES_TRACE_LOG("resolver:%p destroying AresDnsResolver", this);
   grpc_pollset_set_destroy(interested_parties_);
   gpr_free(dns_server_);
   gpr_free(name_to_resolve_);
   grpc_channel_args_destroy(channel_args_);
 }

 void AresDnsResolver::StartLocked() {
   GRPC_CARES_TRACE_LOG("resolver:%p AresDnsResolver::StartLocked() is called.",
                        this);
   MaybeStartResolvingLocked();
 }

 void AresDnsResolver::RequestReresolutionLocked() {
   if (!resolving_) {
     MaybeStartResolvingLocked();
   }
 }

 void AresDnsResolver::ResetBackoffLocked() {
   if (have_next_resolution_timer_) {
     grpc_timer_cancel(&next_resolution_timer_);
   }
   backoff_.Reset();
 }

 void AresDnsResolver::ShutdownLocked() {
   shutdown_initiated_ = true;
   if (have_next_resolution_timer_) {
     grpc_timer_cancel(&next_resolution_timer_);
   }
   if (pending_request_ != nullptr) {
     grpc_cancel_ares_request_locked(pending_request_);
   }
 }

 void AresDnsResolver::OnNextResolutionLocked(void* arg, grpc_error* error) {
   AresDnsResolver* r = static_cast<AresDnsResolver*>(arg);
   GRPC_CARES_TRACE_LOG(
       "resolver:%p re-resolution timer fired. error: %s. shutdown_initiated_: "
       "%d",
       r, grpc_error_string(error), r->shutdown_initiated_);
   r->have_next_resolution_timer_ = false;
   if (error == GRPC_ERROR_NONE && !r->shutdown_initiated_) {
     if (!r->resolving_) {
       GRPC_CARES_TRACE_LOG(
           "resolver:%p start resolving due to re-resolution timer", r);
       r->StartResolvingLocked();
     }
   }
   r->Unref(DEBUG_LOCATION, "next_resolution_timer");
 }

 bool ValueInJsonArray(grpc_json* array, const char* value) {
   for (grpc_json* entry = array->child; entry != nullptr; entry = entry->next) {
     if (entry->type == GRPC_JSON_STRING && strcmp(entry->value, value) == 0) {
       return true;
     }
   }
   return false;
 }

 char* ChooseServiceConfig(char* service_config_choice_json,
                           grpc_error** error) {
   grpc_json* choices_json = grpc_json_parse_string(service_config_choice_json);
   if (choices_json == nullptr) {
     *error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
         "Service Config JSON Parsing, error: could not parse");
     return nullptr;
   }
   if (choices_json->type != GRPC_JSON_ARRAY) {
     *error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
         "Service Config Choices, error: should be of type array");
     return nullptr;
   }
   char* service_config = nullptr;
   InlinedVector<grpc_error*, 4> error_list;
   bool found_choice = false;  // have we found a choice?
   for (grpc_json* choice = choices_json->child; choice != nullptr;
        choice = choice->next) {
     if (choice->type != GRPC_JSON_OBJECT) {
       error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
           "Service Config Choice, error: should be of type object"));
       continue;
     }
     grpc_json* service_config_json = nullptr;
     bool selected = true;  // has this choice been rejected?
     for (grpc_json* field = choice->child; field != nullptr;
          field = field->next) {
       // Check client language, if specified.
       if (strcmp(field->key, "clientLanguage") == 0) {
         if (field->type != GRPC_JSON_ARRAY) {
           error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
               "field:clientLanguage error:should be of type array"));
         } else if (!ValueInJsonArray(field, "c++")) {
           selected = false;
         }
       }
       // Check client hostname, if specified.
       if (strcmp(field->key, "clientHostname") == 0) {
         if (field->type != GRPC_JSON_ARRAY) {
           error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
               "field:clientHostname error:should be of type array"));
           continue;
         }
         char* hostname = grpc_gethostname();
         if (hostname == nullptr || !ValueInJsonArray(field, hostname)) {
           selected = false;
         }
       }
       // Check percentage, if specified.
       if (strcmp(field->key, "percentage") == 0) {
         if (field->type != GRPC_JSON_NUMBER) {
           error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
               "field:percentage error:should be of type number"));
           continue;
         }
         int random_pct = rand() % 100;
         int percentage;
         if (sscanf(field->value, "%d", &percentage) != 1) {
           error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
               "field:percentage error:should be of type integer"));
           continue;
         }
         if (random_pct > percentage || percentage == 0) {
           selected = false;
         }
       }
       // Save service config.
       if (strcmp(field->key, "serviceConfig") == 0) {
         if (field->type == GRPC_JSON_OBJECT) {
           service_config_json = field;
         } else {
           error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
               "field:serviceConfig error:should be of type object"));
         }
       }
     }
     if (!found_choice && selected && service_config_json != nullptr) {
       service_config = grpc_json_dump_to_string(service_config_json, 0);
       found_choice = true;
     }
   }
   grpc_json_destroy(choices_json);
   if (!error_list.empty()) {
     gpr_free(service_config);
     service_config = nullptr;
     *error = GRPC_ERROR_CREATE_FROM_VECTOR("Service Config Choices Parser",
                                            &error_list);
   }
   return service_config;
 }

 void AresDnsResolver::OnResolvedLocked(void* arg, grpc_error* error) {
   AresDnsResolver* r = static_cast<AresDnsResolver*>(arg);
   GPR_ASSERT(r->resolving_);
   r->resolving_ = false;
   gpr_free(r->pending_request_);
   r->pending_request_ = nullptr;
   if (r->shutdown_initiated_) {
     r->Unref(DEBUG_LOCATION, "OnResolvedLocked() shutdown");
     return;
   }
   if (r->addresses_ != nullptr) {
     Result result;
     result.addresses = std::move(*r->addresses_);
     if (r->service_config_json_ != nullptr) {
       char* service_config_string = ChooseServiceConfig(
           r->service_config_json_, &result.service_config_error);
       gpr_free(r->service_config_json_);
       if (result.service_config_error == GRPC_ERROR_NONE &&
           service_config_string != nullptr) {
         GRPC_CARES_TRACE_LOG("resolver:%p selected service config choice: %s",
                              r, service_config_string);
         result.service_config = ServiceConfig::Create(
             service_config_string, &result.service_config_error);
       }
       gpr_free(service_config_string);
     }
     result.args = grpc_channel_args_copy(r->channel_args_);
     r->result_handler()->ReturnResult(std::move(result));
     r->addresses_.reset();
     // Reset backoff state so that we start from the beginning when the
     // next request gets triggered.
     r->backoff_.Reset();
   } else {
     GRPC_CARES_TRACE_LOG("resolver:%p dns resolution failed: %s", r,
                          grpc_error_string(error));
     r->result_handler()->ReturnError(grpc_error_set_int(
         GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
             "DNS resolution failed", &error, 1),
         GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_UNAVAILABLE));
     // Set retry timer.
     grpc_millis next_try = r->backoff_.NextAttemptTime();
     grpc_millis timeout = next_try - ExecCtx::Get()->Now();
     GRPC_CARES_TRACE_LOG("resolver:%p dns resolution failed (will retry): %s",
                          r, grpc_error_string(error));
     GPR_ASSERT(!r->have_next_resolution_timer_);
     r->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.
     r->Ref(DEBUG_LOCATION, "retry-timer").release();
     if (timeout > 0) {
       GRPC_CARES_TRACE_LOG("resolver:%p retrying in %" PRId64 " milliseconds",
                            r, timeout);
     } else {
       GRPC_CARES_TRACE_LOG("resolver:%p retrying immediately", r);
     }
     grpc_timer_init(&r->next_resolution_timer_, next_try,
                     &r->on_next_resolution_);
   }
   r->Unref(DEBUG_LOCATION, "dns-resolving");
 }

 void AresDnsResolver::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) {
     const grpc_millis earliest_next_resolution =
         last_resolution_timestamp_ + min_time_between_resolutions_;
     const grpc_millis ms_until_next_resolution =
         earliest_next_resolution - grpc_core::ExecCtx::Get()->Now();
     if (ms_until_next_resolution > 0) {
       const grpc_millis last_resolution_ago =
           grpc_core::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);
       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,
                       &on_next_resolution_);
       return;
     }
   }
   StartResolvingLocked();
 }

 void AresDnsResolver::StartResolvingLocked() {
   // 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, "dns-resolving").release();
   GPR_ASSERT(!resolving_);
   resolving_ = true;
   service_config_json_ = nullptr;
   pending_request_ = grpc_dns_lookup_ares_locked(
       dns_server_, name_to_resolve_, kDefaultPort, interested_parties_,
       &on_resolved_, &addresses_, enable_srv_queries_ /* check_grpclb */,
       request_service_config_ ? &service_config_json_ : nullptr,
       query_timeout_ms_, combiner());
   last_resolution_timestamp_ = grpc_core::ExecCtx::Get()->Now();
   GRPC_CARES_TRACE_LOG("resolver:%p Started resolving. pending_request_:%p",
                        this, pending_request_);
 }

 //
 // Factory
 //

 class AresDnsResolverFactory : public ResolverFactory {
  public:
   bool IsValidUri(const grpc_uri* uri) const override { return true; }

   OrphanablePtr<Resolver> CreateResolver(ResolverArgs args) const override {
     return OrphanablePtr<Resolver>(New<AresDnsResolver>(std::move(args)));
   }

   const char* scheme() const override { return "dns"; }
 };

 }  // namespace

 }  // namespace grpc_core

 extern grpc_address_resolver_vtable* grpc_resolve_address_impl;
 static grpc_address_resolver_vtable* default_resolver;

 static grpc_error* blocking_resolve_address_ares(
     const char* name, const char* default_port,
     grpc_resolved_addresses** addresses) {
   return default_resolver->blocking_resolve_address(name, default_port,
                                                     addresses);
 }

 static grpc_address_resolver_vtable ares_resolver = {
     grpc_resolve_address_ares, blocking_resolve_address_ares};

 #ifdef GRPC_UV
 /* TODO(murgatroid99): Remove this when we want the cares resolver to be the
  * default when using libuv */
 static bool should_use_ares(const char* resolver_env) {
   return resolver_env != nullptr && gpr_stricmp(resolver_env, "ares") == 0;
 }
 #else  /* GRPC_UV */
 static bool should_use_ares(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);
 }
 #endif /* GRPC_UV */

 static bool g_use_ares_dns_resolver;

 void grpc_resolver_dns_ares_init() {
   grpc_core::UniquePtr<char> resolver =
       GPR_GLOBAL_CONFIG_GET(grpc_dns_resolver);
   if (should_use_ares(resolver.get())) {
     g_use_ares_dns_resolver = true;
     gpr_log(GPR_DEBUG, "Using ares dns resolver");
     address_sorting_init();
     grpc_error* error = grpc_ares_init();
     if (error != GRPC_ERROR_NONE) {
       GRPC_LOG_IF_ERROR("grpc_ares_init() failed", error);
       return;
     }
     if (default_resolver == nullptr) {
       default_resolver = grpc_resolve_address_impl;
     }
     grpc_set_resolver_impl(&ares_resolver);
     grpc_core::ResolverRegistry::Builder::RegisterResolverFactory(
         grpc_core::UniquePtr<grpc_core::ResolverFactory>(
             grpc_core::New<grpc_core::AresDnsResolverFactory>()));
   } else {
     g_use_ares_dns_resolver = false;
   }
 }

 void grpc_resolver_dns_ares_shutdown() {
   if (g_use_ares_dns_resolver) {
     address_sorting_shutdown();
     grpc_ares_cleanup();
   }
 }

 #else /* GRPC_ARES == 1 */

 void grpc_resolver_dns_ares_init(void) {}

 void grpc_resolver_dns_ares_shutdown(void) {}

 #endif /* GRPC_ARES == 1 */
	/*
	*
	* Copyright 2015 gRPC authors.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*
	*/

	#include <grpc/support/port_platform.h>

	#if GRPC_ARES == 1

	#include <limits.h>
	#include <stdio.h>
	#include <string.h>

	#include <grpc/support/alloc.h>
	#include <grpc/support/string_util.h>

	#include <address_sorting/address_sorting.h>

	#include "src/core/ext/filters/client_channel/http_connect_handshaker.h"
	#include "src/core/ext/filters/client_channel/lb_policy_registry.h"
	#include "src/core/ext/filters/client_channel/resolver/dns/c_ares/grpc_ares_wrapper.h"
	#include "src/core/ext/filters/client_channel/resolver/dns/dns_resolver_selection.h"
	#include "src/core/ext/filters/client_channel/resolver_registry.h"
	#include "src/core/ext/filters/client_channel/server_address.h"
	#include "src/core/ext/filters/client_channel/service_config.h"
	#include "src/core/lib/backoff/backoff.h"
	#include "src/core/lib/channel/channel_args.h"
	#include "src/core/lib/gpr/string.h"
	#include "src/core/lib/gprpp/manual_constructor.h"
	#include "src/core/lib/iomgr/combiner.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/json/json.h"

	#define GRPC_DNS_INITIAL_CONNECT_BACKOFF_SECONDS 1
	#define GRPC_DNS_RECONNECT_BACKOFF_MULTIPLIER 1.6
	#define GRPC_DNS_RECONNECT_MAX_BACKOFF_SECONDS 120
	#define GRPC_DNS_RECONNECT_JITTER 0.2

	namespace grpc_core {

	namespace {

	const char kDefaultPort[] = "https";

	class AresDnsResolver : public Resolver {
	public:
	explicit AresDnsResolver(ResolverArgs args);

	void StartLocked() override;

	void RequestReresolutionLocked() override;

	void ResetBackoffLocked() override;

	void ShutdownLocked() override;

	private:
	virtual ~AresDnsResolver();

	void MaybeStartResolvingLocked();
	void StartResolvingLocked();

	static void OnNextResolutionLocked(void* arg, grpc_error* error);
	static void OnResolvedLocked(void* arg, grpc_error* error);

	/// DNS server to use (if not system default)
	char* dns_server_;
	/// name to resolve (usually the same as target_name)
	char* name_to_resolve_;
	/// channel args
	grpc_channel_args* channel_args_;
	/// whether to request the service config
	bool request_service_config_;
	/// pollset_set to drive the name resolution process
	grpc_pollset_set* interested_parties_;
	/// closures used by the combiner
	grpc_closure on_next_resolution_;
	grpc_closure on_resolved_;
	/// are we currently resolving?
	bool resolving_ = false;
	/// the pending resolving request
	grpc_ares_request* pending_request_ = nullptr;
	/// next resolution timer
	bool have_next_resolution_timer_ = false;
	grpc_timer next_resolution_timer_;
	/// min interval between DNS requests
	grpc_millis min_time_between_resolutions_;
	/// timestamp of last DNS request
	grpc_millis last_resolution_timestamp_ = -1;
	/// retry backoff state
	BackOff backoff_;
	/// currently resolving addresses
	UniquePtr<ServerAddressList> addresses_;
	/// currently resolving service config
	char* service_config_json_ = nullptr;
	// has shutdown been initiated
	bool shutdown_initiated_ = false;
	// timeout in milliseconds for active DNS queries
	int query_timeout_ms_;
	// whether or not to enable SRV DNS queries
	bool enable_srv_queries_;
	};

	AresDnsResolver::AresDnsResolver(ResolverArgs args)
	: Resolver(args.combiner, std::move(args.result_handler)),
	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)) {
	// Get name to resolve from URI path.
	const char* path = args.uri->path;
	if (path[0] == '/') ++path;
	name_to_resolve_ = gpr_strdup(path);
	// Get DNS server from URI authority.
	dns_server_ = nullptr;
	if (0 != strcmp(args.uri->authority, "")) {
	dns_server_ = gpr_strdup(args.uri->authority);
	}
	channel_args_ = grpc_channel_args_copy(args.args);
	// Disable service config option
	const grpc_arg* arg = grpc_channel_args_find(
	channel_args_, GRPC_ARG_SERVICE_CONFIG_DISABLE_RESOLUTION);
	request_service_config_ = !grpc_channel_arg_get_bool(arg, true);
	// Min time b/t resolutions option
	arg = grpc_channel_args_find(channel_args_,
	GRPC_ARG_DNS_MIN_TIME_BETWEEN_RESOLUTIONS_MS);
	min_time_between_resolutions_ =
	grpc_channel_arg_get_integer(arg, {1000 * 30, 0, INT_MAX});
	// Enable SRV queries option
	arg = grpc_channel_args_find(channel_args_, GRPC_ARG_DNS_ENABLE_SRV_QUERIES);
	enable_srv_queries_ = grpc_channel_arg_get_bool(arg, false);
	interested_parties_ = grpc_pollset_set_create();
	if (args.pollset_set != nullptr) {
	grpc_pollset_set_add_pollset_set(interested_parties_, args.pollset_set);
	}
	GRPC_CLOSURE_INIT(&on_next_resolution_, OnNextResolutionLocked, this,
	grpc_combiner_scheduler(combiner()));
	GRPC_CLOSURE_INIT(&on_resolved_, OnResolvedLocked, this,
	grpc_combiner_scheduler(combiner()));
	const grpc_arg* query_timeout_ms_arg =
	grpc_channel_args_find(channel_args_, GRPC_ARG_DNS_ARES_QUERY_TIMEOUT_MS);
	query_timeout_ms_ = grpc_channel_arg_get_integer(
	query_timeout_ms_arg,
	{GRPC_DNS_ARES_DEFAULT_QUERY_TIMEOUT_MS, 0, INT_MAX});
	}

	AresDnsResolver::~AresDnsResolver() {
	GRPC_CARES_TRACE_LOG("resolver:%p destroying AresDnsResolver", this);
	grpc_pollset_set_destroy(interested_parties_);
	gpr_free(dns_server_);
	gpr_free(name_to_resolve_);
	grpc_channel_args_destroy(channel_args_);
	}

	void AresDnsResolver::StartLocked() {
	GRPC_CARES_TRACE_LOG("resolver:%p AresDnsResolver::StartLocked() is called.",
	this);
	MaybeStartResolvingLocked();
	}

	void AresDnsResolver::RequestReresolutionLocked() {
	if (!resolving_) {
	MaybeStartResolvingLocked();
	}
	}

	void AresDnsResolver::ResetBackoffLocked() {
	if (have_next_resolution_timer_) {
	grpc_timer_cancel(&next_resolution_timer_);
	}
	backoff_.Reset();
	}

	void AresDnsResolver::ShutdownLocked() {
	shutdown_initiated_ = true;
	if (have_next_resolution_timer_) {
	grpc_timer_cancel(&next_resolution_timer_);
	}
	if (pending_request_ != nullptr) {
	grpc_cancel_ares_request_locked(pending_request_);
	}
	}

	void AresDnsResolver::OnNextResolutionLocked(void* arg, grpc_error* error) {
	AresDnsResolver* r = static_cast<AresDnsResolver*>(arg);
	GRPC_CARES_TRACE_LOG(
	"resolver:%p re-resolution timer fired. error: %s. shutdown_initiated_: "
	"%d",
	r, grpc_error_string(error), r->shutdown_initiated_);
	r->have_next_resolution_timer_ = false;
	if (error == GRPC_ERROR_NONE && !r->shutdown_initiated_) {
	if (!r->resolving_) {
	GRPC_CARES_TRACE_LOG(
	"resolver:%p start resolving due to re-resolution timer", r);
	r->StartResolvingLocked();
	}
	}
	r->Unref(DEBUG_LOCATION, "next_resolution_timer");
	}

	bool ValueInJsonArray(grpc_json* array, const char* value) {
	for (grpc_json* entry = array->child; entry != nullptr; entry = entry->next) {
	if (entry->type == GRPC_JSON_STRING && strcmp(entry->value, value) == 0) {
	return true;
	}
	}
	return false;
	}

	char* ChooseServiceConfig(char* service_config_choice_json,
	grpc_error** error) {
	grpc_json* choices_json = grpc_json_parse_string(service_config_choice_json);
	if (choices_json == nullptr) {
	*error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
	"Service Config JSON Parsing, error: could not parse");
	return nullptr;
	}
	if (choices_json->type != GRPC_JSON_ARRAY) {
	*error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
	"Service Config Choices, error: should be of type array");
	return nullptr;
	}
	char* service_config = nullptr;
	InlinedVector<grpc_error*, 4> error_list;
	bool found_choice = false; // have we found a choice?
	for (grpc_json* choice = choices_json->child; choice != nullptr;
	choice = choice->next) {
	if (choice->type != GRPC_JSON_OBJECT) {
	error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
	"Service Config Choice, error: should be of type object"));
	continue;
	}
	grpc_json* service_config_json = nullptr;
	bool selected = true; // has this choice been rejected?
	for (grpc_json* field = choice->child; field != nullptr;
	field = field->next) {
	// Check client language, if specified.
	if (strcmp(field->key, "clientLanguage") == 0) {
	if (field->type != GRPC_JSON_ARRAY) {
	error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
	"field:clientLanguage error:should be of type array"));
	} else if (!ValueInJsonArray(field, "c++")) {
	selected = false;
	}
	}
	// Check client hostname, if specified.
	if (strcmp(field->key, "clientHostname") == 0) {
	if (field->type != GRPC_JSON_ARRAY) {
	error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
	"field:clientHostname error:should be of type array"));
	continue;
	}
	char* hostname = grpc_gethostname();
	if (hostname == nullptr \|\| !ValueInJsonArray(field, hostname)) {
	selected = false;
	}
	}
	// Check percentage, if specified.
	if (strcmp(field->key, "percentage") == 0) {
	if (field->type != GRPC_JSON_NUMBER) {
	error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
	"field:percentage error:should be of type number"));
	continue;
	}
	int random_pct = rand() % 100;
	int percentage;
	if (sscanf(field->value, "%d", &percentage) != 1) {
	error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
	"field:percentage error:should be of type integer"));
	continue;
	}
	if (random_pct > percentage \|\| percentage == 0) {
	selected = false;
	}
	}
	// Save service config.
	if (strcmp(field->key, "serviceConfig") == 0) {
	if (field->type == GRPC_JSON_OBJECT) {
	service_config_json = field;
	} else {
	error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
	"field:serviceConfig error:should be of type object"));
	}
	}
	}
	if (!found_choice && selected && service_config_json != nullptr) {
	service_config = grpc_json_dump_to_string(service_config_json, 0);
	found_choice = true;
	}
	}
	grpc_json_destroy(choices_json);
	if (!error_list.empty()) {
	gpr_free(service_config);
	service_config = nullptr;
	*error = GRPC_ERROR_CREATE_FROM_VECTOR("Service Config Choices Parser",
	&error_list);
	}
	return service_config;
	}

	void AresDnsResolver::OnResolvedLocked(void* arg, grpc_error* error) {
	AresDnsResolver* r = static_cast<AresDnsResolver*>(arg);
	GPR_ASSERT(r->resolving_);
	r->resolving_ = false;
	gpr_free(r->pending_request_);
	r->pending_request_ = nullptr;
	if (r->shutdown_initiated_) {
	r->Unref(DEBUG_LOCATION, "OnResolvedLocked() shutdown");
	return;
	}
	if (r->addresses_ != nullptr) {
	Result result;
	result.addresses = std::move(*r->addresses_);
	if (r->service_config_json_ != nullptr) {
	char* service_config_string = ChooseServiceConfig(
	r->service_config_json_, &result.service_config_error);
	gpr_free(r->service_config_json_);
	if (result.service_config_error == GRPC_ERROR_NONE &&
	service_config_string != nullptr) {
	GRPC_CARES_TRACE_LOG("resolver:%p selected service config choice: %s",
	r, service_config_string);
	result.service_config = ServiceConfig::Create(
	service_config_string, &result.service_config_error);
	}
	gpr_free(service_config_string);
	}
	result.args = grpc_channel_args_copy(r->channel_args_);
	r->result_handler()->ReturnResult(std::move(result));
	r->addresses_.reset();
	// Reset backoff state so that we start from the beginning when the
	// next request gets triggered.
	r->backoff_.Reset();
	} else {
	GRPC_CARES_TRACE_LOG("resolver:%p dns resolution failed: %s", r,
	grpc_error_string(error));
	r->result_handler()->ReturnError(grpc_error_set_int(
	GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
	"DNS resolution failed", &error, 1),
	GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_UNAVAILABLE));
	// Set retry timer.
	grpc_millis next_try = r->backoff_.NextAttemptTime();
	grpc_millis timeout = next_try - ExecCtx::Get()->Now();
	GRPC_CARES_TRACE_LOG("resolver:%p dns resolution failed (will retry): %s",
	r, grpc_error_string(error));
	GPR_ASSERT(!r->have_next_resolution_timer_);
	r->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.
	r->Ref(DEBUG_LOCATION, "retry-timer").release();
	if (timeout > 0) {
	GRPC_CARES_TRACE_LOG("resolver:%p retrying in %" PRId64 " milliseconds",
	r, timeout);
	} else {
	GRPC_CARES_TRACE_LOG("resolver:%p retrying immediately", r);
	}
	grpc_timer_init(&r->next_resolution_timer_, next_try,
	&r->on_next_resolution_);
	}
	r->Unref(DEBUG_LOCATION, "dns-resolving");
	}

	void AresDnsResolver::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) {
	const grpc_millis earliest_next_resolution =
	last_resolution_timestamp_ + min_time_between_resolutions_;
	const grpc_millis ms_until_next_resolution =
	earliest_next_resolution - grpc_core::ExecCtx::Get()->Now();
	if (ms_until_next_resolution > 0) {
	const grpc_millis last_resolution_ago =
	grpc_core::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);
	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,
	&on_next_resolution_);
	return;
	}
	}
	StartResolvingLocked();
	}

	void AresDnsResolver::StartResolvingLocked() {
	// 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, "dns-resolving").release();
	GPR_ASSERT(!resolving_);
	resolving_ = true;
	service_config_json_ = nullptr;
	pending_request_ = grpc_dns_lookup_ares_locked(
	dns_server_, name_to_resolve_, kDefaultPort, interested_parties_,
	&on_resolved_, &addresses_, enable_srv_queries_ /* check_grpclb */,
	request_service_config_ ? &service_config_json_ : nullptr,
	query_timeout_ms_, combiner());
	last_resolution_timestamp_ = grpc_core::ExecCtx::Get()->Now();
	GRPC_CARES_TRACE_LOG("resolver:%p Started resolving. pending_request_:%p",
	this, pending_request_);
	}

	//
	// Factory
	//

	class AresDnsResolverFactory : public ResolverFactory {
	public:
	bool IsValidUri(const grpc_uri* uri) const override { return true; }

	OrphanablePtr<Resolver> CreateResolver(ResolverArgs args) const override {
	return OrphanablePtr<Resolver>(New<AresDnsResolver>(std::move(args)));
	}

	const char* scheme() const override { return "dns"; }
	};

	} // namespace

	} // namespace grpc_core

	extern grpc_address_resolver_vtable* grpc_resolve_address_impl;
	static grpc_address_resolver_vtable* default_resolver;

	static grpc_error* blocking_resolve_address_ares(
	const char* name, const char* default_port,
	grpc_resolved_addresses** addresses) {
	return default_resolver->blocking_resolve_address(name, default_port,
	addresses);
	}

	static grpc_address_resolver_vtable ares_resolver = {
	grpc_resolve_address_ares, blocking_resolve_address_ares};

	#ifdef GRPC_UV
	/* TODO(murgatroid99): Remove this when we want the cares resolver to be the
	* default when using libuv */
	static bool should_use_ares(const char* resolver_env) {
	return resolver_env != nullptr && gpr_stricmp(resolver_env, "ares") == 0;
	}
	#else /* GRPC_UV */
	static bool should_use_ares(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);
	}
	#endif /* GRPC_UV */

	static bool g_use_ares_dns_resolver;

	void grpc_resolver_dns_ares_init() {
	grpc_core::UniquePtr<char> resolver =
	GPR_GLOBAL_CONFIG_GET(grpc_dns_resolver);
	if (should_use_ares(resolver.get())) {
	g_use_ares_dns_resolver = true;
	gpr_log(GPR_DEBUG, "Using ares dns resolver");
	address_sorting_init();
	grpc_error* error = grpc_ares_init();
	if (error != GRPC_ERROR_NONE) {
	GRPC_LOG_IF_ERROR("grpc_ares_init() failed", error);
	return;
	}
	if (default_resolver == nullptr) {
	default_resolver = grpc_resolve_address_impl;
	}
	grpc_set_resolver_impl(&ares_resolver);
	grpc_core::ResolverRegistry::Builder::RegisterResolverFactory(
	grpc_core::UniquePtr<grpc_core::ResolverFactory>(
	grpc_core::New<grpc_core::AresDnsResolverFactory>()));
	} else {
	g_use_ares_dns_resolver = false;
	}
	}

	void grpc_resolver_dns_ares_shutdown() {
	if (g_use_ares_dns_resolver) {
	address_sorting_shutdown();
	grpc_ares_cleanup();
	}
	}

	#else /* GRPC_ARES == 1 */

	void grpc_resolver_dns_ares_init(void) {}

	void grpc_resolver_dns_ares_shutdown(void) {}

	#endif /* GRPC_ARES == 1 */