From 209f644f047ccf8ab13b207ebb145dadc0d37a42 Mon Sep 17 00:00:00 2001 From: "Mark D. Roth" Date: Thu, 8 Feb 2018 10:26:46 -0800 Subject: Convert resolver API to C++. --- .../resolver/dns/c_ares/dns_resolver_ares.cc | 507 ++++++++++----------- .../resolver/dns/native/dns_resolver.cc | 449 +++++++++--------- .../client_channel/resolver/fake/fake_resolver.cc | 326 ++++++------- .../client_channel/resolver/fake/fake_resolver.h | 77 ++-- .../resolver/sockaddr/sockaddr_resolver.cc | 250 +++++----- 5 files changed, 789 insertions(+), 820 deletions(-) (limited to 'src/core/ext/filters/client_channel/resolver') diff --git a/src/core/ext/filters/client_channel/resolver/dns/c_ares/dns_resolver_ares.cc b/src/core/ext/filters/client_channel/resolver/dns/c_ares/dns_resolver_ares.cc index f2f25bc7c0..6e03ae447f 100644 --- a/src/core/ext/filters/client_channel/resolver/dns/c_ares/dns_resolver_ares.cc +++ b/src/core/ext/filters/client_channel/resolver/dns/c_ares/dns_resolver_ares.cc @@ -49,109 +49,168 @@ #define GRPC_DNS_RECONNECT_MAX_BACKOFF_SECONDS 120 #define GRPC_DNS_RECONNECT_JITTER 0.2 -typedef struct { - /** base class: must be first */ - grpc_resolver base; - /** DNS server to use (if not system default) */ - char* dns_server; - /** name to resolve (usually the same as target_name) */ - char* name_to_resolve; - /** default port to use */ - char* default_port; - /** 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 dns_ares_on_next_resolution_timer_closure; - grpc_closure dns_ares_on_resolved_closure; - - /** Combiner guarding the rest of the state */ - grpc_combiner* combiner; - /** are we currently resolving? */ - bool resolving; - /** the pending resolving request */ - grpc_ares_request* pending_request; - /** which version of the result have we published? */ - int published_version; - /** which version of the result is current? */ - int resolved_version; - /** pending next completion, or NULL */ - grpc_closure* next_completion; - /** target result address for next completion */ - grpc_channel_args** target_result; - /** current (fully resolved) result */ - grpc_channel_args* resolved_result; - /** next resolution timer */ - bool have_next_resolution_timer; - grpc_timer next_resolution_timer; - /** retry backoff state */ - grpc_core::ManualConstructor backoff; - /** min resolution period. Max one resolution will happen per period */ - grpc_millis min_time_between_resolutions; - /** when was the last resolution? -1 if no resolution has happened yet */ - grpc_millis last_resolution_timestamp; - /** currently resolving addresses */ - grpc_lb_addresses* lb_addresses; - /** currently resolving service config */ - char* service_config_json; -} ares_dns_resolver; - -static void dns_ares_destroy(grpc_resolver* r); - -static void dns_ares_start_resolving_locked(ares_dns_resolver* r); -static void dns_ares_maybe_start_resolving_locked(ares_dns_resolver* r); -static void dns_ares_maybe_finish_next_locked(ares_dns_resolver* r); - -static void dns_ares_shutdown_locked(grpc_resolver* r); -static void dns_ares_channel_saw_error_locked(grpc_resolver* r); -static void dns_ares_next_locked(grpc_resolver* r, - grpc_channel_args** target_result, - grpc_closure* on_complete); - -static const grpc_resolver_vtable dns_ares_resolver_vtable = { - dns_ares_destroy, dns_ares_shutdown_locked, - dns_ares_channel_saw_error_locked, dns_ares_next_locked}; - -static void dns_ares_shutdown_locked(grpc_resolver* resolver) { - ares_dns_resolver* r = (ares_dns_resolver*)resolver; - if (r->have_next_resolution_timer) { - grpc_timer_cancel(&r->next_resolution_timer); +namespace grpc_core { + +namespace { + +const char kDefaultPort[] = "https"; + +class AresDnsResolver : public Resolver { + public: + explicit AresDnsResolver(const ResolverArgs& args); + + void NextLocked(grpc_channel_args** result, + grpc_closure* on_complete) override; + + void RequestReresolutionLocked() override; + + void ShutdownLocked() override; + + private: + virtual ~AresDnsResolver(); + + void MaybeStartResolvingLocked(); + void StartResolvingLocked(); + void MaybeFinishNextLocked(); + + 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; + /// which version of the result have we published? + int published_version_ = 0; + /// which version of the result is current? + int resolved_version_ = 0; + /// pending next completion, or NULL + grpc_closure* next_completion_ = nullptr; + /// target result address for next completion + grpc_channel_args** target_result_ = nullptr; + /// current (fully resolved) result + grpc_channel_args* resolved_result_ = 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 + grpc_lb_addresses* lb_addresses_ = nullptr; + /// currently resolving service config + char* service_config_json_ = nullptr; +}; + +AresDnsResolver::AresDnsResolver(const ResolverArgs& args) + : Resolver(args.combiner), + 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. + if (0 != strcmp(args.uri->authority, "")) { + dns_server_ = gpr_strdup(args.uri->authority); + } + channel_args_ = grpc_channel_args_copy(args.args); + const grpc_arg* arg = grpc_channel_args_find( + channel_args_, GRPC_ARG_SERVICE_CONFIG_DISABLE_RESOLUTION); + request_service_config_ = !grpc_channel_arg_get_integer( + arg, (grpc_integer_options){false, false, true}); + 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, 0, INT_MAX}); + 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())); +} + +AresDnsResolver::~AresDnsResolver() { + gpr_log(GPR_DEBUG, "destroying AresDnsResolver"); + if (resolved_result_ != nullptr) { + grpc_channel_args_destroy(resolved_result_); } - if (r->pending_request != nullptr) { - grpc_cancel_ares_request(r->pending_request); + grpc_pollset_set_destroy(interested_parties_); + gpr_free(dns_server_); + gpr_free(name_to_resolve_); + grpc_channel_args_destroy(channel_args_); +} + +void AresDnsResolver::NextLocked(grpc_channel_args** target_result, + grpc_closure* on_complete) { + gpr_log(GPR_DEBUG, "AresDnsResolver::NextLocked() is called."); + GPR_ASSERT(next_completion_ == nullptr); + next_completion_ = on_complete; + target_result_ = target_result; + if (resolved_version_ == 0 && !resolving_) { + MaybeStartResolvingLocked(); + } else { + MaybeFinishNextLocked(); } - if (r->next_completion != nullptr) { - *r->target_result = nullptr; - GRPC_CLOSURE_SCHED(r->next_completion, GRPC_ERROR_CREATE_FROM_STATIC_STRING( - "Resolver Shutdown")); - r->next_completion = nullptr; +} + +void AresDnsResolver::RequestReresolutionLocked() { + if (!resolving_) { + MaybeStartResolvingLocked(); } } -static void dns_ares_channel_saw_error_locked(grpc_resolver* resolver) { - ares_dns_resolver* r = (ares_dns_resolver*)resolver; - if (!r->resolving) { - dns_ares_maybe_start_resolving_locked(r); +void AresDnsResolver::ShutdownLocked() { + if (have_next_resolution_timer_) { + grpc_timer_cancel(&next_resolution_timer_); + } + if (pending_request_ != nullptr) { + grpc_cancel_ares_request(pending_request_); + } + if (next_completion_ != nullptr) { + *target_result_ = nullptr; + GRPC_CLOSURE_SCHED(next_completion_, GRPC_ERROR_CREATE_FROM_STATIC_STRING( + "Resolver Shutdown")); + next_completion_ = nullptr; } } -static void dns_ares_on_next_resolution_timer_locked(void* arg, - grpc_error* error) { - ares_dns_resolver* r = (ares_dns_resolver*)arg; - r->have_next_resolution_timer = false; +void AresDnsResolver::OnNextResolutionLocked(void* arg, grpc_error* error) { + AresDnsResolver* r = static_cast(arg); + r->have_next_resolution_timer_ = false; if (error == GRPC_ERROR_NONE) { - if (!r->resolving) { - dns_ares_start_resolving_locked(r); + if (!r->resolving_) { + r->StartResolvingLocked(); } } - GRPC_RESOLVER_UNREF(&r->base, "next_resolution_timer"); + r->Unref(DEBUG_LOCATION, "next_resolution_timer"); } -static bool value_in_json_array(grpc_json* array, const char* value) { +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; @@ -160,7 +219,7 @@ static bool value_in_json_array(grpc_json* array, const char* value) { return false; } -static char* choose_service_config(char* service_config_choice_json) { +char* ChooseServiceConfig(char* service_config_choice_json) { grpc_json* choices_json = grpc_json_parse_string(service_config_choice_json); if (choices_json == nullptr || choices_json->type != GRPC_JSON_ARRAY) { gpr_log(GPR_ERROR, "cannot parse service config JSON string"); @@ -178,8 +237,7 @@ static char* choose_service_config(char* service_config_choice_json) { field = field->next) { // Check client language, if specified. if (strcmp(field->key, "clientLanguage") == 0) { - if (field->type != GRPC_JSON_ARRAY || - !value_in_json_array(field, "c++")) { + if (field->type != GRPC_JSON_ARRAY || !ValueInJsonArray(field, "c++")) { service_config_json = nullptr; break; } @@ -188,7 +246,7 @@ static char* choose_service_config(char* service_config_choice_json) { if (strcmp(field->key, "clientHostname") == 0) { char* hostname = grpc_gethostname(); if (hostname == nullptr || field->type != GRPC_JSON_ARRAY || - !value_in_json_array(field, hostname)) { + !ValueInJsonArray(field, hostname)) { service_config_json = nullptr; break; } @@ -223,24 +281,24 @@ static char* choose_service_config(char* service_config_choice_json) { return service_config; } -static void dns_ares_on_resolved_locked(void* arg, grpc_error* error) { - ares_dns_resolver* r = (ares_dns_resolver*)arg; +void AresDnsResolver::OnResolvedLocked(void* arg, grpc_error* error) { + AresDnsResolver* r = static_cast(arg); grpc_channel_args* result = nullptr; - GPR_ASSERT(r->resolving); - r->resolving = false; - r->pending_request = nullptr; - if (r->lb_addresses != nullptr) { + GPR_ASSERT(r->resolving_); + r->resolving_ = false; + r->pending_request_ = nullptr; + if (r->lb_addresses_ != nullptr) { static const char* args_to_remove[2]; size_t num_args_to_remove = 0; grpc_arg new_args[3]; size_t num_args_to_add = 0; new_args[num_args_to_add++] = - grpc_lb_addresses_create_channel_arg(r->lb_addresses); + grpc_lb_addresses_create_channel_arg(r->lb_addresses_); grpc_service_config* service_config = nullptr; char* service_config_string = nullptr; - if (r->service_config_json != nullptr) { - service_config_string = choose_service_config(r->service_config_json); - gpr_free(r->service_config_json); + if (r->service_config_json_ != nullptr) { + service_config_string = ChooseServiceConfig(r->service_config_json_); + gpr_free(r->service_config_json_); if (service_config_string != nullptr) { gpr_log(GPR_INFO, "selected service config choice: %s", service_config_string); @@ -260,221 +318,150 @@ static void dns_ares_on_resolved_locked(void* arg, grpc_error* error) { } } result = grpc_channel_args_copy_and_add_and_remove( - r->channel_args, args_to_remove, num_args_to_remove, new_args, + r->channel_args_, args_to_remove, num_args_to_remove, new_args, num_args_to_add); if (service_config != nullptr) grpc_service_config_destroy(service_config); gpr_free(service_config_string); - grpc_lb_addresses_destroy(r->lb_addresses); + grpc_lb_addresses_destroy(r->lb_addresses_); // Reset backoff state so that we start from the beginning when the // next request gets triggered. - r->backoff->Reset(); + r->backoff_.Reset(); } else { const char* msg = grpc_error_string(error); gpr_log(GPR_DEBUG, "dns resolution failed: %s", msg); - grpc_millis next_try = r->backoff->NextAttemptTime(); - grpc_millis timeout = next_try - grpc_core::ExecCtx::Get()->Now(); + grpc_millis next_try = r->backoff_.NextAttemptTime(); + grpc_millis timeout = next_try - ExecCtx::Get()->Now(); gpr_log(GPR_INFO, "dns resolution failed (will retry): %s", grpc_error_string(error)); - GPR_ASSERT(!r->have_next_resolution_timer); - r->have_next_resolution_timer = true; - GRPC_RESOLVER_REF(&r->base, "next_resolution_timer"); + 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. + RefCountedPtr self = r->Ref(DEBUG_LOCATION, "retry-timer"); + self.release(); if (timeout > 0) { gpr_log(GPR_DEBUG, "retrying in %" PRIdPTR " milliseconds", timeout); } else { gpr_log(GPR_DEBUG, "retrying immediately"); } - grpc_timer_init(&r->next_resolution_timer, next_try, - &r->dns_ares_on_next_resolution_timer_closure); + grpc_timer_init(&r->next_resolution_timer_, next_try, + &r->on_next_resolution_); } - if (r->resolved_result != nullptr) { - grpc_channel_args_destroy(r->resolved_result); - } - r->resolved_result = result; - r->last_resolution_timestamp = grpc_core::ExecCtx::Get()->Now(); - r->resolved_version++; - dns_ares_maybe_finish_next_locked(r); - GRPC_RESOLVER_UNREF(&r->base, "dns-resolving"); -} - -static void dns_ares_next_locked(grpc_resolver* resolver, - grpc_channel_args** target_result, - grpc_closure* on_complete) { - gpr_log(GPR_DEBUG, "dns_ares_next is called."); - ares_dns_resolver* r = (ares_dns_resolver*)resolver; - GPR_ASSERT(!r->next_completion); - r->next_completion = on_complete; - r->target_result = target_result; - if (r->resolved_version == 0 && !r->resolving) { - dns_ares_maybe_start_resolving_locked(r); - } else { - dns_ares_maybe_finish_next_locked(r); + if (r->resolved_result_ != nullptr) { + grpc_channel_args_destroy(r->resolved_result_); } + r->resolved_result_ = result; + ++r->resolved_version_; + r->MaybeFinishNextLocked(); + r->Unref(DEBUG_LOCATION, "dns-resolving"); } -static void dns_ares_start_resolving_locked(ares_dns_resolver* r) { - GRPC_RESOLVER_REF(&r->base, "dns-resolving"); - GPR_ASSERT(!r->resolving); - r->resolving = true; - r->lb_addresses = nullptr; - r->service_config_json = nullptr; - r->pending_request = grpc_dns_lookup_ares( - r->dns_server, r->name_to_resolve, r->default_port, r->interested_parties, - &r->dns_ares_on_resolved_closure, &r->lb_addresses, - true /* check_grpclb */, - r->request_service_config ? &r->service_config_json : nullptr); -} - -static void dns_ares_maybe_finish_next_locked(ares_dns_resolver* r) { - if (r->next_completion != nullptr && - r->resolved_version != r->published_version) { - *r->target_result = r->resolved_result == nullptr - ? nullptr - : grpc_channel_args_copy(r->resolved_result); - gpr_log(GPR_DEBUG, "dns_ares_maybe_finish_next_locked"); - GRPC_CLOSURE_SCHED(r->next_completion, GRPC_ERROR_NONE); - r->next_completion = nullptr; - r->published_version = r->resolved_version; - } -} - -static void dns_ares_maybe_start_resolving_locked(ares_dns_resolver* r) { - if (r->last_resolution_timestamp >= 0) { +void AresDnsResolver::MaybeStartResolvingLocked() { + if (last_resolution_timestamp_ >= 0) { const grpc_millis earliest_next_resolution = - r->last_resolution_timestamp + r->min_time_between_resolutions; + 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() - r->last_resolution_timestamp; + grpc_core::ExecCtx::Get()->Now() - last_resolution_timestamp_; gpr_log(GPR_DEBUG, "In cooldown from last resolution (from %" PRIdPTR " ms ago). Will resolve again in %" PRIdPTR " ms", last_resolution_ago, ms_until_next_resolution); - if (!r->have_next_resolution_timer) { - r->have_next_resolution_timer = true; - GRPC_RESOLVER_REF(&r->base, "next_resolution_timer_cooldown"); - grpc_timer_init(&r->next_resolution_timer, ms_until_next_resolution, - &r->dns_ares_on_next_resolution_timer_closure); + if (!have_next_resolution_timer_) { + 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. + RefCountedPtr self = + Ref(DEBUG_LOCATION, "next_resolution_timer_cooldown"); + self.release(); + grpc_timer_init(&next_resolution_timer_, ms_until_next_resolution, + &on_next_resolution_); } // TODO(dgq): remove the following two lines once Pick First stops // discarding subchannels after selecting. - ++r->resolved_version; - dns_ares_maybe_finish_next_locked(r); + ++resolved_version_; + MaybeFinishNextLocked(); return; } } - dns_ares_start_resolving_locked(r); + StartResolvingLocked(); } -static void dns_ares_destroy(grpc_resolver* gr) { - gpr_log(GPR_DEBUG, "dns_ares_destroy"); - ares_dns_resolver* r = (ares_dns_resolver*)gr; - if (r->resolved_result != nullptr) { - grpc_channel_args_destroy(r->resolved_result); - } - grpc_pollset_set_destroy(r->interested_parties); - gpr_free(r->dns_server); - gpr_free(r->name_to_resolve); - gpr_free(r->default_port); - grpc_channel_args_destroy(r->channel_args); - gpr_free(r); +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. + RefCountedPtr self = Ref(DEBUG_LOCATION, "dns-resolving"); + self.release(); + GPR_ASSERT(!resolving_); + resolving_ = true; + lb_addresses_ = nullptr; + service_config_json_ = nullptr; + pending_request_ = grpc_dns_lookup_ares( + dns_server_, name_to_resolve_, kDefaultPort, interested_parties_, + &on_resolved_, &lb_addresses_, true /* check_grpclb */, + request_service_config_ ? &service_config_json_ : nullptr); + last_resolution_timestamp_ = grpc_core::ExecCtx::Get()->Now(); } -static grpc_resolver* dns_ares_create(grpc_resolver_args* args, - const char* default_port) { - /* Get name from args. */ - const char* path = args->uri->path; - if (path[0] == '/') ++path; - /* Create resolver. */ - ares_dns_resolver* r = - (ares_dns_resolver*)gpr_zalloc(sizeof(ares_dns_resolver)); - grpc_resolver_init(&r->base, &dns_ares_resolver_vtable, args->combiner); - if (0 != strcmp(args->uri->authority, "")) { - r->dns_server = gpr_strdup(args->uri->authority); - } - r->name_to_resolve = gpr_strdup(path); - r->default_port = gpr_strdup(default_port); - r->channel_args = grpc_channel_args_copy(args->args); - const grpc_arg* arg = grpc_channel_args_find( - r->channel_args, GRPC_ARG_SERVICE_CONFIG_DISABLE_RESOLUTION); - r->request_service_config = !grpc_channel_arg_get_integer( - arg, (grpc_integer_options){false, false, true}); - r->interested_parties = grpc_pollset_set_create(); - if (args->pollset_set != nullptr) { - grpc_pollset_set_add_pollset_set(r->interested_parties, args->pollset_set); +void AresDnsResolver::MaybeFinishNextLocked() { + if (next_completion_ != nullptr && resolved_version_ != published_version_) { + *target_result_ = resolved_result_ == nullptr + ? nullptr + : grpc_channel_args_copy(resolved_result_); + gpr_log(GPR_DEBUG, "AresDnsResolver::MaybeFinishNextLocked()"); + GRPC_CLOSURE_SCHED(next_completion_, GRPC_ERROR_NONE); + next_completion_ = nullptr; + published_version_ = resolved_version_; } - grpc_core::BackOff::Options backoff_options; - 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); - r->backoff.Init(grpc_core::BackOff(backoff_options)); - GRPC_CLOSURE_INIT(&r->dns_ares_on_next_resolution_timer_closure, - dns_ares_on_next_resolution_timer_locked, r, - grpc_combiner_scheduler(r->base.combiner)); - GRPC_CLOSURE_INIT(&r->dns_ares_on_resolved_closure, - dns_ares_on_resolved_locked, r, - grpc_combiner_scheduler(r->base.combiner)); - const grpc_arg* period_arg = grpc_channel_args_find( - args->args, GRPC_ARG_DNS_MIN_TIME_BETWEEN_RESOLUTIONS_MS); - r->min_time_between_resolutions = - grpc_channel_arg_get_integer(period_arg, {1000, 0, INT_MAX}); - r->last_resolution_timestamp = -1; - return &r->base; } -/* - * FACTORY - */ - -static void dns_ares_factory_ref(grpc_resolver_factory* factory) {} +// +// Factory +// -static void dns_ares_factory_unref(grpc_resolver_factory* factory) {} - -static grpc_resolver* dns_factory_create_resolver( - grpc_resolver_factory* factory, grpc_resolver_args* args) { - return dns_ares_create(args, "https"); -} +class AresDnsResolverFactory : public ResolverFactory { + public: + OrphanablePtr CreateResolver( + const ResolverArgs& args) const override { + return OrphanablePtr(New(args)); + } -static char* dns_ares_factory_get_default_host_name( - grpc_resolver_factory* factory, grpc_uri* uri) { - const char* path = uri->path; - if (path[0] == '/') ++path; - return gpr_strdup(path); -} + const char* scheme() const override { return "dns"; } +}; -static const grpc_resolver_factory_vtable dns_ares_factory_vtable = { - dns_ares_factory_ref, dns_ares_factory_unref, dns_factory_create_resolver, - dns_ares_factory_get_default_host_name, "dns"}; -static grpc_resolver_factory dns_resolver_factory = {&dns_ares_factory_vtable}; +} // namespace -static grpc_resolver_factory* dns_ares_resolver_factory_create() { - return &dns_resolver_factory; -} +} // namespace grpc_core -void grpc_resolver_dns_ares_init(void) { - char* resolver = gpr_getenv("GRPC_DNS_RESOLVER"); +void grpc_resolver_dns_ares_init() { + char* resolver_env = gpr_getenv("GRPC_DNS_RESOLVER"); /* TODO(zyc): Turn on c-ares based resolver by default after the address sorter and the CNAME support are added. */ - if (resolver != nullptr && gpr_stricmp(resolver, "ares") == 0) { + if (resolver_env != nullptr && gpr_stricmp(resolver_env, "ares") == 0) { grpc_error* error = grpc_ares_init(); if (error != GRPC_ERROR_NONE) { GRPC_LOG_IF_ERROR("ares_library_init() failed", error); return; } grpc_resolve_address = grpc_resolve_address_ares; - grpc_register_resolver_type(dns_ares_resolver_factory_create()); + grpc_core::ResolverRegistry::Builder::RegisterResolverFactory( + grpc_core::UniquePtr( + grpc_core::New())); } - gpr_free(resolver); + gpr_free(resolver_env); } -void grpc_resolver_dns_ares_shutdown(void) { - char* resolver = gpr_getenv("GRPC_DNS_RESOLVER"); - if (resolver != nullptr && gpr_stricmp(resolver, "ares") == 0) { +void grpc_resolver_dns_ares_shutdown() { + char* resolver_env = gpr_getenv("GRPC_DNS_RESOLVER"); + if (resolver_env != nullptr && gpr_stricmp(resolver_env, "ares") == 0) { grpc_ares_cleanup(); } - gpr_free(resolver); + gpr_free(resolver_env); } #else /* GRPC_ARES == 1 && !defined(GRPC_UV) */ diff --git a/src/core/ext/filters/client_channel/resolver/dns/native/dns_resolver.cc b/src/core/ext/filters/client_channel/resolver/dns/native/dns_resolver.cc index 478810d263..fbab136421 100644 --- a/src/core/ext/filters/client_channel/resolver/dns/native/dns_resolver.cc +++ b/src/core/ext/filters/client_channel/resolver/dns/native/dns_resolver.cc @@ -43,301 +43,298 @@ #define GRPC_DNS_RECONNECT_MAX_BACKOFF_SECONDS 120 #define GRPC_DNS_RECONNECT_JITTER 0.2 -typedef struct { - /** base class: must be first */ - grpc_resolver base; - /** name to resolve */ - char* name_to_resolve; - /** default port to use */ - char* default_port; - /** channel args. */ - grpc_channel_args* channel_args; - /** pollset_set to drive the name resolution process */ - grpc_pollset_set* interested_parties; - - /** are we currently resolving? */ - bool resolving; - /** which version of the result have we published? */ - int published_version; - /** which version of the result is current? */ - int resolved_version; - /** pending next completion, or NULL */ - grpc_closure* next_completion; - /** target result address for next completion */ - grpc_channel_args** target_result; - /** current (fully resolved) result */ - grpc_channel_args* resolved_result; - /** next resolution timer */ - bool have_next_resolution_timer; - grpc_timer next_resolution_timer; - grpc_closure next_resolution_closure; - /** retry backoff state */ - grpc_core::ManualConstructor backoff; - /** min resolution period. Max one resolution will happen per period */ - grpc_millis min_time_between_resolutions; - /** when was the last resolution? -1 if no resolution has happened yet */ - grpc_millis last_resolution_timestamp; - /** currently resolving addresses */ - grpc_resolved_addresses* addresses; -} dns_resolver; - -static void dns_destroy(grpc_resolver* r); - -static void dns_start_resolving_locked(dns_resolver* r); -static void maybe_start_resolving_locked(dns_resolver* r); -static void dns_maybe_finish_next_locked(dns_resolver* r); - -static void dns_shutdown_locked(grpc_resolver* r); -static void dns_channel_saw_error_locked(grpc_resolver* r); -static void dns_next_locked(grpc_resolver* r, grpc_channel_args** target_result, - grpc_closure* on_complete); - -static const grpc_resolver_vtable dns_resolver_vtable = { - dns_destroy, dns_shutdown_locked, dns_channel_saw_error_locked, - dns_next_locked}; - -static void dns_shutdown_locked(grpc_resolver* resolver) { - dns_resolver* r = (dns_resolver*)resolver; - if (r->have_next_resolution_timer) { - grpc_timer_cancel(&r->next_resolution_timer); - } - if (r->next_completion != nullptr) { - *r->target_result = nullptr; - GRPC_CLOSURE_SCHED(r->next_completion, GRPC_ERROR_CREATE_FROM_STATIC_STRING( - "Resolver Shutdown")); - r->next_completion = nullptr; +namespace grpc_core { + +namespace { + +const char kDefaultPort[] = "https"; + +class NativeDnsResolver : public Resolver { + public: + explicit NativeDnsResolver(const ResolverArgs& args); + + void NextLocked(grpc_channel_args** result, + grpc_closure* on_complete) override; + + void RequestReresolutionLocked() override; + + void ShutdownLocked() override; + + private: + virtual ~NativeDnsResolver(); + + void MaybeStartResolvingLocked(); + void StartResolvingLocked(); + void MaybeFinishNextLocked(); + + static void OnNextResolutionLocked(void* arg, grpc_error* error); + static void OnResolvedLocked(void* arg, grpc_error* error); + + /// name to resolve + char* name_to_resolve_ = nullptr; + /// channel args + grpc_channel_args* channel_args_ = nullptr; + /// pollset_set to drive the name resolution process + grpc_pollset_set* interested_parties_ = nullptr; + /// are we currently resolving? + bool resolving_ = false; + grpc_closure on_resolved_; + /// which version of the result have we published? + int published_version_ = 0; + /// which version of the result is current? + int resolved_version_ = 0; + /// pending next completion, or nullptr + grpc_closure* next_completion_ = nullptr; + /// target result address for next completion + grpc_channel_args** target_result_ = nullptr; + /// current (fully resolved) result + grpc_channel_args* resolved_result_ = nullptr; + /// next resolution timer + bool have_next_resolution_timer_ = false; + grpc_timer next_resolution_timer_; + grpc_closure on_next_resolution_; + /// min time 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 + grpc_resolved_addresses* addresses_ = nullptr; +}; + +NativeDnsResolver::NativeDnsResolver(const ResolverArgs& args) + : Resolver(args.combiner), + 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)) { + char* path = args.uri->path; + if (path[0] == '/') ++path; + name_to_resolve_ = gpr_strdup(path); + channel_args_ = grpc_channel_args_copy(args.args); + const grpc_arg* arg = grpc_channel_args_find( + args.args, GRPC_ARG_DNS_MIN_TIME_BETWEEN_RESOLUTIONS_MS); + min_time_between_resolutions_ = + grpc_channel_arg_get_integer(arg, {1000, 0, INT_MAX}); + 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_, + NativeDnsResolver::OnNextResolutionLocked, this, + grpc_combiner_scheduler(args.combiner)); + GRPC_CLOSURE_INIT(&on_resolved_, NativeDnsResolver::OnResolvedLocked, this, + grpc_combiner_scheduler(args.combiner)); } -static void dns_channel_saw_error_locked(grpc_resolver* resolver) { - dns_resolver* r = (dns_resolver*)resolver; - if (!r->resolving) { - maybe_start_resolving_locked(r); +NativeDnsResolver::~NativeDnsResolver() { + if (resolved_result_ != nullptr) { + grpc_channel_args_destroy(resolved_result_); } + grpc_pollset_set_destroy(interested_parties_); + gpr_free(name_to_resolve_); + grpc_channel_args_destroy(channel_args_); } -static void dns_next_locked(grpc_resolver* resolver, - grpc_channel_args** target_result, - grpc_closure* on_complete) { - dns_resolver* r = (dns_resolver*)resolver; - GPR_ASSERT(!r->next_completion); - r->next_completion = on_complete; - r->target_result = target_result; - if (r->resolved_version == 0 && !r->resolving) { - maybe_start_resolving_locked(r); +void NativeDnsResolver::NextLocked(grpc_channel_args** result, + grpc_closure* on_complete) { + GPR_ASSERT(next_completion_ == nullptr); + next_completion_ = on_complete; + target_result_ = result; + if (resolved_version_ == 0 && !resolving_) { + MaybeStartResolvingLocked(); } else { - dns_maybe_finish_next_locked(r); + MaybeFinishNextLocked(); + } +} + +void NativeDnsResolver::RequestReresolutionLocked() { + if (!resolving_) { + MaybeStartResolvingLocked(); + } +} + +void NativeDnsResolver::ShutdownLocked() { + if (have_next_resolution_timer_) { + grpc_timer_cancel(&next_resolution_timer_); + } + if (next_completion_ != nullptr) { + *target_result_ = nullptr; + GRPC_CLOSURE_SCHED(next_completion_, GRPC_ERROR_CREATE_FROM_STATIC_STRING( + "Resolver Shutdown")); + next_completion_ = nullptr; } } -static void dns_on_next_resolution_timer_locked(void* arg, grpc_error* error) { - dns_resolver* r = (dns_resolver*)arg; - r->have_next_resolution_timer = false; - if (error == GRPC_ERROR_NONE && !r->resolving) { - dns_start_resolving_locked(r); +void NativeDnsResolver::OnNextResolutionLocked(void* arg, grpc_error* error) { + NativeDnsResolver* r = static_cast(arg); + r->have_next_resolution_timer_ = false; + if (error == GRPC_ERROR_NONE && !r->resolving_) { + r->StartResolvingLocked(); } - GRPC_RESOLVER_UNREF(&r->base, "next_resolution_timer"); + r->Unref(DEBUG_LOCATION, "retry-timer"); } -static void dns_on_resolved_locked(void* arg, grpc_error* error) { - dns_resolver* r = (dns_resolver*)arg; +void NativeDnsResolver::OnResolvedLocked(void* arg, grpc_error* error) { + NativeDnsResolver* r = static_cast(arg); grpc_channel_args* result = nullptr; - GPR_ASSERT(r->resolving); - r->resolving = false; + GPR_ASSERT(r->resolving_); + r->resolving_ = false; GRPC_ERROR_REF(error); - error = grpc_error_set_str(error, GRPC_ERROR_STR_TARGET_ADDRESS, - grpc_slice_from_copied_string(r->name_to_resolve)); - if (r->addresses != nullptr) { + error = + grpc_error_set_str(error, GRPC_ERROR_STR_TARGET_ADDRESS, + grpc_slice_from_copied_string(r->name_to_resolve_)); + if (r->addresses_ != nullptr) { grpc_lb_addresses* addresses = grpc_lb_addresses_create( - r->addresses->naddrs, nullptr /* user_data_vtable */); - for (size_t i = 0; i < r->addresses->naddrs; ++i) { + r->addresses_->naddrs, nullptr /* user_data_vtable */); + for (size_t i = 0; i < r->addresses_->naddrs; ++i) { grpc_lb_addresses_set_address( - addresses, i, &r->addresses->addrs[i].addr, - r->addresses->addrs[i].len, false /* is_balancer */, + addresses, i, &r->addresses_->addrs[i].addr, + r->addresses_->addrs[i].len, false /* is_balancer */, nullptr /* balancer_name */, nullptr /* user_data */); } grpc_arg new_arg = grpc_lb_addresses_create_channel_arg(addresses); - result = grpc_channel_args_copy_and_add(r->channel_args, &new_arg, 1); - grpc_resolved_addresses_destroy(r->addresses); + result = grpc_channel_args_copy_and_add(r->channel_args_, &new_arg, 1); + grpc_resolved_addresses_destroy(r->addresses_); grpc_lb_addresses_destroy(addresses); // Reset backoff state so that we start from the beginning when the // next request gets triggered. - r->backoff->Reset(); + r->backoff_.Reset(); } else { - grpc_millis next_try = r->backoff->NextAttemptTime(); - grpc_millis timeout = next_try - grpc_core::ExecCtx::Get()->Now(); + grpc_millis next_try = r->backoff_.NextAttemptTime(); + grpc_millis timeout = next_try - ExecCtx::Get()->Now(); gpr_log(GPR_INFO, "dns resolution failed (will retry): %s", grpc_error_string(error)); - GPR_ASSERT(!r->have_next_resolution_timer); - r->have_next_resolution_timer = true; - GRPC_RESOLVER_REF(&r->base, "next_resolution_timer"); + 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. + RefCountedPtr self = + r->Ref(DEBUG_LOCATION, "next_resolution_timer"); + self.release(); if (timeout > 0) { gpr_log(GPR_DEBUG, "retrying in %" PRIdPTR " milliseconds", timeout); } else { gpr_log(GPR_DEBUG, "retrying immediately"); } - grpc_timer_init(&r->next_resolution_timer, next_try, - &r->next_resolution_closure); + grpc_timer_init(&r->next_resolution_timer_, next_try, + &r->on_next_resolution_); } - if (r->resolved_result != nullptr) { - grpc_channel_args_destroy(r->resolved_result); + if (r->resolved_result_ != nullptr) { + grpc_channel_args_destroy(r->resolved_result_); } - r->resolved_result = result; - r->resolved_version++; - dns_maybe_finish_next_locked(r); + r->resolved_result_ = result; + ++r->resolved_version_; + r->MaybeFinishNextLocked(); GRPC_ERROR_UNREF(error); - - GRPC_RESOLVER_UNREF(&r->base, "dns-resolving"); + r->Unref(DEBUG_LOCATION, "dns-resolving"); } -static void maybe_start_resolving_locked(dns_resolver* r) { - if (r->last_resolution_timestamp >= 0) { +void NativeDnsResolver::MaybeStartResolvingLocked() { + if (last_resolution_timestamp_ >= 0) { const grpc_millis earliest_next_resolution = - r->last_resolution_timestamp + r->min_time_between_resolutions; + 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() - r->last_resolution_timestamp; + grpc_core::ExecCtx::Get()->Now() - last_resolution_timestamp_; gpr_log(GPR_DEBUG, "In cooldown from last resolution (from %" PRIdPTR " ms ago). Will resolve again in %" PRIdPTR " ms", last_resolution_ago, ms_until_next_resolution); - if (!r->have_next_resolution_timer) { - r->have_next_resolution_timer = true; - GRPC_RESOLVER_REF(&r->base, "next_resolution_timer_cooldown"); - grpc_timer_init(&r->next_resolution_timer, ms_until_next_resolution, - &r->next_resolution_closure); + if (!have_next_resolution_timer_) { + 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. + RefCountedPtr self = + Ref(DEBUG_LOCATION, "next_resolution_timer_cooldown"); + self.release(); + grpc_timer_init(&next_resolution_timer_, ms_until_next_resolution, + &on_next_resolution_); } // TODO(dgq): remove the following two lines once Pick First stops // discarding subchannels after selecting. - ++r->resolved_version; - dns_maybe_finish_next_locked(r); + ++resolved_version_; + MaybeFinishNextLocked(); return; } } - dns_start_resolving_locked(r); + StartResolvingLocked(); } -static void dns_start_resolving_locked(dns_resolver* r) { - GRPC_RESOLVER_REF(&r->base, "dns-resolving"); - GPR_ASSERT(!r->resolving); - r->resolving = true; - r->addresses = nullptr; - grpc_resolve_address( - r->name_to_resolve, r->default_port, r->interested_parties, - GRPC_CLOSURE_CREATE(dns_on_resolved_locked, r, - grpc_combiner_scheduler(r->base.combiner)), - &r->addresses); - r->last_resolution_timestamp = grpc_core::ExecCtx::Get()->Now(); +void NativeDnsResolver::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. + RefCountedPtr self = Ref(DEBUG_LOCATION, "dns-resolving"); + self.release(); + GPR_ASSERT(!resolving_); + resolving_ = true; + addresses_ = nullptr; + grpc_resolve_address(name_to_resolve_, kDefaultPort, interested_parties_, + &on_resolved_, &addresses_); + last_resolution_timestamp_ = grpc_core::ExecCtx::Get()->Now(); } -static void dns_maybe_finish_next_locked(dns_resolver* r) { - if (r->next_completion != nullptr && - r->resolved_version != r->published_version) { - *r->target_result = r->resolved_result == nullptr - ? nullptr - : grpc_channel_args_copy(r->resolved_result); - GRPC_CLOSURE_SCHED(r->next_completion, GRPC_ERROR_NONE); - r->next_completion = nullptr; - r->published_version = r->resolved_version; +void NativeDnsResolver::MaybeFinishNextLocked() { + if (next_completion_ != nullptr && resolved_version_ != published_version_) { + *target_result_ = resolved_result_ == nullptr + ? nullptr + : grpc_channel_args_copy(resolved_result_); + GRPC_CLOSURE_SCHED(next_completion_, GRPC_ERROR_NONE); + next_completion_ = nullptr; + published_version_ = resolved_version_; } } -static void dns_destroy(grpc_resolver* gr) { - dns_resolver* r = (dns_resolver*)gr; - if (r->resolved_result != nullptr) { - grpc_channel_args_destroy(r->resolved_result); - } - grpc_pollset_set_destroy(r->interested_parties); - gpr_free(r->name_to_resolve); - gpr_free(r->default_port); - grpc_channel_args_destroy(r->channel_args); - gpr_free(r); -} +// +// Factory +// -static grpc_resolver* dns_create(grpc_resolver_args* args, - const char* default_port) { - if (0 != strcmp(args->uri->authority, "")) { - gpr_log(GPR_ERROR, "authority based dns uri's not supported"); - return nullptr; - } - // Get name from args. - char* path = args->uri->path; - if (path[0] == '/') ++path; - // Create resolver. - dns_resolver* r = (dns_resolver*)gpr_zalloc(sizeof(dns_resolver)); - grpc_resolver_init(&r->base, &dns_resolver_vtable, args->combiner); - r->name_to_resolve = gpr_strdup(path); - r->default_port = gpr_strdup(default_port); - r->channel_args = grpc_channel_args_copy(args->args); - r->interested_parties = grpc_pollset_set_create(); - if (args->pollset_set != nullptr) { - grpc_pollset_set_add_pollset_set(r->interested_parties, args->pollset_set); +class NativeDnsResolverFactory : public ResolverFactory { + public: + OrphanablePtr CreateResolver( + const ResolverArgs& args) const override { + if (0 != strcmp(args.uri->authority, "")) { + gpr_log(GPR_ERROR, "authority based dns uri's not supported"); + return OrphanablePtr(nullptr); + } + return OrphanablePtr(New(args)); } - grpc_core::BackOff::Options backoff_options; - 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); - r->backoff.Init(grpc_core::BackOff(backoff_options)); - const grpc_arg* period_arg = grpc_channel_args_find( - args->args, GRPC_ARG_DNS_MIN_TIME_BETWEEN_RESOLUTIONS_MS); - r->min_time_between_resolutions = - grpc_channel_arg_get_integer(period_arg, {1000, 0, INT_MAX}); - r->last_resolution_timestamp = -1; - GRPC_CLOSURE_INIT(&r->next_resolution_closure, - dns_on_next_resolution_timer_locked, r, - grpc_combiner_scheduler(r->base.combiner)); - return &r->base; -} -/* - * FACTORY - */ + const char* scheme() const override { return "dns"; } +}; -static void dns_factory_ref(grpc_resolver_factory* factory) {} +} // namespace -static void dns_factory_unref(grpc_resolver_factory* factory) {} +} // namespace grpc_core -static grpc_resolver* dns_factory_create_resolver( - grpc_resolver_factory* factory, grpc_resolver_args* args) { - return dns_create(args, "https"); -} - -static char* dns_factory_get_default_host_name(grpc_resolver_factory* factory, - grpc_uri* uri) { - const char* path = uri->path; - if (path[0] == '/') ++path; - return gpr_strdup(path); -} - -static const grpc_resolver_factory_vtable dns_factory_vtable = { - dns_factory_ref, dns_factory_unref, dns_factory_create_resolver, - dns_factory_get_default_host_name, "dns"}; -static grpc_resolver_factory dns_resolver_factory = {&dns_factory_vtable}; - -static grpc_resolver_factory* dns_resolver_factory_create() { - return &dns_resolver_factory; -} - -void grpc_resolver_dns_native_init(void) { - char* resolver = gpr_getenv("GRPC_DNS_RESOLVER"); - if (resolver != nullptr && gpr_stricmp(resolver, "native") == 0) { +void grpc_resolver_dns_native_init() { + char* resolver_env = gpr_getenv("GRPC_DNS_RESOLVER"); + if (resolver_env != nullptr && gpr_stricmp(resolver_env, "native") == 0) { gpr_log(GPR_DEBUG, "Using native dns resolver"); - grpc_register_resolver_type(dns_resolver_factory_create()); + grpc_core::ResolverRegistry::Builder::RegisterResolverFactory( + grpc_core::UniquePtr( + grpc_core::New())); } else { - grpc_resolver_factory* existing_factory = - grpc_resolver_factory_lookup("dns"); + grpc_core::ResolverRegistry::Builder::InitRegistry(); + grpc_core::ResolverFactory* existing_factory = + grpc_core::ResolverRegistry::LookupResolverFactory("dns"); if (existing_factory == nullptr) { gpr_log(GPR_DEBUG, "Using native dns resolver"); - grpc_register_resolver_type(dns_resolver_factory_create()); - } else { - grpc_resolver_factory_unref(existing_factory); + grpc_core::ResolverRegistry::Builder::RegisterResolverFactory( + grpc_core::UniquePtr( + grpc_core::New())); } } - gpr_free(resolver); + gpr_free(resolver_env); } -void grpc_resolver_dns_native_shutdown(void) {} +void grpc_resolver_dns_native_shutdown() {} diff --git a/src/core/ext/filters/client_channel/resolver/fake/fake_resolver.cc b/src/core/ext/filters/client_channel/resolver/fake/fake_resolver.cc index f457917775..b01e608c3f 100644 --- a/src/core/ext/filters/client_channel/resolver/fake/fake_resolver.cc +++ b/src/core/ext/filters/client_channel/resolver/fake/fake_resolver.cc @@ -42,190 +42,177 @@ #include "src/core/ext/filters/client_channel/resolver/fake/fake_resolver.h" -// -// fake_resolver -// +namespace grpc_core { -typedef struct { - // Base class -- must be first - grpc_resolver base; +// This cannot be in an anonymous namespace, because it is a friend of +// FakeResolverResponseGenerator. +class FakeResolver : public Resolver { + public: + explicit FakeResolver(const ResolverArgs& args); - // Passed-in parameters - grpc_channel_args* channel_args; + void NextLocked(grpc_channel_args** result, + grpc_closure* on_complete) override; - // If not NULL, the next set of resolution results to be returned to - // grpc_resolver_next_locked()'s closure. - grpc_channel_args* next_results; + void RequestReresolutionLocked() override; - // Results to use for the pretended re-resolution in - // fake_resolver_channel_saw_error_locked(). - grpc_channel_args* results_upon_error; + private: + friend class FakeResolverResponseGenerator; + + virtual ~FakeResolver(); + void MaybeFinishNextLocked(); + + void ShutdownLocked() override; + + // passed-in parameters + grpc_channel_args* channel_args_ = nullptr; + // If not NULL, the next set of resolution results to be returned to + // NextLocked()'s closure. + grpc_channel_args* next_results_ = nullptr; + // Results to use for the pretended re-resolution in + // RequestReresolutionLocked(). + grpc_channel_args* reresolution_results_ = nullptr; // TODO(juanlishen): This can go away once pick_first is changed to not throw // away its subchannels, since that will eliminate its dependence on // channel_saw_error_locked() causing an immediate resolver return. // A copy of the most-recently used resolution results. - grpc_channel_args* last_used_results; - - // Pending next completion, or NULL - grpc_closure* next_completion; - - // Target result address for next completion - grpc_channel_args** target_result; -} fake_resolver; - -static void fake_resolver_destroy(grpc_resolver* gr) { - fake_resolver* r = (fake_resolver*)gr; - grpc_channel_args_destroy(r->next_results); - grpc_channel_args_destroy(r->results_upon_error); - grpc_channel_args_destroy(r->last_used_results); - grpc_channel_args_destroy(r->channel_args); - gpr_free(r); + grpc_channel_args* last_used_results_ = nullptr; + // pending next completion, or NULL + grpc_closure* next_completion_ = nullptr; + // target result address for next completion + grpc_channel_args** target_result_ = nullptr; +}; + +FakeResolver::FakeResolver(const ResolverArgs& args) : Resolver(args.combiner) { + channel_args_ = grpc_channel_args_copy(args.args); + FakeResolverResponseGenerator* response_generator = + FakeResolverResponseGenerator::GetFromArgs(args.args); + if (response_generator != nullptr) response_generator->resolver_ = this; } -static void fake_resolver_shutdown_locked(grpc_resolver* resolver) { - fake_resolver* r = (fake_resolver*)resolver; - if (r->next_completion != nullptr) { - *r->target_result = nullptr; - GRPC_CLOSURE_SCHED(r->next_completion, GRPC_ERROR_CREATE_FROM_STATIC_STRING( - "Resolver Shutdown")); - r->next_completion = nullptr; - } +FakeResolver::~FakeResolver() { + grpc_channel_args_destroy(next_results_); + grpc_channel_args_destroy(reresolution_results_); + grpc_channel_args_destroy(last_used_results_); + grpc_channel_args_destroy(channel_args_); } -static void fake_resolver_maybe_finish_next_locked(fake_resolver* r) { - if (r->next_completion != nullptr && r->next_results != nullptr) { - *r->target_result = - grpc_channel_args_union(r->next_results, r->channel_args); - grpc_channel_args_destroy(r->next_results); - r->next_results = nullptr; - GRPC_CLOSURE_SCHED(r->next_completion, GRPC_ERROR_NONE); - r->next_completion = nullptr; - } +void FakeResolver::NextLocked(grpc_channel_args** target_result, + grpc_closure* on_complete) { + GPR_ASSERT(next_completion_ == nullptr); + next_completion_ = on_complete; + target_result_ = target_result; + MaybeFinishNextLocked(); } -static void fake_resolver_channel_saw_error_locked(grpc_resolver* resolver) { - fake_resolver* r = (fake_resolver*)resolver; +void FakeResolver::RequestReresolutionLocked() { // A resolution must have been returned before an error is seen. - GPR_ASSERT(r->last_used_results != nullptr); - grpc_channel_args_destroy(r->next_results); - if (r->results_upon_error != nullptr) { - r->next_results = grpc_channel_args_copy(r->results_upon_error); + GPR_ASSERT(last_used_results_ != nullptr); + grpc_channel_args_destroy(next_results_); + if (reresolution_results_ != nullptr) { + next_results_ = grpc_channel_args_copy(reresolution_results_); } else { - // If results_upon_error is unavailable, re-resolve with the most-recently + // If reresolution_results is unavailable, re-resolve with the most-recently // used results to avoid a no-op re-resolution. - r->next_results = grpc_channel_args_copy(r->last_used_results); + next_results_ = grpc_channel_args_copy(last_used_results_); } - fake_resolver_maybe_finish_next_locked(r); -} - -static void fake_resolver_next_locked(grpc_resolver* resolver, - grpc_channel_args** target_result, - grpc_closure* on_complete) { - fake_resolver* r = (fake_resolver*)resolver; - GPR_ASSERT(!r->next_completion); - r->next_completion = on_complete; - r->target_result = target_result; - fake_resolver_maybe_finish_next_locked(r); -} - -static const grpc_resolver_vtable fake_resolver_vtable = { - fake_resolver_destroy, fake_resolver_shutdown_locked, - fake_resolver_channel_saw_error_locked, fake_resolver_next_locked}; - -struct grpc_fake_resolver_response_generator { - fake_resolver* resolver; // Set by the fake_resolver constructor to itself. - gpr_refcount refcount; -}; - -grpc_fake_resolver_response_generator* -grpc_fake_resolver_response_generator_create() { - grpc_fake_resolver_response_generator* generator = - (grpc_fake_resolver_response_generator*)gpr_zalloc(sizeof(*generator)); - gpr_ref_init(&generator->refcount, 1); - return generator; + MaybeFinishNextLocked(); } -grpc_fake_resolver_response_generator* -grpc_fake_resolver_response_generator_ref( - grpc_fake_resolver_response_generator* generator) { - gpr_ref(&generator->refcount); - return generator; +void FakeResolver::MaybeFinishNextLocked() { + if (next_completion_ != nullptr && next_results_ != nullptr) { + *target_result_ = grpc_channel_args_union(next_results_, channel_args_); + grpc_channel_args_destroy(next_results_); + next_results_ = nullptr; + GRPC_CLOSURE_SCHED(next_completion_, GRPC_ERROR_NONE); + next_completion_ = nullptr; + } } -void grpc_fake_resolver_response_generator_unref( - grpc_fake_resolver_response_generator* generator) { - if (gpr_unref(&generator->refcount)) { - gpr_free(generator); +void FakeResolver::ShutdownLocked() { + if (next_completion_ != nullptr) { + *target_result_ = nullptr; + GRPC_CLOSURE_SCHED(next_completion_, GRPC_ERROR_CREATE_FROM_STATIC_STRING( + "Resolver Shutdown")); + next_completion_ = nullptr; } } -typedef struct set_response_closure_arg { +// +// FakeResolverResponseGenerator +// + +struct SetResponseClosureArg { grpc_closure set_response_closure; - grpc_fake_resolver_response_generator* generator; + FakeResolverResponseGenerator* generator; grpc_channel_args* response; - bool upon_error; -} set_response_closure_arg; - -static void set_response_closure_locked(void* arg, grpc_error* error) { - set_response_closure_arg* closure_arg = (set_response_closure_arg*)arg; - grpc_fake_resolver_response_generator* generator = closure_arg->generator; - fake_resolver* r = generator->resolver; - if (!closure_arg->upon_error) { - grpc_channel_args_destroy(r->next_results); - r->next_results = closure_arg->response; - grpc_channel_args_destroy(r->last_used_results); - r->last_used_results = grpc_channel_args_copy(closure_arg->response); - fake_resolver_maybe_finish_next_locked(r); - } else { - grpc_channel_args_destroy(r->results_upon_error); - r->results_upon_error = closure_arg->response; - } - gpr_free(closure_arg); +}; + +void FakeResolverResponseGenerator::SetResponseLocked(void* arg, + grpc_error* error) { + SetResponseClosureArg* closure_arg = static_cast(arg); + FakeResolver* resolver = closure_arg->generator->resolver_; + grpc_channel_args_destroy(resolver->next_results_); + resolver->next_results_ = closure_arg->response; + grpc_channel_args_destroy(resolver->last_used_results_); + resolver->last_used_results_ = grpc_channel_args_copy(closure_arg->response); + resolver->MaybeFinishNextLocked(); + Delete(closure_arg); } -void grpc_fake_resolver_response_generator_set_response( - grpc_fake_resolver_response_generator* generator, - grpc_channel_args* response) { - GPR_ASSERT(generator->resolver != nullptr); +void FakeResolverResponseGenerator::SetResponse(grpc_channel_args* response) { GPR_ASSERT(response != nullptr); - set_response_closure_arg* closure_arg = - (set_response_closure_arg*)gpr_zalloc(sizeof(*closure_arg)); - closure_arg->generator = generator; + GPR_ASSERT(resolver_ != nullptr); + SetResponseClosureArg* closure_arg = New(); + closure_arg->generator = this; closure_arg->response = grpc_channel_args_copy(response); - closure_arg->upon_error = false; - GRPC_CLOSURE_SCHED(GRPC_CLOSURE_INIT(&closure_arg->set_response_closure, - set_response_closure_locked, closure_arg, - grpc_combiner_scheduler( - generator->resolver->base.combiner)), - GRPC_ERROR_NONE); + GRPC_CLOSURE_SCHED( + GRPC_CLOSURE_INIT(&closure_arg->set_response_closure, SetResponseLocked, + closure_arg, + grpc_combiner_scheduler(resolver_->combiner())), + GRPC_ERROR_NONE); } -void grpc_fake_resolver_response_generator_set_response_upon_error( - grpc_fake_resolver_response_generator* generator, +void FakeResolverResponseGenerator::SetReresolutionResponseLocked( + void* arg, grpc_error* error) { + SetResponseClosureArg* closure_arg = static_cast(arg); + FakeResolver* resolver = closure_arg->generator->resolver_; + grpc_channel_args_destroy(resolver->reresolution_results_); + resolver->reresolution_results_ = closure_arg->response; + Delete(closure_arg); +} + +void FakeResolverResponseGenerator::SetReresolutionResponse( grpc_channel_args* response) { - GPR_ASSERT(generator->resolver != nullptr); - set_response_closure_arg* closure_arg = - (set_response_closure_arg*)gpr_zalloc(sizeof(*closure_arg)); - closure_arg->generator = generator; + GPR_ASSERT(resolver_ != nullptr); + SetResponseClosureArg* closure_arg = New(); + closure_arg->generator = this; closure_arg->response = response != nullptr ? grpc_channel_args_copy(response) : nullptr; - closure_arg->upon_error = true; - GRPC_CLOSURE_SCHED(GRPC_CLOSURE_INIT(&closure_arg->set_response_closure, - set_response_closure_locked, closure_arg, - grpc_combiner_scheduler( - generator->resolver->base.combiner)), - GRPC_ERROR_NONE); + GRPC_CLOSURE_SCHED( + GRPC_CLOSURE_INIT(&closure_arg->set_response_closure, + SetReresolutionResponseLocked, closure_arg, + grpc_combiner_scheduler(resolver_->combiner())), + GRPC_ERROR_NONE); } +namespace { + static void* response_generator_arg_copy(void* p) { - return grpc_fake_resolver_response_generator_ref( - (grpc_fake_resolver_response_generator*)p); + FakeResolverResponseGenerator* generator = + static_cast(p); + // TODO(roth): We currently deal with this ref manually. Once the + // new channel args code is converted to C++, find a way to track this ref + // in a cleaner way. + RefCountedPtr copy = generator->Ref(); + copy.release(); + return p; } static void response_generator_arg_destroy(void* p) { - grpc_fake_resolver_response_generator_unref( - (grpc_fake_resolver_response_generator*)p); + FakeResolverResponseGenerator* generator = + static_cast(p); + generator->Unref(); } static int response_generator_cmp(void* a, void* b) { return GPR_ICMP(a, b); } @@ -234,8 +221,10 @@ static const grpc_arg_pointer_vtable response_generator_arg_vtable = { response_generator_arg_copy, response_generator_arg_destroy, response_generator_cmp}; -grpc_arg grpc_fake_resolver_response_generator_arg( - grpc_fake_resolver_response_generator* generator) { +} // namespace + +grpc_arg FakeResolverResponseGenerator::MakeChannelArg( + FakeResolverResponseGenerator* generator) { grpc_arg arg; arg.type = GRPC_ARG_POINTER; arg.key = (char*)GRPC_ARG_FAKE_RESOLVER_RESPONSE_GENERATOR; @@ -244,49 +233,38 @@ grpc_arg grpc_fake_resolver_response_generator_arg( return arg; } -grpc_fake_resolver_response_generator* -grpc_fake_resolver_get_response_generator(const grpc_channel_args* args) { +FakeResolverResponseGenerator* FakeResolverResponseGenerator::GetFromArgs( + const grpc_channel_args* args) { const grpc_arg* arg = grpc_channel_args_find(args, GRPC_ARG_FAKE_RESOLVER_RESPONSE_GENERATOR); if (arg == nullptr || arg->type != GRPC_ARG_POINTER) return nullptr; - return (grpc_fake_resolver_response_generator*)arg->value.pointer.p; + return static_cast(arg->value.pointer.p); } // -// fake_resolver_factory +// Factory // -static void fake_resolver_factory_ref(grpc_resolver_factory* factory) {} - -static void fake_resolver_factory_unref(grpc_resolver_factory* factory) {} +namespace { -static grpc_resolver* fake_resolver_create(grpc_resolver_factory* factory, - grpc_resolver_args* args) { - fake_resolver* r = (fake_resolver*)gpr_zalloc(sizeof(*r)); - r->channel_args = grpc_channel_args_copy(args->args); - grpc_resolver_init(&r->base, &fake_resolver_vtable, args->combiner); - grpc_fake_resolver_response_generator* response_generator = - grpc_fake_resolver_get_response_generator(args->args); - if (response_generator != nullptr) response_generator->resolver = r; - return &r->base; -} +class FakeResolverFactory : public ResolverFactory { + public: + OrphanablePtr CreateResolver( + const ResolverArgs& args) const override { + return OrphanablePtr(New(args)); + } -static char* fake_resolver_get_default_authority(grpc_resolver_factory* factory, - grpc_uri* uri) { - const char* path = uri->path; - if (path[0] == '/') ++path; - return gpr_strdup(path); -} + const char* scheme() const override { return "fake"; } +}; -static const grpc_resolver_factory_vtable fake_resolver_factory_vtable = { - fake_resolver_factory_ref, fake_resolver_factory_unref, - fake_resolver_create, fake_resolver_get_default_authority, "fake"}; +} // namespace -static grpc_resolver_factory fake_resolver_factory = { - &fake_resolver_factory_vtable}; +} // namespace grpc_core -void grpc_resolver_fake_init(void) { - grpc_register_resolver_type(&fake_resolver_factory); +void grpc_resolver_fake_init() { + grpc_core::ResolverRegistry::Builder::RegisterResolverFactory( + grpc_core::UniquePtr( + grpc_core::New())); } -void grpc_resolver_fake_shutdown(void) {} +void grpc_resolver_fake_shutdown() {} diff --git a/src/core/ext/filters/client_channel/resolver/fake/fake_resolver.h b/src/core/ext/filters/client_channel/resolver/fake/fake_resolver.h index 94f9a8e6ca..d42811d913 100644 --- a/src/core/ext/filters/client_channel/resolver/fake/fake_resolver.h +++ b/src/core/ext/filters/client_channel/resolver/fake/fake_resolver.h @@ -20,50 +20,57 @@ #include "src/core/ext/filters/client_channel/lb_policy_factory.h" #include "src/core/ext/filters/client_channel/uri_parser.h" #include "src/core/lib/channel/channel_args.h" +#include "src/core/lib/gprpp/ref_counted.h" #define GRPC_ARG_FAKE_RESOLVER_RESPONSE_GENERATOR \ "grpc.fake_resolver.response_generator" -void grpc_resolver_fake_init(); +namespace grpc_core { -// Instances of \a grpc_fake_resolver_response_generator are passed to the -// fake resolver in a channel argument (see \a -// grpc_fake_resolver_response_generator_arg) in order to inject and trigger -// custom resolutions. See also \a -// grpc_fake_resolver_response_generator_set_response. -typedef struct grpc_fake_resolver_response_generator - grpc_fake_resolver_response_generator; -grpc_fake_resolver_response_generator* -grpc_fake_resolver_response_generator_create(); +class FakeResolver; -// Set next response of the fake resolver associated with the \a -// response_generator instance and trigger a new resolution. -void grpc_fake_resolver_response_generator_set_response( - grpc_fake_resolver_response_generator* generator, - grpc_channel_args* response); +/// A mechanism for generating responses for the fake resolver. +/// An instance of this class is passed to the fake resolver via a channel +/// argument (see \a MakeChannelArg()) and used to inject and trigger custom +/// resolutions. +// TODO(roth): I would ideally like this to be InternallyRefCounted +// instead of RefCounted, but external refs are currently needed to +// encode this in channel args. Once channel_args are converted to C++, +// see if we can find a way to fix this. +class FakeResolverResponseGenerator + : public RefCounted { + public: + FakeResolverResponseGenerator() {} -// Set results_upon_error of the fake resolver associated with the \a -// response_generator instance. When fake_resolver_channel_saw_error_locked() is -// called, results_upon_error will be returned as long as it's non-NULL, -// otherwise the last value set by -// grpc_fake_resolver_response_generator_set_response() will be returned. -void grpc_fake_resolver_response_generator_set_response_upon_error( - grpc_fake_resolver_response_generator* generator, - grpc_channel_args* response); + // Instructs the fake resolver associated with the response generator + // instance to trigger a new resolution with the specified response. + void SetResponse(grpc_channel_args* next_response); -// Return a \a grpc_arg for a \a grpc_fake_resolver_response_generator instance. -grpc_arg grpc_fake_resolver_response_generator_arg( - grpc_fake_resolver_response_generator* generator); -// Return the \a grpc_fake_resolver_response_generator instance in \a args or -// NULL. -grpc_fake_resolver_response_generator* -grpc_fake_resolver_get_response_generator(const grpc_channel_args* args); + // Sets the re-resolution response, which is returned by the fake resolver + // when re-resolution is requested (via \a RequestReresolutionLocked()). + // The new re-resolution response replaces any previous re-resolution + // response that may have been set by a previous call. + // If the re-resolution response is set to NULL, then the fake + // resolver will return the last value set via \a SetResponse(). + void SetReresolutionResponse(grpc_channel_args* response); -grpc_fake_resolver_response_generator* -grpc_fake_resolver_response_generator_ref( - grpc_fake_resolver_response_generator* generator); -void grpc_fake_resolver_response_generator_unref( - grpc_fake_resolver_response_generator* generator); + // Returns a channel arg containing \a generator. + static grpc_arg MakeChannelArg(FakeResolverResponseGenerator* generator); + + // Returns the response generator in \a args, or null if not found. + static FakeResolverResponseGenerator* GetFromArgs( + const grpc_channel_args* args); + + private: + friend class FakeResolver; + + static void SetResponseLocked(void* arg, grpc_error* error); + static void SetReresolutionResponseLocked(void* arg, grpc_error* error); + + FakeResolver* resolver_ = nullptr; // Do not own. +}; + +} // namespace grpc_core #endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_FAKE_FAKE_RESOLVER_H \ */ diff --git a/src/core/ext/filters/client_channel/resolver/sockaddr/sockaddr_resolver.cc b/src/core/ext/filters/client_channel/resolver/sockaddr/sockaddr_resolver.cc index 784935eb20..966b9fd3f2 100644 --- a/src/core/ext/filters/client_channel/resolver/sockaddr/sockaddr_resolver.cc +++ b/src/core/ext/filters/client_channel/resolver/sockaddr/sockaddr_resolver.cc @@ -37,115 +37,99 @@ #include "src/core/lib/slice/slice_internal.h" #include "src/core/lib/slice/slice_string_helpers.h" -typedef struct { - /** base class: must be first */ - grpc_resolver base; - /** the addresses that we've 'resolved' */ - grpc_lb_addresses* addresses; - /** channel args */ - grpc_channel_args* channel_args; - /** have we published? */ - bool published; - /** pending next completion, or NULL */ - grpc_closure* next_completion; - /** target result address for next completion */ - grpc_channel_args** target_result; -} sockaddr_resolver; - -static void sockaddr_destroy(grpc_resolver* r); - -static void sockaddr_maybe_finish_next_locked(sockaddr_resolver* r); - -static void sockaddr_shutdown_locked(grpc_resolver* r); -static void sockaddr_channel_saw_error_locked(grpc_resolver* r); -static void sockaddr_next_locked(grpc_resolver* r, - grpc_channel_args** target_result, - grpc_closure* on_complete); - -static const grpc_resolver_vtable sockaddr_resolver_vtable = { - sockaddr_destroy, sockaddr_shutdown_locked, - sockaddr_channel_saw_error_locked, sockaddr_next_locked}; - -static void sockaddr_shutdown_locked(grpc_resolver* resolver) { - sockaddr_resolver* r = (sockaddr_resolver*)resolver; - if (r->next_completion != nullptr) { - *r->target_result = nullptr; - GRPC_CLOSURE_SCHED(r->next_completion, GRPC_ERROR_CREATE_FROM_STATIC_STRING( - "Resolver Shutdown")); - r->next_completion = nullptr; - } -} +namespace grpc_core { -static void sockaddr_channel_saw_error_locked(grpc_resolver* resolver) { - sockaddr_resolver* r = (sockaddr_resolver*)resolver; - r->published = false; - sockaddr_maybe_finish_next_locked(r); -} +namespace { -static void sockaddr_next_locked(grpc_resolver* resolver, - grpc_channel_args** target_result, - grpc_closure* on_complete) { - sockaddr_resolver* r = (sockaddr_resolver*)resolver; - GPR_ASSERT(!r->next_completion); - r->next_completion = on_complete; - r->target_result = target_result; - sockaddr_maybe_finish_next_locked(r); -} +class SockaddrResolver : public Resolver { + public: + /// Takes ownership of \a addresses. + SockaddrResolver(const ResolverArgs& args, grpc_lb_addresses* addresses); -static void sockaddr_maybe_finish_next_locked(sockaddr_resolver* r) { - if (r->next_completion != nullptr && !r->published) { - r->published = true; - grpc_arg arg = grpc_lb_addresses_create_channel_arg(r->addresses); - *r->target_result = - grpc_channel_args_copy_and_add(r->channel_args, &arg, 1); - GRPC_CLOSURE_SCHED(r->next_completion, GRPC_ERROR_NONE); - r->next_completion = nullptr; - } -} + void NextLocked(grpc_channel_args** result, + grpc_closure* on_complete) override; + + void RequestReresolutionLocked() override; -static void sockaddr_destroy(grpc_resolver* gr) { - sockaddr_resolver* r = (sockaddr_resolver*)gr; - grpc_lb_addresses_destroy(r->addresses); - grpc_channel_args_destroy(r->channel_args); - gpr_free(r); + void ShutdownLocked() override; + + private: + virtual ~SockaddrResolver(); + + void MaybeFinishNextLocked(); + + /// the addresses that we've "resolved" + grpc_lb_addresses* addresses_ = nullptr; + /// channel args + grpc_channel_args* channel_args_ = nullptr; + /// have we published? + bool published_ = false; + /// pending next completion, or NULL + grpc_closure* next_completion_ = nullptr; + /// target result address for next completion + grpc_channel_args** target_result_ = nullptr; +}; + +SockaddrResolver::SockaddrResolver(const ResolverArgs& args, + grpc_lb_addresses* addresses) + : Resolver(args.combiner), + addresses_(addresses), + channel_args_(grpc_channel_args_copy(args.args)) {} + +SockaddrResolver::~SockaddrResolver() { + grpc_lb_addresses_destroy(addresses_); + grpc_channel_args_destroy(channel_args_); } -static char* ip_get_default_authority(grpc_uri* uri) { - const char* path = uri->path; - if (path[0] == '/') ++path; - return gpr_strdup(path); +void SockaddrResolver::NextLocked(grpc_channel_args** target_result, + grpc_closure* on_complete) { + GPR_ASSERT(!next_completion_); + next_completion_ = on_complete; + target_result_ = target_result; + MaybeFinishNextLocked(); } -static char* ipv4_get_default_authority(grpc_resolver_factory* factory, - grpc_uri* uri) { - return ip_get_default_authority(uri); +void SockaddrResolver::RequestReresolutionLocked() { + published_ = false; + MaybeFinishNextLocked(); } -static char* ipv6_get_default_authority(grpc_resolver_factory* factory, - grpc_uri* uri) { - return ip_get_default_authority(uri); +void SockaddrResolver::ShutdownLocked() { + if (next_completion_ != nullptr) { + *target_result_ = nullptr; + GRPC_CLOSURE_SCHED(next_completion_, GRPC_ERROR_CREATE_FROM_STATIC_STRING( + "Resolver Shutdown")); + next_completion_ = nullptr; + } } -#ifdef GRPC_HAVE_UNIX_SOCKET -char* unix_get_default_authority(grpc_resolver_factory* factory, - grpc_uri* uri) { - return gpr_strdup("localhost"); +void SockaddrResolver::MaybeFinishNextLocked() { + if (next_completion_ != nullptr && !published_) { + published_ = true; + grpc_arg arg = grpc_lb_addresses_create_channel_arg(addresses_); + *target_result_ = grpc_channel_args_copy_and_add(channel_args_, &arg, 1); + GRPC_CLOSURE_SCHED(next_completion_, GRPC_ERROR_NONE); + next_completion_ = nullptr; + } } -#endif -static void do_nothing(void* ignored) {} +// +// Factory +// -static grpc_resolver* sockaddr_create(grpc_resolver_args* args, - bool parse(const grpc_uri* uri, - grpc_resolved_address* dst)) { - if (0 != strcmp(args->uri->authority, "")) { - gpr_log(GPR_ERROR, "authority based uri's not supported by the %s scheme", - args->uri->scheme); - return nullptr; +void DoNothing(void* ignored) {} + +OrphanablePtr CreateSockaddrResolver( + const ResolverArgs& args, + bool parse(const grpc_uri* uri, grpc_resolved_address* dst)) { + if (0 != strcmp(args.uri->authority, "")) { + gpr_log(GPR_ERROR, "authority-based URIs not supported by the %s scheme", + args.uri->scheme); + return OrphanablePtr(nullptr); } - /* Construct addresses. */ + // Construct addresses. grpc_slice path_slice = - grpc_slice_new(args->uri->path, strlen(args->uri->path), do_nothing); + grpc_slice_new(args.uri->path, strlen(args.uri->path), DoNothing); grpc_slice_buffer path_parts; grpc_slice_buffer_init(&path_parts); grpc_slice_split(path_slice, ",", &path_parts); @@ -153,7 +137,7 @@ static grpc_resolver* sockaddr_create(grpc_resolver_args* args, path_parts.count, nullptr /* user_data_vtable */); bool errors_found = false; for (size_t i = 0; i < addresses->num_addresses; i++) { - grpc_uri ith_uri = *args->uri; + grpc_uri ith_uri = *args.uri; char* part_str = grpc_slice_to_c_string(path_parts.slices[i]); ith_uri.path = part_str; if (!parse(&ith_uri, &addresses->addresses[i].address)) { @@ -166,48 +150,64 @@ static grpc_resolver* sockaddr_create(grpc_resolver_args* args, grpc_slice_unref_internal(path_slice); if (errors_found) { grpc_lb_addresses_destroy(addresses); - return nullptr; + return OrphanablePtr(nullptr); } - /* Instantiate resolver. */ - sockaddr_resolver* r = - (sockaddr_resolver*)gpr_zalloc(sizeof(sockaddr_resolver)); - r->addresses = addresses; - r->channel_args = grpc_channel_args_copy(args->args); - grpc_resolver_init(&r->base, &sockaddr_resolver_vtable, args->combiner); - return &r->base; + // Instantiate resolver. + return OrphanablePtr(New(args, addresses)); } -/* - * FACTORY - */ +class IPv4ResolverFactory : public ResolverFactory { + public: + OrphanablePtr CreateResolver( + const ResolverArgs& args) const override { + return CreateSockaddrResolver(args, grpc_parse_ipv4); + } -static void sockaddr_factory_ref(grpc_resolver_factory* factory) {} + const char* scheme() const override { return "ipv4"; } +}; -static void sockaddr_factory_unref(grpc_resolver_factory* factory) {} +class IPv6ResolverFactory : public ResolverFactory { + public: + OrphanablePtr CreateResolver( + const ResolverArgs& args) const override { + return CreateSockaddrResolver(args, grpc_parse_ipv6); + } -#define DECL_FACTORY(name) \ - static grpc_resolver* name##_factory_create_resolver( \ - grpc_resolver_factory* factory, grpc_resolver_args* args) { \ - return sockaddr_create(args, grpc_parse_##name); \ - } \ - static const grpc_resolver_factory_vtable name##_factory_vtable = { \ - sockaddr_factory_ref, sockaddr_factory_unref, \ - name##_factory_create_resolver, name##_get_default_authority, #name}; \ - static grpc_resolver_factory name##_resolver_factory = { \ - &name##_factory_vtable} + const char* scheme() const override { return "ipv6"; } +}; #ifdef GRPC_HAVE_UNIX_SOCKET -DECL_FACTORY(unix); -#endif -DECL_FACTORY(ipv4); -DECL_FACTORY(ipv6); +class UnixResolverFactory : public ResolverFactory { + public: + OrphanablePtr CreateResolver( + const ResolverArgs& args) const override { + return CreateSockaddrResolver(args, grpc_parse_unix); + } + + UniquePtr GetDefaultAuthority(grpc_uri* uri) const override { + return UniquePtr(gpr_strdup("localhost")); + } + + const char* scheme() const override { return "unix"; } +}; +#endif // GRPC_HAVE_UNIX_SOCKET + +} // namespace + +} // namespace grpc_core -void grpc_resolver_sockaddr_init(void) { - grpc_register_resolver_type(&ipv4_resolver_factory); - grpc_register_resolver_type(&ipv6_resolver_factory); +void grpc_resolver_sockaddr_init() { + grpc_core::ResolverRegistry::Builder::RegisterResolverFactory( + grpc_core::UniquePtr( + grpc_core::New())); + grpc_core::ResolverRegistry::Builder::RegisterResolverFactory( + grpc_core::UniquePtr( + grpc_core::New())); #ifdef GRPC_HAVE_UNIX_SOCKET - grpc_register_resolver_type(&unix_resolver_factory); + grpc_core::ResolverRegistry::Builder::RegisterResolverFactory( + grpc_core::UniquePtr( + grpc_core::New())); #endif } -void grpc_resolver_sockaddr_shutdown(void) {} +void grpc_resolver_sockaddr_shutdown() {} -- cgit v1.2.3