diff options
Diffstat (limited to 'src/core/ext/filters/client_channel/resolver/sockaddr/sockaddr_resolver.cc')
-rw-r--r-- | src/core/ext/filters/client_channel/resolver/sockaddr/sockaddr_resolver.cc | 250 |
1 files changed, 125 insertions, 125 deletions
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<Resolver> 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<Resolver>(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<Resolver>(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<Resolver>(New<SockaddrResolver>(args, addresses)); } -/* - * FACTORY - */ +class IPv4ResolverFactory : public ResolverFactory { + public: + OrphanablePtr<Resolver> 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<Resolver> 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<Resolver> CreateResolver( + const ResolverArgs& args) const override { + return CreateSockaddrResolver(args, grpc_parse_unix); + } + + UniquePtr<char> GetDefaultAuthority(grpc_uri* uri) const override { + return UniquePtr<char>(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::ResolverFactory>( + grpc_core::New<grpc_core::IPv4ResolverFactory>())); + grpc_core::ResolverRegistry::Builder::RegisterResolverFactory( + grpc_core::UniquePtr<grpc_core::ResolverFactory>( + grpc_core::New<grpc_core::IPv6ResolverFactory>())); #ifdef GRPC_HAVE_UNIX_SOCKET - grpc_register_resolver_type(&unix_resolver_factory); + grpc_core::ResolverRegistry::Builder::RegisterResolverFactory( + grpc_core::UniquePtr<grpc_core::ResolverFactory>( + grpc_core::New<grpc_core::UnixResolverFactory>())); #endif } -void grpc_resolver_sockaddr_shutdown(void) {} +void grpc_resolver_sockaddr_shutdown() {} |