grpc 1.24.0 → 1.25.0

data/src/core/ext/filters/client_channel/resolver/dns/c_ares/grpc_ares_wrapper.h

@@ -65,7 +65,7 @@ extern grpc_ares_request* (*grpc_dns_lookup_ares_locked)(
     grpc_pollset_set* interested_parties, grpc_closure* on_done,
     grpc_core::UniquePtr<grpc_core::ServerAddressList>* addresses,
     bool check_grpclb, char** service_config_json, int query_timeout_ms,
-    grpc_combiner* combiner);
+    grpc_core::Combiner* combiner);
 
 /* Cancel the pending grpc_ares_request \a request */
 extern void (*grpc_cancel_ares_request_locked)(grpc_ares_request* request);

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

@@ -31,7 +31,7 @@ static grpc_ares_request* grpc_dns_lookup_ares_locked_impl(
     grpc_pollset_set* interested_parties, grpc_closure* on_done,
     grpc_core::UniquePtr<grpc_core::ServerAddressList>* addrs,
     bool check_grpclb, char** service_config_json, int query_timeout_ms,
-    grpc_combiner* combiner) {
+    grpc_core::Combiner* combiner) {
   return NULL;
 }
 
@@ -40,7 +40,7 @@ grpc_ares_request* (*grpc_dns_lookup_ares_locked)(
     grpc_pollset_set* interested_parties, grpc_closure* on_done,
     grpc_core::UniquePtr<grpc_core::ServerAddressList>* addrs,
     bool check_grpclb, char** service_config_json, int query_timeout_ms,
-    grpc_combiner* combiner) = grpc_dns_lookup_ares_locked_impl;
+    grpc_core::Combiner* combiner) = grpc_dns_lookup_ares_locked_impl;
 
 static void grpc_cancel_ares_request_locked_impl(grpc_ares_request* r) {}
 

data/src/core/ext/filters/client_channel/resolver/dns/native/dns_resolver.cc

@@ -66,7 +66,9 @@ class NativeDnsResolver : public Resolver {
   void MaybeStartResolvingLocked();
   void StartResolvingLocked();
 
+  static void OnNextResolution(void* arg, grpc_error* error);
   static void OnNextResolutionLocked(void* arg, grpc_error* error);
+  static void OnResolved(void* arg, grpc_error* error);
   static void OnResolvedLocked(void* arg, grpc_error* error);
 
   /// name to resolve
@@ -115,11 +117,6 @@ NativeDnsResolver::NativeDnsResolver(ResolverArgs args)
   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));
 }
 
 NativeDnsResolver::~NativeDnsResolver() {
@@ -150,6 +147,14 @@ void NativeDnsResolver::ShutdownLocked() {
   }
 }
 
+void NativeDnsResolver::OnNextResolution(void* arg, grpc_error* error) {
+  NativeDnsResolver* r = static_cast<NativeDnsResolver*>(arg);
+  r->combiner()->Run(
+      GRPC_CLOSURE_INIT(&r->on_next_resolution_,
+                        NativeDnsResolver::OnNextResolutionLocked, r, nullptr),
+      GRPC_ERROR_REF(error));
+}
+
 void NativeDnsResolver::OnNextResolutionLocked(void* arg, grpc_error* error) {
   NativeDnsResolver* r = static_cast<NativeDnsResolver*>(arg);
   r->have_next_resolution_timer_ = false;
@@ -159,6 +164,14 @@ void NativeDnsResolver::OnNextResolutionLocked(void* arg, grpc_error* error) {
   r->Unref(DEBUG_LOCATION, "retry-timer");
 }
 
+void NativeDnsResolver::OnResolved(void* arg, grpc_error* error) {
+  NativeDnsResolver* r = static_cast<NativeDnsResolver*>(arg);
+  r->combiner()->Run(
+      GRPC_CLOSURE_INIT(&r->on_resolved_, NativeDnsResolver::OnResolvedLocked,
+                        r, nullptr),
+      GRPC_ERROR_REF(error));
+}
+
 void NativeDnsResolver::OnResolvedLocked(void* arg, grpc_error* error) {
   NativeDnsResolver* r = static_cast<NativeDnsResolver*>(arg);
   GPR_ASSERT(r->resolving_);
@@ -202,6 +215,9 @@ void NativeDnsResolver::OnResolvedLocked(void* arg, grpc_error* error) {
     } else {
       gpr_log(GPR_DEBUG, "retrying immediately");
     }
+    GRPC_CLOSURE_INIT(&r->on_next_resolution_,
+                      NativeDnsResolver::OnNextResolution, r,
+                      grpc_schedule_on_exec_ctx);
     grpc_timer_init(&r->next_resolution_timer_, next_try,
                     &r->on_next_resolution_);
   }
@@ -229,6 +245,9 @@ void NativeDnsResolver::MaybeStartResolvingLocked() {
       // 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_CLOSURE_INIT(&on_next_resolution_,
+                        NativeDnsResolver::OnNextResolution, this,
+                        grpc_schedule_on_exec_ctx);
       grpc_timer_init(&next_resolution_timer_,
                       ExecCtx::Get()->Now() + ms_until_next_resolution,
                       &on_next_resolution_);
@@ -247,6 +266,8 @@ void NativeDnsResolver::StartResolvingLocked() {
   GPR_ASSERT(!resolving_);
   resolving_ = true;
   addresses_ = nullptr;
+  GRPC_CLOSURE_INIT(&on_resolved_, NativeDnsResolver::OnResolved, this,
+                    grpc_schedule_on_exec_ctx);
   grpc_resolve_address(name_to_resolve_, kDefaultPort, interested_parties_,
                        &on_resolved_, &addresses_);
   last_resolution_timestamp_ = grpc_core::ExecCtx::Get()->Now();
@@ -268,7 +289,7 @@ class NativeDnsResolverFactory : public ResolverFactory {
 
   OrphanablePtr<Resolver> CreateResolver(ResolverArgs args) const override {
     if (!IsValidUri(args.uri)) return nullptr;
-    return OrphanablePtr<Resolver>(New<NativeDnsResolver>(std::move(args)));
+    return MakeOrphanable<NativeDnsResolver>(std::move(args));
   }
 
   const char* scheme() const override { return "dns"; }
@@ -284,8 +305,7 @@ void grpc_resolver_dns_native_init() {
   if (gpr_stricmp(resolver.get(), "native") == 0) {
     gpr_log(GPR_DEBUG, "Using native dns resolver");
     grpc_core::ResolverRegistry::Builder::RegisterResolverFactory(
-        grpc_core::UniquePtr<grpc_core::ResolverFactory>(
-            grpc_core::New<grpc_core::NativeDnsResolverFactory>()));
+        grpc_core::MakeUnique<grpc_core::NativeDnsResolverFactory>());
   } else {
     grpc_core::ResolverRegistry::Builder::InitRegistry();
     grpc_core::ResolverFactory* existing_factory =
@@ -293,8 +313,7 @@ void grpc_resolver_dns_native_init() {
     if (existing_factory == nullptr) {
       gpr_log(GPR_DEBUG, "Using native dns resolver");
       grpc_core::ResolverRegistry::Builder::RegisterResolverFactory(
-          grpc_core::UniquePtr<grpc_core::ResolverFactory>(
-              grpc_core::New<grpc_core::NativeDnsResolverFactory>()));
+          grpc_core::MakeUnique<grpc_core::NativeDnsResolverFactory>());
     }
   }
 }

data/src/core/ext/filters/client_channel/resolver/fake/fake_resolver.cc

@@ -98,8 +98,6 @@ FakeResolver::FakeResolver(ResolverArgs args)
     : Resolver(args.combiner, std::move(args.result_handler)),
       response_generator_(
           FakeResolverResponseGenerator::GetFromArgs(args.args)) {
-  GRPC_CLOSURE_INIT(&reresolution_closure_, ReturnReresolutionResult, this,
-                    grpc_combiner_scheduler(combiner()));
   // Channels sharing the same subchannels may have different resolver response
   // generators. If we don't remove this arg, subchannel pool will create new
   // subchannels for the same address instead of reusing existing ones because
@@ -129,7 +127,9 @@ void FakeResolver::RequestReresolutionLocked() {
     if (!reresolution_closure_pending_) {
       reresolution_closure_pending_ = true;
       Ref().release();  // ref held by closure
-      GRPC_CLOSURE_SCHED(&reresolution_closure_, GRPC_ERROR_NONE);
+      GRPC_CLOSURE_INIT(&reresolution_closure_, ReturnReresolutionResult, this,
+                        nullptr);
+      combiner()->Run(&reresolution_closure_, GRPC_ERROR_NONE);
     }
   }
 }
@@ -159,7 +159,7 @@ void FakeResolver::MaybeSendResultLocked() {
   }
 }
 
-void FakeResolver::ReturnReresolutionResult(void* arg, grpc_error* error) {
+void FakeResolver::ReturnReresolutionResult(void* arg, grpc_error* /*error*/) {
   FakeResolver* self = static_cast<FakeResolver*>(arg);
   self->reresolution_closure_pending_ = false;
   self->MaybeSendResultLocked();
@@ -183,7 +183,7 @@ struct SetResponseClosureArg {
 };
 
 void FakeResolverResponseGenerator::SetResponseLocked(void* arg,
-                                                      grpc_error* error) {
+                                                      grpc_error* /*error*/) {
   SetResponseClosureArg* closure_arg = static_cast<SetResponseClosureArg*>(arg);
   auto& resolver = closure_arg->resolver;
   if (!resolver->shutdown_) {
@@ -208,15 +208,14 @@ void FakeResolverResponseGenerator::SetResponse(Resolver::Result result) {
   SetResponseClosureArg* closure_arg = New<SetResponseClosureArg>();
   closure_arg->resolver = std::move(resolver);
   closure_arg->result = std::move(result);
-  GRPC_CLOSURE_SCHED(
-      GRPC_CLOSURE_INIT(
-          &closure_arg->set_response_closure, SetResponseLocked, closure_arg,
-          grpc_combiner_scheduler(closure_arg->resolver->combiner())),
+  closure_arg->resolver->combiner()->Run(
+      GRPC_CLOSURE_INIT(&closure_arg->set_response_closure, SetResponseLocked,
+                        closure_arg, nullptr),
       GRPC_ERROR_NONE);
 }
 
 void FakeResolverResponseGenerator::SetReresolutionResponseLocked(
-    void* arg, grpc_error* error) {
+    void* arg, grpc_error* /*error*/) {
   SetResponseClosureArg* closure_arg = static_cast<SetResponseClosureArg*>(arg);
   auto& resolver = closure_arg->resolver;
   if (!resolver->shutdown_) {
@@ -238,11 +237,9 @@ void FakeResolverResponseGenerator::SetReresolutionResponse(
   closure_arg->resolver = std::move(resolver);
   closure_arg->result = std::move(result);
   closure_arg->has_result = true;
-  GRPC_CLOSURE_SCHED(
-      GRPC_CLOSURE_INIT(
-          &closure_arg->set_response_closure, SetReresolutionResponseLocked,
-          closure_arg,
-          grpc_combiner_scheduler(closure_arg->resolver->combiner())),
+  closure_arg->resolver->combiner()->Run(
+      GRPC_CLOSURE_INIT(&closure_arg->set_response_closure,
+                        SetReresolutionResponseLocked, closure_arg, nullptr),
       GRPC_ERROR_NONE);
 }
 
@@ -255,16 +252,14 @@ void FakeResolverResponseGenerator::UnsetReresolutionResponse() {
   }
   SetResponseClosureArg* closure_arg = New<SetResponseClosureArg>();
   closure_arg->resolver = std::move(resolver);
-  GRPC_CLOSURE_SCHED(
-      GRPC_CLOSURE_INIT(
-          &closure_arg->set_response_closure, SetReresolutionResponseLocked,
-          closure_arg,
-          grpc_combiner_scheduler(closure_arg->resolver->combiner())),
+  closure_arg->resolver->combiner()->Run(
+      GRPC_CLOSURE_INIT(&closure_arg->set_response_closure,
+                        SetReresolutionResponseLocked, closure_arg, nullptr),
       GRPC_ERROR_NONE);
 }
 
 void FakeResolverResponseGenerator::SetFailureLocked(void* arg,
-                                                     grpc_error* error) {
+                                                     grpc_error* /*error*/) {
   SetResponseClosureArg* closure_arg = static_cast<SetResponseClosureArg*>(arg);
   auto& resolver = closure_arg->resolver;
   if (!resolver->shutdown_) {
@@ -283,10 +278,9 @@ void FakeResolverResponseGenerator::SetFailure() {
   }
   SetResponseClosureArg* closure_arg = New<SetResponseClosureArg>();
   closure_arg->resolver = std::move(resolver);
-  GRPC_CLOSURE_SCHED(
-      GRPC_CLOSURE_INIT(
-          &closure_arg->set_response_closure, SetFailureLocked, closure_arg,
-          grpc_combiner_scheduler(closure_arg->resolver->combiner())),
+  closure_arg->resolver->combiner()->Run(
+      GRPC_CLOSURE_INIT(&closure_arg->set_response_closure, SetFailureLocked,
+                        closure_arg, nullptr),
       GRPC_ERROR_NONE);
 }
 
@@ -300,10 +294,9 @@ void FakeResolverResponseGenerator::SetFailureOnReresolution() {
   SetResponseClosureArg* closure_arg = New<SetResponseClosureArg>();
   closure_arg->resolver = std::move(resolver);
   closure_arg->immediate = false;
-  GRPC_CLOSURE_SCHED(
-      GRPC_CLOSURE_INIT(
-          &closure_arg->set_response_closure, SetFailureLocked, closure_arg,
-          grpc_combiner_scheduler(closure_arg->resolver->combiner())),
+  closure_arg->resolver->combiner()->Run(
+      GRPC_CLOSURE_INIT(&closure_arg->set_response_closure, SetFailureLocked,
+                        closure_arg, nullptr),
       GRPC_ERROR_NONE);
 }
 
@@ -316,10 +309,9 @@ void FakeResolverResponseGenerator::SetFakeResolver(
     SetResponseClosureArg* closure_arg = New<SetResponseClosureArg>();
     closure_arg->resolver = resolver_->Ref();
     closure_arg->result = std::move(result_);
-    GRPC_CLOSURE_SCHED(
+    resolver_->combiner()->Run(
         GRPC_CLOSURE_INIT(&closure_arg->set_response_closure, SetResponseLocked,
-                          closure_arg,
-                          grpc_combiner_scheduler(resolver_->combiner())),
+                          closure_arg, nullptr),
         GRPC_ERROR_NONE);
     has_result_ = false;
   }
@@ -379,10 +371,10 @@ namespace {
 
 class FakeResolverFactory : public ResolverFactory {
  public:
-  bool IsValidUri(const grpc_uri* uri) const override { return true; }
+  bool IsValidUri(const grpc_uri* /*uri*/) const override { return true; }
 
   OrphanablePtr<Resolver> CreateResolver(ResolverArgs args) const override {
-    return OrphanablePtr<Resolver>(New<FakeResolver>(std::move(args)));
+    return MakeOrphanable<FakeResolver>(std::move(args));
   }
 
   const char* scheme() const override { return "fake"; }
@@ -394,8 +386,7 @@ class FakeResolverFactory : public ResolverFactory {
 
 void grpc_resolver_fake_init() {
   grpc_core::ResolverRegistry::Builder::RegisterResolverFactory(
-      grpc_core::UniquePtr<grpc_core::ResolverFactory>(
-          grpc_core::New<grpc_core::FakeResolverFactory>()));
+      grpc_core::MakeUnique<grpc_core::FakeResolverFactory>());
 }
 
 void grpc_resolver_fake_shutdown() {}

data/src/core/ext/filters/client_channel/resolver/sockaddr/sockaddr_resolver.cc

@@ -78,7 +78,7 @@ void SockaddrResolver::StartLocked() {
 // Factory
 //
 
-void DoNothing(void* ignored) {}
+void DoNothing(void* /*ignored*/) {}
 
 bool ParseUri(const grpc_uri* uri,
               bool parse(const grpc_uri* uri, grpc_resolved_address* dst),
@@ -119,8 +119,8 @@ OrphanablePtr<Resolver> CreateSockaddrResolver(
   ServerAddressList addresses;
   if (!ParseUri(args.uri, parse, &addresses)) return nullptr;
   // Instantiate resolver.
-  return OrphanablePtr<Resolver>(
-      New<SockaddrResolver>(std::move(addresses), std::move(args)));
+  return MakeOrphanable<SockaddrResolver>(std::move(addresses),
+                                          std::move(args));
 }
 
 class IPv4ResolverFactory : public ResolverFactory {
@@ -160,7 +160,7 @@ class UnixResolverFactory : public ResolverFactory {
     return CreateSockaddrResolver(std::move(args), grpc_parse_unix);
   }
 
-  UniquePtr<char> GetDefaultAuthority(grpc_uri* uri) const override {
+  UniquePtr<char> GetDefaultAuthority(grpc_uri* /*uri*/) const override {
     return UniquePtr<char>(gpr_strdup("localhost"));
   }
 
@@ -174,15 +174,12 @@ class UnixResolverFactory : public ResolverFactory {
 
 void grpc_resolver_sockaddr_init() {
   grpc_core::ResolverRegistry::Builder::RegisterResolverFactory(
-      grpc_core::UniquePtr<grpc_core::ResolverFactory>(
-          grpc_core::New<grpc_core::IPv4ResolverFactory>()));
+      grpc_core::MakeUnique<grpc_core::IPv4ResolverFactory>());
   grpc_core::ResolverRegistry::Builder::RegisterResolverFactory(
-      grpc_core::UniquePtr<grpc_core::ResolverFactory>(
-          grpc_core::New<grpc_core::IPv6ResolverFactory>()));
+      grpc_core::MakeUnique<grpc_core::IPv6ResolverFactory>());
 #ifdef GRPC_HAVE_UNIX_SOCKET
   grpc_core::ResolverRegistry::Builder::RegisterResolverFactory(
-      grpc_core::UniquePtr<grpc_core::ResolverFactory>(
-          grpc_core::New<grpc_core::UnixResolverFactory>()));
+      grpc_core::MakeUnique<grpc_core::UnixResolverFactory>());
 #endif
 }
 

data/src/core/ext/filters/client_channel/resolver/xds/xds_resolver.cc

@@ -19,39 +19,84 @@
 #include <grpc/support/port_platform.h>
 
 #include "src/core/ext/filters/client_channel/resolver_registry.h"
+#include "src/core/ext/filters/client_channel/xds/xds_client.h"
+#include "src/core/lib/gprpp/string_view.h"
 
 namespace grpc_core {
 
 namespace {
 
+//
+// XdsResolver
+//
+
 class XdsResolver : public Resolver {
  public:
   explicit XdsResolver(ResolverArgs args)
       : Resolver(args.combiner, std::move(args.result_handler)),
-        args_(grpc_channel_args_copy(args.args)) {}
+        args_(grpc_channel_args_copy(args.args)),
+        interested_parties_(args.pollset_set) {
+    char* path = args.uri->path;
+    if (path[0] == '/') ++path;
+    server_name_.reset(gpr_strdup(path));
+  }
+
   ~XdsResolver() override { grpc_channel_args_destroy(args_); }
 
   void StartLocked() override;
 
-  void ShutdownLocked() override{};
+  void ShutdownLocked() override { xds_client_.reset(); }
 
  private:
+  class ServiceConfigWatcher : public XdsClient::ServiceConfigWatcherInterface {
+   public:
+    explicit ServiceConfigWatcher(RefCountedPtr<XdsResolver> resolver)
+        : resolver_(std::move(resolver)) {}
+    void OnServiceConfigChanged(
+        RefCountedPtr<ServiceConfig> service_config) override;
+    void OnError(grpc_error* error) override;
+
+   private:
+    RefCountedPtr<XdsResolver> resolver_;
+  };
+
+  UniquePtr<char> server_name_;
   const grpc_channel_args* args_;
+  grpc_pollset_set* interested_parties_;
+  OrphanablePtr<XdsClient> xds_client_;
 };
 
-void XdsResolver::StartLocked() {
-  static const char* service_config =
-      "{\n"
-      "  \"loadBalancingConfig\":[\n"
-      "    { \"xds_experimental\":{} }\n"
-      "  ]\n"
-      "}";
+void XdsResolver::ServiceConfigWatcher::OnServiceConfigChanged(
+    RefCountedPtr<ServiceConfig> service_config) {
+  grpc_arg xds_client_arg = resolver_->xds_client_->MakeChannelArg();
   Result result;
-  result.args = args_;
-  args_ = nullptr;
+  result.args =
+      grpc_channel_args_copy_and_add(resolver_->args_, &xds_client_arg, 1);
+  result.service_config = std::move(service_config);
+  resolver_->result_handler()->ReturnResult(std::move(result));
+}
+
+void XdsResolver::ServiceConfigWatcher::OnError(grpc_error* error) {
+  grpc_arg xds_client_arg = resolver_->xds_client_->MakeChannelArg();
+  Result result;
+  result.args =
+      grpc_channel_args_copy_and_add(resolver_->args_, &xds_client_arg, 1);
+  result.service_config_error = error;
+  resolver_->result_handler()->ReturnResult(std::move(result));
+}
+
+void XdsResolver::StartLocked() {
   grpc_error* error = GRPC_ERROR_NONE;
-  result.service_config = ServiceConfig::Create(service_config, &error);
-  result_handler()->ReturnResult(std::move(result));
+  xds_client_ = MakeOrphanable<XdsClient>(
+      combiner(), interested_parties_, StringView(server_name_.get()),
+      MakeUnique<ServiceConfigWatcher>(Ref()), *args_, &error);
+  if (error != GRPC_ERROR_NONE) {
+    gpr_log(GPR_ERROR,
+            "Failed to create xds client -- channel will remain in "
+            "TRANSIENT_FAILURE: %s",
+            grpc_error_string(error));
+    result_handler()->ReturnError(error);
+  }
 }
 
 //
@@ -70,7 +115,7 @@ class XdsResolverFactory : public ResolverFactory {
 
   OrphanablePtr<Resolver> CreateResolver(ResolverArgs args) const override {
     if (!IsValidUri(args.uri)) return nullptr;
-    return OrphanablePtr<Resolver>(New<XdsResolver>(std::move(args)));
+    return MakeOrphanable<XdsResolver>(std::move(args));
   }
 
   const char* scheme() const override { return "xds-experimental"; }
@@ -82,8 +127,7 @@ class XdsResolverFactory : public ResolverFactory {
 
 void grpc_resolver_xds_init() {
   grpc_core::ResolverRegistry::Builder::RegisterResolverFactory(
-      grpc_core::UniquePtr<grpc_core::ResolverFactory>(
-          grpc_core::New<grpc_core::XdsResolverFactory>()));
+      grpc_core::MakeUnique<grpc_core::XdsResolverFactory>());
 }
 
 void grpc_resolver_xds_shutdown() {}