grpc 1.28.0 → 1.30.0

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

@@ -25,6 +25,7 @@
 #include "src/core/lib/iomgr/iomgr.h"
 #include "src/core/lib/iomgr/polling_entity.h"
 #include "src/core/lib/iomgr/resolve_address.h"
+#include "src/core/lib/iomgr/work_serializer.h"
 
 #define GRPC_DNS_ARES_DEFAULT_QUERY_TIMEOUT_MS 120000
 
@@ -63,9 +64,10 @@ extern void (*grpc_resolve_address_ares)(const char* name,
 extern grpc_ares_request* (*grpc_dns_lookup_ares_locked)(
     const char* dns_server, const char* name, const char* default_port,
     grpc_pollset_set* interested_parties, grpc_closure* on_done,
-    std::unique_ptr<grpc_core::ServerAddressList>* addresses, bool check_grpclb,
+    std::unique_ptr<grpc_core::ServerAddressList>* addresses,
+    std::unique_ptr<grpc_core::ServerAddressList>* balancer_addresses,
     char** service_config_json, int query_timeout_ms,
-    grpc_core::Combiner* combiner);
+    std::shared_ptr<grpc_core::WorkSerializer> work_serializer);
 
 /* Cancel the pending grpc_ares_request \a request */
 extern void (*grpc_cancel_ares_request_locked)(grpc_ares_request* request);
@@ -89,7 +91,7 @@ bool grpc_ares_query_ipv6();
 
 /* Sorts destinations in lb_addrs according to RFC 6724. */
 void grpc_cares_wrapper_address_sorting_sort(
-    grpc_core::ServerAddressList* addresses);
+    const grpc_ares_request* request, grpc_core::ServerAddressList* addresses);
 
 #endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_DNS_C_ARES_GRPC_ARES_WRAPPER_H \
         */

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

@@ -29,18 +29,21 @@ struct grpc_ares_request {
 static grpc_ares_request* grpc_dns_lookup_ares_locked_impl(
     const char* dns_server, const char* name, const char* default_port,
     grpc_pollset_set* interested_parties, grpc_closure* on_done,
-    std::unique_ptr<grpc_core::ServerAddressList>* addrs, bool check_grpclb,
+    std::unique_ptr<grpc_core::ServerAddressList>* addrs,
+    std::unique_ptr<grpc_core::ServerAddressList>* balancer_addrs,
     char** service_config_json, int query_timeout_ms,
-    grpc_core::Combiner* combiner) {
+    std::shared_ptr<grpc_core::WorkSerializer> work_serializer) {
   return NULL;
 }
 
 grpc_ares_request* (*grpc_dns_lookup_ares_locked)(
     const char* dns_server, const char* name, const char* default_port,
     grpc_pollset_set* interested_parties, grpc_closure* on_done,
-    std::unique_ptr<grpc_core::ServerAddressList>* addrs, bool check_grpclb,
+    std::unique_ptr<grpc_core::ServerAddressList>* addrs,
+    std::unique_ptr<grpc_core::ServerAddressList>* balancer_addrs,
     char** service_config_json, int query_timeout_ms,
-    grpc_core::Combiner* combiner) = grpc_dns_lookup_ares_locked_impl;
+    std::shared_ptr<grpc_core::WorkSerializer> work_serializer) =
+    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

@@ -33,9 +33,9 @@
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gprpp/manual_constructor.h"
-#include "src/core/lib/iomgr/combiner.h"
 #include "src/core/lib/iomgr/resolve_address.h"
 #include "src/core/lib/iomgr/timer.h"
+#include "src/core/lib/iomgr/work_serializer.h"
 
 #define GRPC_DNS_INITIAL_CONNECT_BACKOFF_SECONDS 1
 #define GRPC_DNS_RECONNECT_BACKOFF_MULTIPLIER 1.6
@@ -67,9 +67,9 @@ class NativeDnsResolver : public Resolver {
   void StartResolvingLocked();
 
   static void OnNextResolution(void* arg, grpc_error* error);
-  static void OnNextResolutionLocked(void* arg, grpc_error* error);
+  void OnNextResolutionLocked(grpc_error* error);
   static void OnResolved(void* arg, grpc_error* error);
-  static void OnResolvedLocked(void* arg, grpc_error* error);
+  void OnResolvedLocked(grpc_error* error);
 
   /// name to resolve
   char* name_to_resolve_ = nullptr;
@@ -97,7 +97,7 @@ class NativeDnsResolver : public Resolver {
 };
 
 NativeDnsResolver::NativeDnsResolver(ResolverArgs args)
-    : Resolver(args.combiner, std::move(args.result_handler)),
+    : Resolver(std::move(args.work_serializer), std::move(args.result_handler)),
       backoff_(
           BackOff::Options()
               .set_initial_backoff(GRPC_DNS_INITIAL_CONNECT_BACKOFF_SECONDS *
@@ -149,79 +149,76 @@ 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));
+  GRPC_ERROR_REF(error);  // ref owned by lambda
+  r->work_serializer()->Run([r, error]() { r->OnNextResolutionLocked(error); },
+                            DEBUG_LOCATION);
 }
 
-void NativeDnsResolver::OnNextResolutionLocked(void* arg, grpc_error* error) {
-  NativeDnsResolver* r = static_cast<NativeDnsResolver*>(arg);
-  r->have_next_resolution_timer_ = false;
-  if (error == GRPC_ERROR_NONE && !r->resolving_) {
-    r->StartResolvingLocked();
+void NativeDnsResolver::OnNextResolutionLocked(grpc_error* error) {
+  have_next_resolution_timer_ = false;
+  if (error == GRPC_ERROR_NONE && !resolving_) {
+    StartResolvingLocked();
   }
-  r->Unref(DEBUG_LOCATION, "retry-timer");
+  Unref(DEBUG_LOCATION, "retry-timer");
+  GRPC_ERROR_UNREF(error);
 }
 
 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));
+  GRPC_ERROR_REF(error);  // owned by lambda
+  r->work_serializer()->Run([r, error]() { r->OnResolvedLocked(error); },
+                            DEBUG_LOCATION);
 }
 
-void NativeDnsResolver::OnResolvedLocked(void* arg, grpc_error* error) {
-  NativeDnsResolver* r = static_cast<NativeDnsResolver*>(arg);
-  GPR_ASSERT(r->resolving_);
-  r->resolving_ = false;
-  if (r->shutdown_) {
-    r->Unref(DEBUG_LOCATION, "dns-resolving");
+void NativeDnsResolver::OnResolvedLocked(grpc_error* error) {
+  GPR_ASSERT(resolving_);
+  resolving_ = false;
+  if (shutdown_) {
+    Unref(DEBUG_LOCATION, "dns-resolving");
+    GRPC_ERROR_UNREF(error);
     return;
   }
-  if (r->addresses_ != nullptr) {
+  if (addresses_ != nullptr) {
     Result result;
-    for (size_t i = 0; i < r->addresses_->naddrs; ++i) {
-      result.addresses.emplace_back(&r->addresses_->addrs[i].addr,
-                                    r->addresses_->addrs[i].len,
+    for (size_t i = 0; i < addresses_->naddrs; ++i) {
+      result.addresses.emplace_back(&addresses_->addrs[i].addr,
+                                    addresses_->addrs[i].len,
                                     nullptr /* args */);
     }
-    grpc_resolved_addresses_destroy(r->addresses_);
-    result.args = grpc_channel_args_copy(r->channel_args_);
-    r->result_handler()->ReturnResult(std::move(result));
+    grpc_resolved_addresses_destroy(addresses_);
+    result.args = grpc_channel_args_copy(channel_args_);
+    result_handler()->ReturnResult(std::move(result));
     // Reset backoff state so that we start from the beginning when the
     // next request gets triggered.
-    r->backoff_.Reset();
+    backoff_.Reset();
   } else {
     gpr_log(GPR_INFO, "dns resolution failed (will retry): %s",
             grpc_error_string(error));
     // Return transient error.
-    r->result_handler()->ReturnError(grpc_error_set_int(
+    result_handler()->ReturnError(grpc_error_set_int(
         GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
             "DNS resolution failed", &error, 1),
         GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_UNAVAILABLE));
     // Set up for retry.
-    grpc_millis next_try = r->backoff_.NextAttemptTime();
+    grpc_millis next_try = backoff_.NextAttemptTime();
     grpc_millis timeout = next_try - ExecCtx::Get()->Now();
-    GPR_ASSERT(!r->have_next_resolution_timer_);
-    r->have_next_resolution_timer_ = true;
+    GPR_ASSERT(!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.
-    r->Ref(DEBUG_LOCATION, "next_resolution_timer").release();
+    Ref(DEBUG_LOCATION, "next_resolution_timer").release();
     if (timeout > 0) {
       gpr_log(GPR_DEBUG, "retrying in %" PRId64 " milliseconds", timeout);
     } 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_);
+    GRPC_CLOSURE_INIT(&on_next_resolution_, NativeDnsResolver::OnNextResolution,
+                      this, grpc_schedule_on_exec_ctx);
+    grpc_timer_init(&next_resolution_timer_, next_try, &on_next_resolution_);
   }
-  r->Unref(DEBUG_LOCATION, "dns-resolving");
+  Unref(DEBUG_LOCATION, "dns-resolving");
+  GRPC_ERROR_UNREF(error);
 }
 
 void NativeDnsResolver::MaybeStartResolvingLocked() {

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

@@ -35,9 +35,9 @@
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/iomgr/closure.h"
-#include "src/core/lib/iomgr/combiner.h"
 #include "src/core/lib/iomgr/resolve_address.h"
 #include "src/core/lib/iomgr/unix_sockets_posix.h"
+#include "src/core/lib/iomgr/work_serializer.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/slice/slice_string_helpers.h"
 
@@ -57,20 +57,15 @@ class FakeResolver : public Resolver {
 
  private:
   friend class FakeResolverResponseGenerator;
+  friend class FakeResolverResponseSetter;
 
   virtual ~FakeResolver();
 
-  void ShutdownLocked() override {
-    shutdown_ = true;
-    if (response_generator_ != nullptr) {
-      response_generator_->SetFakeResolver(nullptr);
-      response_generator_.reset();
-    }
-  }
+  void ShutdownLocked() override;
 
   void MaybeSendResultLocked();
 
-  static void ReturnReresolutionResult(void* arg, grpc_error* error);
+  void ReturnReresolutionResult();
 
   // passed-in parameters
   grpc_channel_args* channel_args_ = nullptr;
@@ -90,12 +85,11 @@ class FakeResolver : public Resolver {
   // if true, return failure
   bool return_failure_ = false;
   // pending re-resolution
-  grpc_closure reresolution_closure_;
   bool reresolution_closure_pending_ = false;
 };
 
 FakeResolver::FakeResolver(ResolverArgs args)
-    : Resolver(args.combiner, std::move(args.result_handler)),
+    : Resolver(std::move(args.work_serializer), std::move(args.result_handler)),
       response_generator_(
           FakeResolverResponseGenerator::GetFromArgs(args.args)) {
   // Channels sharing the same subchannels may have different resolver response
@@ -127,13 +121,20 @@ void FakeResolver::RequestReresolutionLocked() {
     if (!reresolution_closure_pending_) {
       reresolution_closure_pending_ = true;
       Ref().release();  // ref held by closure
-      GRPC_CLOSURE_INIT(&reresolution_closure_, ReturnReresolutionResult, this,
-                        nullptr);
-      combiner()->Run(&reresolution_closure_, GRPC_ERROR_NONE);
+      work_serializer()->Run([this]() { ReturnReresolutionResult(); },
+                             DEBUG_LOCATION);
     }
   }
 }
 
+void FakeResolver::ShutdownLocked() {
+  shutdown_ = true;
+  if (response_generator_ != nullptr) {
+    response_generator_->SetFakeResolver(nullptr);
+    response_generator_.reset();
+  }
+}
+
 void FakeResolver::MaybeSendResultLocked() {
   if (!started_ || shutdown_) return;
   if (return_failure_) {
@@ -159,11 +160,59 @@ void FakeResolver::MaybeSendResultLocked() {
   }
 }
 
-void FakeResolver::ReturnReresolutionResult(void* arg, grpc_error* /*error*/) {
-  FakeResolver* self = static_cast<FakeResolver*>(arg);
-  self->reresolution_closure_pending_ = false;
-  self->MaybeSendResultLocked();
-  self->Unref();
+void FakeResolver::ReturnReresolutionResult() {
+  reresolution_closure_pending_ = false;
+  MaybeSendResultLocked();
+  Unref();
+}
+
+class FakeResolverResponseSetter {
+ public:
+  explicit FakeResolverResponseSetter(RefCountedPtr<FakeResolver> resolver,
+                                      Resolver::Result result,
+                                      bool has_result = false,
+                                      bool immediate = true)
+      : resolver_(std::move(resolver)),
+        result_(std::move(result)),
+        has_result_(has_result),
+        immediate_(immediate) {}
+  void SetResponseLocked();
+  void SetReresolutionResponseLocked();
+  void SetFailureLocked();
+
+ private:
+  RefCountedPtr<FakeResolver> resolver_;
+  Resolver::Result result_;
+  bool has_result_;
+  bool immediate_;
+};
+
+// Deletes object when done
+void FakeResolverResponseSetter::SetReresolutionResponseLocked() {
+  if (!resolver_->shutdown_) {
+    resolver_->reresolution_result_ = std::move(result_);
+    resolver_->has_reresolution_result_ = has_result_;
+  }
+  delete this;
+}
+
+// Deletes object when done
+void FakeResolverResponseSetter::SetResponseLocked() {
+  if (!resolver_->shutdown_) {
+    resolver_->next_result_ = std::move(result_);
+    resolver_->has_next_result_ = true;
+    resolver_->MaybeSendResultLocked();
+  }
+  delete this;
+}
+
+// Deletes object when done
+void FakeResolverResponseSetter::SetFailureLocked() {
+  if (!resolver_->shutdown_) {
+    resolver_->return_failure_ = true;
+    if (immediate_) resolver_->MaybeSendResultLocked();
+  }
+  delete this;
 }
 
 //
@@ -174,26 +223,6 @@ FakeResolverResponseGenerator::FakeResolverResponseGenerator() {}
 
 FakeResolverResponseGenerator::~FakeResolverResponseGenerator() {}
 
-struct SetResponseClosureArg {
-  grpc_closure set_response_closure;
-  RefCountedPtr<FakeResolver> resolver;
-  Resolver::Result result;
-  bool has_result = false;
-  bool immediate = true;
-};
-
-void FakeResolverResponseGenerator::SetResponseLocked(void* arg,
-                                                      grpc_error* /*error*/) {
-  SetResponseClosureArg* closure_arg = static_cast<SetResponseClosureArg*>(arg);
-  auto& resolver = closure_arg->resolver;
-  if (!resolver->shutdown_) {
-    resolver->next_result_ = std::move(closure_arg->result);
-    resolver->has_next_result_ = true;
-    resolver->MaybeSendResultLocked();
-  }
-  delete closure_arg;
-}
-
 void FakeResolverResponseGenerator::SetResponse(Resolver::Result result) {
   RefCountedPtr<FakeResolver> resolver;
   {
@@ -205,24 +234,10 @@ void FakeResolverResponseGenerator::SetResponse(Resolver::Result result) {
     }
     resolver = resolver_->Ref();
   }
-  SetResponseClosureArg* closure_arg = new SetResponseClosureArg();
-  closure_arg->resolver = std::move(resolver);
-  closure_arg->result = std::move(result);
-  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*/) {
-  SetResponseClosureArg* closure_arg = static_cast<SetResponseClosureArg*>(arg);
-  auto& resolver = closure_arg->resolver;
-  if (!resolver->shutdown_) {
-    resolver->reresolution_result_ = std::move(closure_arg->result);
-    resolver->has_reresolution_result_ = closure_arg->has_result;
-  }
-  delete closure_arg;
+  FakeResolverResponseSetter* arg =
+      new FakeResolverResponseSetter(resolver, std::move(result));
+  resolver->work_serializer()->Run([arg]() { arg->SetResponseLocked(); },
+                                   DEBUG_LOCATION);
 }
 
 void FakeResolverResponseGenerator::SetReresolutionResponse(
@@ -233,14 +248,10 @@ void FakeResolverResponseGenerator::SetReresolutionResponse(
     GPR_ASSERT(resolver_ != nullptr);
     resolver = resolver_->Ref();
   }
-  SetResponseClosureArg* closure_arg = new SetResponseClosureArg();
-  closure_arg->resolver = std::move(resolver);
-  closure_arg->result = std::move(result);
-  closure_arg->has_result = true;
-  closure_arg->resolver->combiner()->Run(
-      GRPC_CLOSURE_INIT(&closure_arg->set_response_closure,
-                        SetReresolutionResponseLocked, closure_arg, nullptr),
-      GRPC_ERROR_NONE);
+  FakeResolverResponseSetter* arg = new FakeResolverResponseSetter(
+      resolver, std::move(result), true /* has_result */);
+  resolver->work_serializer()->Run(
+      [arg]() { arg->SetReresolutionResponseLocked(); }, DEBUG_LOCATION);
 }
 
 void FakeResolverResponseGenerator::UnsetReresolutionResponse() {
@@ -250,23 +261,10 @@ void FakeResolverResponseGenerator::UnsetReresolutionResponse() {
     GPR_ASSERT(resolver_ != nullptr);
     resolver = resolver_->Ref();
   }
-  SetResponseClosureArg* closure_arg = new SetResponseClosureArg();
-  closure_arg->resolver = std::move(resolver);
-  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*/) {
-  SetResponseClosureArg* closure_arg = static_cast<SetResponseClosureArg*>(arg);
-  auto& resolver = closure_arg->resolver;
-  if (!resolver->shutdown_) {
-    resolver->return_failure_ = true;
-    if (closure_arg->immediate) resolver->MaybeSendResultLocked();
-  }
-  delete closure_arg;
+  FakeResolverResponseSetter* arg =
+      new FakeResolverResponseSetter(resolver, Resolver::Result());
+  resolver->work_serializer()->Run(
+      [arg]() { arg->SetReresolutionResponseLocked(); }, DEBUG_LOCATION);
 }
 
 void FakeResolverResponseGenerator::SetFailure() {
@@ -276,12 +274,10 @@ void FakeResolverResponseGenerator::SetFailure() {
     GPR_ASSERT(resolver_ != nullptr);
     resolver = resolver_->Ref();
   }
-  SetResponseClosureArg* closure_arg = new SetResponseClosureArg();
-  closure_arg->resolver = std::move(resolver);
-  closure_arg->resolver->combiner()->Run(
-      GRPC_CLOSURE_INIT(&closure_arg->set_response_closure, SetFailureLocked,
-                        closure_arg, nullptr),
-      GRPC_ERROR_NONE);
+  FakeResolverResponseSetter* arg =
+      new FakeResolverResponseSetter(resolver, Resolver::Result());
+  resolver->work_serializer()->Run([arg]() { arg->SetFailureLocked(); },
+                                   DEBUG_LOCATION);
 }
 
 void FakeResolverResponseGenerator::SetFailureOnReresolution() {
@@ -291,13 +287,11 @@ void FakeResolverResponseGenerator::SetFailureOnReresolution() {
     GPR_ASSERT(resolver_ != nullptr);
     resolver = resolver_->Ref();
   }
-  SetResponseClosureArg* closure_arg = new SetResponseClosureArg();
-  closure_arg->resolver = std::move(resolver);
-  closure_arg->immediate = false;
-  closure_arg->resolver->combiner()->Run(
-      GRPC_CLOSURE_INIT(&closure_arg->set_response_closure, SetFailureLocked,
-                        closure_arg, nullptr),
-      GRPC_ERROR_NONE);
+  FakeResolverResponseSetter* arg = new FakeResolverResponseSetter(
+      resolver, Resolver::Result(), false /* has_result */,
+      false /* immediate */);
+  resolver->work_serializer()->Run([arg]() { arg->SetFailureLocked(); },
+                                   DEBUG_LOCATION);
 }
 
 void FakeResolverResponseGenerator::SetFakeResolver(
@@ -306,13 +300,10 @@ void FakeResolverResponseGenerator::SetFakeResolver(
   resolver_ = std::move(resolver);
   if (resolver_ == nullptr) return;
   if (has_result_) {
-    SetResponseClosureArg* closure_arg = new SetResponseClosureArg();
-    closure_arg->resolver = resolver_->Ref();
-    closure_arg->result = std::move(result_);
-    resolver_->combiner()->Run(
-        GRPC_CLOSURE_INIT(&closure_arg->set_response_closure, SetResponseLocked,
-                          closure_arg, nullptr),
-        GRPC_ERROR_NONE);
+    FakeResolverResponseSetter* arg =
+        new FakeResolverResponseSetter(resolver_, std::move(result_));
+    resolver_->work_serializer()->Run([arg]() { arg->SetResponseLocked(); },
+                                      DEBUG_LOCATION);
     has_result_ = false;
   }
 }