grpc 1.19.0 → 1.20.0.pre1

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

@@ -19,6 +19,7 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "src/core/ext/filters/client_channel/resolver.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/iomgr/error.h"
@@ -44,20 +45,22 @@ class FakeResolverResponseGenerator
   FakeResolverResponseGenerator() {}
 
   // 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);
+  // instance to trigger a new resolution with the specified result. If the
+  // resolver is not available yet, delays response setting until it is. This
+  // can be called at most once before the resolver is available.
+  void SetResponse(Resolver::Result result);
 
   // 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 not return anything when \a RequestReresolutionLocked()
-  // is called.
-  void SetReresolutionResponse(grpc_channel_args* response);
+  void SetReresolutionResponse(Resolver::Result result);
 
-  // Tells the resolver to return a transient failure (signalled by
-  // returning a null result with no error).
+  // Unsets the re-resolution response.  After this, the fake resolver will
+  // not return anything when \a RequestReresolutionLocked() is called.
+  void UnsetReresolutionResponse();
+
+  // Tells the resolver to return a transient failure.
   void SetFailure();
 
   // Same as SetFailure(), but instead of returning the error
@@ -79,6 +82,8 @@ class FakeResolverResponseGenerator
   static void SetFailureLocked(void* arg, grpc_error* error);
 
   FakeResolver* resolver_ = nullptr;  // Do not own.
+  Resolver::Result result_;
+  bool has_result_ = false;
 };
 
 }  // namespace grpc_core

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

@@ -44,35 +44,21 @@ namespace {
 
 class SockaddrResolver : public Resolver {
  public:
-  /// Takes ownership of \a addresses.
-  SockaddrResolver(const ResolverArgs& args,
-                   UniquePtr<ServerAddressList> addresses);
+  SockaddrResolver(ServerAddressList addresses, ResolverArgs args);
+  ~SockaddrResolver() override;
 
-  void NextLocked(grpc_channel_args** result,
-                  grpc_closure* on_complete) override;
+  void StartLocked() override;
 
-  void ShutdownLocked() override;
+  void ShutdownLocked() override {}
 
  private:
-  virtual ~SockaddrResolver();
-
-  void MaybeFinishNextLocked();
-
-  /// the addresses that we've "resolved"
-  UniquePtr<ServerAddressList> addresses_;
-  /// 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;
+  ServerAddressList addresses_;
+  const grpc_channel_args* channel_args_ = nullptr;
 };
 
-SockaddrResolver::SockaddrResolver(const ResolverArgs& args,
-                                   UniquePtr<ServerAddressList> addresses)
-    : Resolver(args.combiner),
+SockaddrResolver::SockaddrResolver(ServerAddressList addresses,
+                                   ResolverArgs args)
+    : Resolver(args.combiner, std::move(args.result_handler)),
       addresses_(std::move(addresses)),
       channel_args_(grpc_channel_args_copy(args.args)) {}
 
@@ -80,31 +66,13 @@ SockaddrResolver::~SockaddrResolver() {
   grpc_channel_args_destroy(channel_args_);
 }
 
-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();
-}
-
-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;
-  }
-}
-
-void SockaddrResolver::MaybeFinishNextLocked() {
-  if (next_completion_ != nullptr && !published_) {
-    published_ = true;
-    grpc_arg arg = CreateServerAddressListChannelArg(addresses_.get());
-    *target_result_ = grpc_channel_args_copy_and_add(channel_args_, &arg, 1);
-    GRPC_CLOSURE_SCHED(next_completion_, GRPC_ERROR_NONE);
-    next_completion_ = nullptr;
-  }
+void SockaddrResolver::StartLocked() {
+  Result result;
+  result.addresses = std::move(addresses_);
+  // TODO(roth): Use std::move() once channel args is converted to C++.
+  result.args = channel_args_;
+  channel_args_ = nullptr;
+  result_handler()->ReturnResult(std::move(result));
 }
 
 //
@@ -114,12 +82,12 @@ void SockaddrResolver::MaybeFinishNextLocked() {
 void DoNothing(void* ignored) {}
 
 OrphanablePtr<Resolver> CreateSockaddrResolver(
-    const ResolverArgs& args,
+    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);
+    return nullptr;
   }
   // Construct addresses.
   grpc_slice path_slice =
@@ -127,7 +95,7 @@ OrphanablePtr<Resolver> CreateSockaddrResolver(
   grpc_slice_buffer path_parts;
   grpc_slice_buffer_init(&path_parts);
   grpc_slice_split(path_slice, ",", &path_parts);
-  auto addresses = MakeUnique<ServerAddressList>();
+  ServerAddressList addresses;
   bool errors_found = false;
   for (size_t i = 0; i < path_parts.count; i++) {
     grpc_uri ith_uri = *args.uri;
@@ -135,10 +103,10 @@ OrphanablePtr<Resolver> CreateSockaddrResolver(
     ith_uri.path = part_str.get();
     grpc_resolved_address addr;
     if (!parse(&ith_uri, &addr)) {
-      errors_found = true; /* GPR_TRUE */
+      errors_found = true;
       break;
     }
-    addresses->emplace_back(addr, nullptr /* args */);
+    addresses.emplace_back(addr, nullptr /* args */);
   }
   grpc_slice_buffer_destroy_internal(&path_parts);
   grpc_slice_unref_internal(path_slice);
@@ -147,14 +115,13 @@ OrphanablePtr<Resolver> CreateSockaddrResolver(
   }
   // Instantiate resolver.
   return OrphanablePtr<Resolver>(
-      New<SockaddrResolver>(args, std::move(addresses)));
+      New<SockaddrResolver>(std::move(addresses), std::move(args)));
 }
 
 class IPv4ResolverFactory : public ResolverFactory {
  public:
-  OrphanablePtr<Resolver> CreateResolver(
-      const ResolverArgs& args) const override {
-    return CreateSockaddrResolver(args, grpc_parse_ipv4);
+  OrphanablePtr<Resolver> CreateResolver(ResolverArgs args) const override {
+    return CreateSockaddrResolver(std::move(args), grpc_parse_ipv4);
   }
 
   const char* scheme() const override { return "ipv4"; }
@@ -162,9 +129,8 @@ class IPv4ResolverFactory : public ResolverFactory {
 
 class IPv6ResolverFactory : public ResolverFactory {
  public:
-  OrphanablePtr<Resolver> CreateResolver(
-      const ResolverArgs& args) const override {
-    return CreateSockaddrResolver(args, grpc_parse_ipv6);
+  OrphanablePtr<Resolver> CreateResolver(ResolverArgs args) const override {
+    return CreateSockaddrResolver(std::move(args), grpc_parse_ipv6);
   }
 
   const char* scheme() const override { return "ipv6"; }
@@ -173,9 +139,8 @@ class IPv6ResolverFactory : public ResolverFactory {
 #ifdef GRPC_HAVE_UNIX_SOCKET
 class UnixResolverFactory : public ResolverFactory {
  public:
-  OrphanablePtr<Resolver> CreateResolver(
-      const ResolverArgs& args) const override {
-    return CreateSockaddrResolver(args, grpc_parse_unix);
+  OrphanablePtr<Resolver> CreateResolver(ResolverArgs args) const override {
+    return CreateSockaddrResolver(std::move(args), grpc_parse_unix);
   }
 
   UniquePtr<char> GetDefaultAuthority(grpc_uri* uri) const override {

data/src/core/ext/filters/client_channel/resolver_factory.h

@@ -41,12 +41,14 @@ struct ResolverArgs {
   grpc_pollset_set* pollset_set = nullptr;
   /// The combiner under which all resolver calls will be run.
   grpc_combiner* combiner = nullptr;
+  /// The result handler to be used by the resolver.
+  UniquePtr<Resolver::ResultHandler> result_handler;
 };
 
 class ResolverFactory {
  public:
   /// Returns a new resolver instance.
-  virtual OrphanablePtr<Resolver> CreateResolver(const ResolverArgs& args) const
+  virtual OrphanablePtr<Resolver> CreateResolver(ResolverArgs args) const
       GRPC_ABSTRACT;
 
   /// Returns a string representing the default authority to use for this

data/src/core/ext/filters/client_channel/resolver_registry.cc

@@ -134,7 +134,8 @@ ResolverFactory* ResolverRegistry::LookupResolverFactory(const char* scheme) {
 
 OrphanablePtr<Resolver> ResolverRegistry::CreateResolver(
     const char* target, const grpc_channel_args* args,
-    grpc_pollset_set* pollset_set, grpc_combiner* combiner) {
+    grpc_pollset_set* pollset_set, grpc_combiner* combiner,
+    UniquePtr<Resolver::ResultHandler> result_handler) {
   GPR_ASSERT(g_state != nullptr);
   grpc_uri* uri = nullptr;
   char* canonical_target = nullptr;
@@ -145,8 +146,10 @@ OrphanablePtr<Resolver> ResolverRegistry::CreateResolver(
   resolver_args.args = args;
   resolver_args.pollset_set = pollset_set;
   resolver_args.combiner = combiner;
+  resolver_args.result_handler = std::move(result_handler);
   OrphanablePtr<Resolver> resolver =
-      factory == nullptr ? nullptr : factory->CreateResolver(resolver_args);
+      factory == nullptr ? nullptr
+                         : factory->CreateResolver(std::move(resolver_args));
   grpc_uri_destroy(uri);
   gpr_free(canonical_target);
   return resolver;

data/src/core/ext/filters/client_channel/resolver_registry.h

@@ -62,10 +62,11 @@ class ResolverRegistry {
   /// \a args are the channel args to be included in resolver results.
   /// \a pollset_set is used to drive I/O in the name resolution process.
   /// \a combiner is the combiner under which all resolver calls will be run.
-  static OrphanablePtr<Resolver> CreateResolver(const char* target,
-                                                const grpc_channel_args* args,
-                                                grpc_pollset_set* pollset_set,
-                                                grpc_combiner* combiner);
+  /// \a result_handler is used to return results from the resolver.
+  static OrphanablePtr<Resolver> CreateResolver(
+      const char* target, const grpc_channel_args* args,
+      grpc_pollset_set* pollset_set, grpc_combiner* combiner,
+      UniquePtr<Resolver::ResultHandler> result_handler);
 
   /// Returns the default authority to pass from a client for \a target.
   static UniquePtr<char> GetDefaultAuthority(const char* target);

data/src/core/ext/filters/client_channel/resolver_result_parsing.cc

@@ -31,6 +31,7 @@
 #include "src/core/ext/filters/client_channel/client_channel.h"
 #include "src/core/ext/filters/client_channel/lb_policy_registry.h"
 #include "src/core/ext/filters/client_channel/server_address.h"
+#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/status_util.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gprpp/memory.h"
@@ -43,42 +44,64 @@ namespace grpc_core {
 namespace internal {
 
 ProcessedResolverResult::ProcessedResolverResult(
-    const grpc_channel_args& resolver_result, bool parse_retry) {
-  ProcessServiceConfig(resolver_result, parse_retry);
+    Resolver::Result* resolver_result, bool parse_retry)
+    : service_config_(resolver_result->service_config) {
+  // If resolver did not return a service config, use the default
+  // specified via the client API.
+  if (service_config_ == nullptr) {
+    const char* service_config_json = grpc_channel_arg_get_string(
+        grpc_channel_args_find(resolver_result->args, GRPC_ARG_SERVICE_CONFIG));
+    if (service_config_json != nullptr) {
+      service_config_ = ServiceConfig::Create(service_config_json);
+    }
+  } else {
+    // Add the service config JSON to channel args so that it's
+    // accessible in the subchannel.
+    // TODO(roth): Consider whether there's a better way to pass the
+    // service config down into the subchannel stack, such as maybe via
+    // call context or metadata.  This would avoid the problem of having
+    // to recreate all subchannels whenever the service config changes.
+    // It would also avoid the need to pass in the resolver result in
+    // mutable form, both here and in
+    // ResolvingLoadBalancingPolicy::ProcessResolverResultCallback().
+    grpc_arg arg = grpc_channel_arg_string_create(
+        const_cast<char*>(GRPC_ARG_SERVICE_CONFIG),
+        const_cast<char*>(service_config_->service_config_json()));
+    grpc_channel_args* new_args =
+        grpc_channel_args_copy_and_add(resolver_result->args, &arg, 1);
+    grpc_channel_args_destroy(resolver_result->args);
+    resolver_result->args = new_args;
+  }
+  // Process service config.
+  ProcessServiceConfig(*resolver_result, parse_retry);
   // If no LB config was found above, just find the LB policy name then.
-  if (lb_policy_name_ == nullptr) ProcessLbPolicyName(resolver_result);
+  if (lb_policy_name_ == nullptr) ProcessLbPolicyName(*resolver_result);
 }
 
 void ProcessedResolverResult::ProcessServiceConfig(
-    const grpc_channel_args& resolver_result, bool parse_retry) {
-  const grpc_arg* channel_arg =
-      grpc_channel_args_find(&resolver_result, GRPC_ARG_SERVICE_CONFIG);
-  const char* service_config_json = grpc_channel_arg_get_string(channel_arg);
-  if (service_config_json != nullptr) {
-    service_config_json_.reset(gpr_strdup(service_config_json));
-    service_config_ = grpc_core::ServiceConfig::Create(service_config_json);
-    if (service_config_ != nullptr) {
-      if (parse_retry) {
-        channel_arg =
-            grpc_channel_args_find(&resolver_result, GRPC_ARG_SERVER_URI);
-        const char* server_uri = grpc_channel_arg_get_string(channel_arg);
-        GPR_ASSERT(server_uri != nullptr);
-        grpc_uri* uri = grpc_uri_parse(server_uri, true);
-        GPR_ASSERT(uri->path[0] != '\0');
-        server_name_ = uri->path[0] == '/' ? uri->path + 1 : uri->path;
-        service_config_->ParseGlobalParams(ParseServiceConfig, this);
-        grpc_uri_destroy(uri);
-      } else {
-        service_config_->ParseGlobalParams(ParseServiceConfig, this);
-      }
-      method_params_table_ = service_config_->CreateMethodConfigTable(
-          ClientChannelMethodParams::CreateFromJson);
-    }
+    const Resolver::Result& resolver_result, bool parse_retry) {
+  if (service_config_ == nullptr) return;
+  service_config_json_ =
+      UniquePtr<char>(gpr_strdup(service_config_->service_config_json()));
+  if (parse_retry) {
+    const grpc_arg* channel_arg =
+        grpc_channel_args_find(resolver_result.args, GRPC_ARG_SERVER_URI);
+    const char* server_uri = grpc_channel_arg_get_string(channel_arg);
+    GPR_ASSERT(server_uri != nullptr);
+    grpc_uri* uri = grpc_uri_parse(server_uri, true);
+    GPR_ASSERT(uri->path[0] != '\0');
+    server_name_ = uri->path[0] == '/' ? uri->path + 1 : uri->path;
+    service_config_->ParseGlobalParams(ParseServiceConfig, this);
+    grpc_uri_destroy(uri);
+  } else {
+    service_config_->ParseGlobalParams(ParseServiceConfig, this);
   }
+  method_params_table_ = service_config_->CreateMethodConfigTable(
+      ClientChannelMethodParams::CreateFromJson);
 }
 
 void ProcessedResolverResult::ProcessLbPolicyName(
-    const grpc_channel_args& resolver_result) {
+    const Resolver::Result& resolver_result) {
   // Prefer the LB policy name found in the service config. Note that this is
   // checking the deprecated loadBalancingPolicy field, rather than the new
   // loadBalancingConfig field.
@@ -96,32 +119,28 @@ void ProcessedResolverResult::ProcessLbPolicyName(
   // Otherwise, find the LB policy name set by the client API.
   if (lb_policy_name_ == nullptr) {
     const grpc_arg* channel_arg =
-        grpc_channel_args_find(&resolver_result, GRPC_ARG_LB_POLICY_NAME);
+        grpc_channel_args_find(resolver_result.args, GRPC_ARG_LB_POLICY_NAME);
     lb_policy_name_.reset(gpr_strdup(grpc_channel_arg_get_string(channel_arg)));
   }
   // Special case: If at least one balancer address is present, we use
   // the grpclb policy, regardless of what the resolver has returned.
-  const ServerAddressList* addresses =
-      FindServerAddressListChannelArg(&resolver_result);
-  if (addresses != nullptr) {
-    bool found_balancer_address = false;
-    for (size_t i = 0; i < addresses->size(); ++i) {
-      const ServerAddress& address = (*addresses)[i];
-      if (address.IsBalancer()) {
-        found_balancer_address = true;
-        break;
-      }
+  bool found_balancer_address = false;
+  for (size_t i = 0; i < resolver_result.addresses.size(); ++i) {
+    const ServerAddress& address = resolver_result.addresses[i];
+    if (address.IsBalancer()) {
+      found_balancer_address = true;
+      break;
     }
-    if (found_balancer_address) {
-      if (lb_policy_name_ != nullptr &&
-          strcmp(lb_policy_name_.get(), "grpclb") != 0) {
-        gpr_log(GPR_INFO,
-                "resolver requested LB policy %s but provided at least one "
-                "balancer address -- forcing use of grpclb LB policy",
-                lb_policy_name_.get());
-      }
-      lb_policy_name_.reset(gpr_strdup("grpclb"));
+  }
+  if (found_balancer_address) {
+    if (lb_policy_name_ != nullptr &&
+        strcmp(lb_policy_name_.get(), "grpclb") != 0) {
+      gpr_log(GPR_INFO,
+              "resolver requested LB policy %s but provided at least one "
+              "balancer address -- forcing use of grpclb LB policy",
+              lb_policy_name_.get());
     }
+    lb_policy_name_.reset(gpr_strdup("grpclb"));
   }
   // Use pick_first if nothing was specified and we didn't select grpclb
   // above.
@@ -148,7 +167,8 @@ void ProcessedResolverResult::ParseLbConfigFromServiceConfig(
       LoadBalancingPolicy::ParseLoadBalancingConfig(field);
   if (policy != nullptr) {
     lb_policy_name_.reset(gpr_strdup(policy->key));
-    lb_policy_config_ = policy->child;
+    lb_policy_config_ =
+        MakeRefCounted<LoadBalancingPolicy::Config>(policy, service_config_);
   }
 }
 

data/src/core/ext/filters/client_channel/resolver_result_parsing.h

@@ -21,14 +21,16 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "src/core/ext/filters/client_channel/lb_policy.h"
+#include "src/core/ext/filters/client_channel/resolver.h"
 #include "src/core/ext/filters/client_channel/retry_throttle.h"
+#include "src/core/ext/filters/client_channel/service_config.h"
 #include "src/core/lib/channel/status_util.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/iomgr/exec_ctx.h"  // for grpc_millis
 #include "src/core/lib/json/json.h"
 #include "src/core/lib/slice/slice_hash_table.h"
-#include "src/core/lib/transport/service_config.h"
 
 namespace grpc_core {
 namespace internal {
@@ -46,8 +48,7 @@ class ProcessedResolverResult {
   // Processes the resolver result and populates the relative members
   // for later consumption. Tries to parse retry parameters only if parse_retry
   // is true.
-  ProcessedResolverResult(const grpc_channel_args& resolver_result,
-                          bool parse_retry);
+  ProcessedResolverResult(Resolver::Result* resolver_result, bool parse_retry);
 
   // Getters. Any managed object's ownership is transferred.
   UniquePtr<char> service_config_json() {
@@ -60,16 +61,18 @@ class ProcessedResolverResult {
     return std::move(method_params_table_);
   }
   UniquePtr<char> lb_policy_name() { return std::move(lb_policy_name_); }
-  grpc_json* lb_policy_config() { return lb_policy_config_; }
+  RefCountedPtr<LoadBalancingPolicy::Config> lb_policy_config() {
+    return std::move(lb_policy_config_);
+  }
 
  private:
   // Finds the service config; extracts LB config and (maybe) retry throttle
   // params from it.
-  void ProcessServiceConfig(const grpc_channel_args& resolver_result,
+  void ProcessServiceConfig(const Resolver::Result& resolver_result,
                             bool parse_retry);
 
   // Finds the LB policy name (when no LB config was found).
-  void ProcessLbPolicyName(const grpc_channel_args& resolver_result);
+  void ProcessLbPolicyName(const Resolver::Result& resolver_result);
 
   // Parses the service config. Intended to be used by
   // ServiceConfig::ParseGlobalParams.
@@ -82,10 +85,10 @@ class ProcessedResolverResult {
 
   // Service config.
   UniquePtr<char> service_config_json_;
-  UniquePtr<grpc_core::ServiceConfig> service_config_;
+  RefCountedPtr<ServiceConfig> service_config_;
   // LB policy.
-  grpc_json* lb_policy_config_ = nullptr;
   UniquePtr<char> lb_policy_name_;
+  RefCountedPtr<LoadBalancingPolicy::Config> lb_policy_config_;
   // Retry throttle data.
   char* server_name_ = nullptr;
   RefCountedPtr<ServerRetryThrottleData> retry_throttle_data_;