grpc 1.30.2 → 1.32.0

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

@@ -23,6 +23,7 @@
 #include <string.h>
 
 #include "absl/container/inlined_vector.h"
+#include "absl/strings/str_cat.h"
 
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
@@ -65,22 +66,22 @@ class RegistryState {
   // If \a default_prefix_ needs to be prepended, sets \a canonical_target
   // to the canonical target string.
   ResolverFactory* FindResolverFactory(const char* target, grpc_uri** uri,
-                                       char** canonical_target) const {
+                                       std::string* canonical_target) const {
     GPR_ASSERT(uri != nullptr);
     *uri = grpc_uri_parse(target, 1);
     ResolverFactory* factory =
         *uri == nullptr ? nullptr : LookupResolverFactory((*uri)->scheme);
     if (factory == nullptr) {
       grpc_uri_destroy(*uri);
-      gpr_asprintf(canonical_target, "%s%s", default_prefix_.get(), target);
-      *uri = grpc_uri_parse(*canonical_target, 1);
+      *canonical_target = absl::StrCat(default_prefix_.get(), target);
+      *uri = grpc_uri_parse(canonical_target->c_str(), 1);
       factory =
           *uri == nullptr ? nullptr : LookupResolverFactory((*uri)->scheme);
       if (factory == nullptr) {
         grpc_uri_destroy(grpc_uri_parse(target, 0));
-        grpc_uri_destroy(grpc_uri_parse(*canonical_target, 0));
+        grpc_uri_destroy(grpc_uri_parse(canonical_target->c_str(), 0));
         gpr_log(GPR_ERROR, "don't know how to resolve '%s' or '%s'", target,
-                *canonical_target);
+                canonical_target->c_str());
       }
     }
     return factory;
@@ -136,12 +137,11 @@ ResolverFactory* ResolverRegistry::LookupResolverFactory(const char* scheme) {
 
 bool ResolverRegistry::IsValidTarget(const char* target) {
   grpc_uri* uri = nullptr;
-  char* canonical_target = nullptr;
+  std::string canonical_target;
   ResolverFactory* factory =
       g_state->FindResolverFactory(target, &uri, &canonical_target);
   bool result = factory == nullptr ? false : factory->IsValidUri(uri);
   grpc_uri_destroy(uri);
-  gpr_free(canonical_target);
   return result;
 }
 
@@ -152,7 +152,7 @@ OrphanablePtr<Resolver> ResolverRegistry::CreateResolver(
     std::unique_ptr<Resolver::ResultHandler> result_handler) {
   GPR_ASSERT(g_state != nullptr);
   grpc_uri* uri = nullptr;
-  char* canonical_target = nullptr;
+  std::string canonical_target;
   ResolverFactory* factory =
       g_state->FindResolverFactory(target, &uri, &canonical_target);
   ResolverArgs resolver_args;
@@ -165,7 +165,6 @@ OrphanablePtr<Resolver> ResolverRegistry::CreateResolver(
       factory == nullptr ? nullptr
                          : factory->CreateResolver(std::move(resolver_args));
   grpc_uri_destroy(uri);
-  gpr_free(canonical_target);
   return resolver;
 }
 
@@ -173,13 +172,12 @@ grpc_core::UniquePtr<char> ResolverRegistry::GetDefaultAuthority(
     const char* target) {
   GPR_ASSERT(g_state != nullptr);
   grpc_uri* uri = nullptr;
-  char* canonical_target = nullptr;
+  std::string canonical_target;
   ResolverFactory* factory =
       g_state->FindResolverFactory(target, &uri, &canonical_target);
   grpc_core::UniquePtr<char> authority =
       factory == nullptr ? nullptr : factory->GetDefaultAuthority(uri);
   grpc_uri_destroy(uri);
-  gpr_free(canonical_target);
   return authority;
 }
 
@@ -187,11 +185,12 @@ grpc_core::UniquePtr<char> ResolverRegistry::AddDefaultPrefixIfNeeded(
     const char* target) {
   GPR_ASSERT(g_state != nullptr);
   grpc_uri* uri = nullptr;
-  char* canonical_target = nullptr;
+  std::string canonical_target;
   g_state->FindResolverFactory(target, &uri, &canonical_target);
   grpc_uri_destroy(uri);
-  return grpc_core::UniquePtr<char>(
-      canonical_target == nullptr ? gpr_strdup(target) : canonical_target);
+  return grpc_core::UniquePtr<char>(canonical_target.empty()
+                                        ? gpr_strdup(target)
+                                        : gpr_strdup(canonical_target.c_str()));
 }
 
 }  // namespace grpc_core

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

@@ -24,6 +24,7 @@
 #include <stdio.h>
 #include <string.h>
 
+#include "absl/strings/str_cat.h"
 #include "absl/types/optional.h"
 
 #include <grpc/support/alloc.h>
@@ -353,13 +354,11 @@ ClientChannelServiceConfigParser::ParseGlobalParams(const Json& json,
         error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
             "field:loadBalancingPolicy error:Unknown lb policy"));
       } else if (requires_config) {
-        char* error_msg;
-        gpr_asprintf(&error_msg,
-                     "field:loadBalancingPolicy error:%s requires a config. "
-                     "Please use loadBalancingConfig instead.",
-                     lb_policy_name.c_str());
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_COPIED_STRING(error_msg));
-        gpr_free(error_msg);
+        error_list.push_back(GRPC_ERROR_CREATE_FROM_COPIED_STRING(
+            absl::StrCat("field:loadBalancingPolicy error:", lb_policy_name,
+                         " requires a config. Please use loadBalancingConfig "
+                         "instead.")
+                .c_str()));
       }
     }
   }

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

@@ -33,7 +33,6 @@
 #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"
 
 namespace grpc_core {
 namespace internal {

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

@@ -114,10 +114,11 @@ class ResolvingLoadBalancingPolicy::ResolvingControlHelper
     return parent_->channel_control_helper()->CreateSubchannel(args);
   }
 
-  void UpdateState(grpc_connectivity_state state,
+  void UpdateState(grpc_connectivity_state state, const absl::Status& status,
                    std::unique_ptr<SubchannelPicker> picker) override {
     if (parent_->resolver_ == nullptr) return;  // Shutting down.
-    parent_->channel_control_helper()->UpdateState(state, std::move(picker));
+    parent_->channel_control_helper()->UpdateState(state, status,
+                                                   std::move(picker));
   }
 
   void RequestReresolution() override {
@@ -145,14 +146,12 @@ class ResolvingLoadBalancingPolicy::ResolvingControlHelper
 
 ResolvingLoadBalancingPolicy::ResolvingLoadBalancingPolicy(
     Args args, TraceFlag* tracer, grpc_core::UniquePtr<char> target_uri,
-    ProcessResolverResultCallback process_resolver_result,
-    void* process_resolver_result_user_data)
+    ChannelConfigHelper* helper)
     : LoadBalancingPolicy(std::move(args)),
       tracer_(tracer),
       target_uri_(std::move(target_uri)),
-      process_resolver_result_(process_resolver_result),
-      process_resolver_result_user_data_(process_resolver_result_user_data) {
-  GPR_ASSERT(process_resolver_result != nullptr);
+      helper_(helper) {
+  GPR_ASSERT(helper_ != nullptr);
   resolver_ = ResolverRegistry::CreateResolver(
       target_uri_.get(), args.args, interested_parties(), work_serializer(),
       absl::make_unique<ResolverResultHandler>(Ref()));
@@ -162,7 +161,7 @@ ResolvingLoadBalancingPolicy::ResolvingLoadBalancingPolicy(
   if (GRPC_TRACE_FLAG_ENABLED(*tracer_)) {
     gpr_log(GPR_INFO, "resolving_lb=%p: starting name resolution", this);
   }
-  channel_control_helper()->UpdateState(GRPC_CHANNEL_CONNECTING,
+  channel_control_helper()->UpdateState(GRPC_CHANNEL_CONNECTING, absl::Status(),
                                         absl::make_unique<QueuePicker>(Ref()));
   resolver_->StartLocked();
 }
@@ -214,8 +213,9 @@ void ResolvingLoadBalancingPolicy::OnResolverError(grpc_error* error) {
   if (lb_policy_ == nullptr) {
     grpc_error* state_error = GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
         "Resolver transient failure", &error, 1);
+    helper_->ResolverTransientFailure(GRPC_ERROR_REF(state_error));
     channel_control_helper()->UpdateState(
-        GRPC_CHANNEL_TRANSIENT_FAILURE,
+        GRPC_CHANNEL_TRANSIENT_FAILURE, grpc_error_to_absl_status(state_error),
         absl::make_unique<TransientFailurePicker>(state_error));
   }
   GRPC_ERROR_UNREF(error);
@@ -304,45 +304,51 @@ void ResolvingLoadBalancingPolicy::OnResolverResultChangedLocked(
   TraceStringVector trace_strings;
   const bool resolution_contains_addresses = result.addresses.size() > 0;
   // Process the resolver result.
-  RefCountedPtr<LoadBalancingPolicy::Config> lb_policy_config;
-  bool service_config_changed = false;
-  std::string service_config_error_string;
-  if (process_resolver_result_ != nullptr) {
-    grpc_error* service_config_error = GRPC_ERROR_NONE;
-    bool no_valid_service_config = false;
-    service_config_changed = process_resolver_result_(
-        process_resolver_result_user_data_, result, &lb_policy_config,
-        &service_config_error, &no_valid_service_config);
-    if (service_config_error != GRPC_ERROR_NONE) {
-      service_config_error_string = grpc_error_string(service_config_error);
-      if (no_valid_service_config) {
+  ChannelConfigHelper::ApplyServiceConfigResult service_config_result;
+  if (helper_ != nullptr) {
+    service_config_result = helper_->ApplyServiceConfig(result);
+    if (service_config_result.service_config_error != GRPC_ERROR_NONE) {
+      if (service_config_result.no_valid_service_config) {
         // We received an invalid service config and we don't have a
         // fallback service config.
-        OnResolverError(service_config_error);
-      } else {
-        GRPC_ERROR_UNREF(service_config_error);
+        OnResolverError(service_config_result.service_config_error);
+        service_config_result.service_config_error = GRPC_ERROR_NONE;
       }
     }
   } else {
-    lb_policy_config = child_lb_config_;
+    service_config_result.lb_policy_config = child_lb_config_;
   }
-  if (lb_policy_config != nullptr) {
-    // Create or update LB policy, as needed.
-    CreateOrUpdateLbPolicyLocked(std::move(lb_policy_config),
-                                 std::move(result));
+  // Before we send the args to the LB policy, grab the ConfigSelector for
+  // later use.
+  RefCountedPtr<ConfigSelector> config_selector =
+      ConfigSelector::GetFromChannelArgs(*result.args);
+  // Create or update LB policy, as needed.
+  if (service_config_result.lb_policy_config != nullptr) {
+    CreateOrUpdateLbPolicyLocked(
+        std::move(service_config_result.lb_policy_config), std::move(result));
+  }
+  // Apply ConfigSelector to channel.
+  // This needs to happen after the LB policy has been updated, since
+  // the ConfigSelector may need the LB policy to know about new
+  // destinations before it can send RPCs to those destinations.
+  if (helper_ != nullptr) {
+    helper_->ApplyConfigSelector(service_config_result.service_config_changed,
+                                 std::move(config_selector));
   }
   // Add channel trace event.
-  if (service_config_changed) {
+  if (service_config_result.service_config_changed) {
     // TODO(ncteisen): might be worth somehow including a snippet of the
     // config in the trace, at the risk of bloating the trace logs.
     trace_strings.push_back("Service config changed");
   }
-  if (!service_config_error_string.empty()) {
-    trace_strings.push_back(service_config_error_string.c_str());
+  if (service_config_result.service_config_error != GRPC_ERROR_NONE) {
+    trace_strings.push_back(
+        grpc_error_string(service_config_result.service_config_error));
   }
   MaybeAddTraceMessagesForAddressChangesLocked(resolution_contains_addresses,
                                                &trace_strings);
   ConcatenateAndAddChannelTraceLocked(trace_strings);
+  GRPC_ERROR_UNREF(service_config_result.service_config_error);
 }
 
 }  // namespace grpc_core

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

@@ -23,6 +23,7 @@
 
 #include "absl/container/inlined_vector.h"
 
+#include "src/core/ext/filters/client_channel/config_selector.h"
 #include "src/core/ext/filters/client_channel/lb_policy.h"
 #include "src/core/ext/filters/client_channel/lb_policy_factory.h"
 #include "src/core/ext/filters/client_channel/resolver.h"
@@ -52,22 +53,39 @@ namespace grpc_core {
 // child LB policy and config to use.
 class ResolvingLoadBalancingPolicy : public LoadBalancingPolicy {
  public:
-  // Synchronous callback that takes the resolver result and sets
-  // lb_policy_config to point to the right data.
-  // Returns true if the service config has changed since the last result.
-  // If the returned no_valid_service_config is true, that means that we
-  // don't have a valid service config to use, and we should set the channel
-  // to be in TRANSIENT_FAILURE.
-  typedef bool (*ProcessResolverResultCallback)(
-      void* user_data, const Resolver::Result& result,
-      RefCountedPtr<LoadBalancingPolicy::Config>* lb_policy_config,
-      grpc_error** service_config_error, bool* no_valid_service_config);
-  // If error is set when this returns, then construction failed, and
-  // the caller may not use the new object.
-  ResolvingLoadBalancingPolicy(
-      Args args, TraceFlag* tracer, grpc_core::UniquePtr<char> target_uri,
-      ProcessResolverResultCallback process_resolver_result,
-      void* process_resolver_result_user_data);
+  class ChannelConfigHelper {
+   public:
+    struct ApplyServiceConfigResult {
+      // Set to true if the service config has changed since the last result.
+      bool service_config_changed = false;
+      // Set to true if we don't have a valid service config to use.
+      // This tells the ResolvingLoadBalancingPolicy to put the channel
+      // into TRANSIENT_FAILURE.
+      bool no_valid_service_config = false;
+      // A service config parsing error occurred.
+      grpc_error* service_config_error = GRPC_ERROR_NONE;
+      // The LB policy config to use.
+      RefCountedPtr<LoadBalancingPolicy::Config> lb_policy_config;
+    };
+
+    virtual ~ChannelConfigHelper() = default;
+
+    // Applies the service config to the channel.
+    virtual ApplyServiceConfigResult ApplyServiceConfig(
+        const Resolver::Result& result) = 0;
+
+    // Applies the ConfigSelector to the channel.
+    virtual void ApplyConfigSelector(
+        bool service_config_changed,
+        RefCountedPtr<ConfigSelector> config_selector) = 0;
+
+    // Indicates a resolver transient failure.
+    virtual void ResolverTransientFailure(grpc_error* error) = 0;
+  };
+
+  ResolvingLoadBalancingPolicy(Args args, TraceFlag* tracer,
+                               grpc_core::UniquePtr<char> target_uri,
+                               ChannelConfigHelper* helper);
 
   virtual const char* name() const override { return "resolving_lb"; }
 
@@ -105,15 +123,16 @@ class ResolvingLoadBalancingPolicy : public LoadBalancingPolicy {
   // Passed in from caller at construction time.
   TraceFlag* tracer_;
   grpc_core::UniquePtr<char> target_uri_;
-  ProcessResolverResultCallback process_resolver_result_ = nullptr;
-  void* process_resolver_result_user_data_ = nullptr;
-  grpc_core::UniquePtr<char> child_policy_name_;
-  RefCountedPtr<LoadBalancingPolicy::Config> child_lb_config_;
+  ChannelConfigHelper* helper_;
 
   // Resolver and associated state.
   OrphanablePtr<Resolver> resolver_;
   bool previous_resolution_contained_addresses_ = false;
 
+  // Determined by resolver results.
+  grpc_core::UniquePtr<char> child_policy_name_;
+  RefCountedPtr<LoadBalancingPolicy::Config> child_lb_config_;
+
   // Child LB policy.
   OrphanablePtr<LoadBalancingPolicy> lb_policy_;
 };

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

@@ -26,23 +26,56 @@ namespace grpc_core {
 // ServerAddress
 //
 
-ServerAddress::ServerAddress(const grpc_resolved_address& address,
-                             grpc_channel_args* args)
-    : address_(address), args_(args) {}
+ServerAddress::ServerAddress(
+    const grpc_resolved_address& address, grpc_channel_args* args,
+    std::map<const char*, std::unique_ptr<AttributeInterface>> attributes)
+    : address_(address), args_(args), attributes_(std::move(attributes)) {}
 
-ServerAddress::ServerAddress(const void* address, size_t address_len,
-                             grpc_channel_args* args)
-    : args_(args) {
+ServerAddress::ServerAddress(
+    const void* address, size_t address_len, grpc_channel_args* args,
+    std::map<const char*, std::unique_ptr<AttributeInterface>> attributes)
+    : args_(args), attributes_(std::move(attributes)) {
   memcpy(address_.addr, address, address_len);
   address_.len = static_cast<socklen_t>(address_len);
 }
 
+namespace {
+
+int CompareAttributes(
+    const std::map<const char*,
+                   std::unique_ptr<ServerAddress::AttributeInterface>>&
+        attributes1,
+    const std::map<const char*,
+                   std::unique_ptr<ServerAddress::AttributeInterface>>&
+        attributes2) {
+  auto it2 = attributes2.begin();
+  for (auto it1 = attributes1.begin(); it1 != attributes1.end(); ++it1) {
+    // attributes2 has fewer elements than attributes1
+    if (it2 == attributes2.end()) return -1;
+    // compare keys
+    int retval = strcmp(it1->first, it2->first);
+    if (retval != 0) return retval;
+    // compare values
+    retval = it1->second->Cmp(it2->second.get());
+    if (retval != 0) return retval;
+    ++it2;
+  }
+  // attributes1 has fewer elements than attributes2
+  if (it2 != attributes2.end()) return 1;
+  // equal
+  return 0;
+}
+
+}  // namespace
+
 int ServerAddress::Cmp(const ServerAddress& other) const {
   if (address_.len > other.address_.len) return 1;
   if (address_.len < other.address_.len) return -1;
   int retval = memcmp(address_.addr, other.address_.addr, address_.len);
   if (retval != 0) return retval;
-  return grpc_channel_args_compare(args_, other.args_);
+  retval = grpc_channel_args_compare(args_, other.args_);
+  if (retval != 0) return retval;
+  return CompareAttributes(attributes_, other.attributes_);
 }
 
 }  // namespace grpc_core

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

@@ -21,6 +21,8 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <map>
+
 #include "absl/container/inlined_vector.h"
 
 #include "src/core/lib/channel/channel_args.h"
@@ -37,26 +39,54 @@ namespace grpc_core {
 // args when a subchannel is created for this address.
 class ServerAddress {
  public:
+  // Base class for resolver-supplied attributes.
+  // Unlike channel args, these attributes don't affect subchannel
+  // uniqueness or behavior.  They are for use by LB policies only.
+  class AttributeInterface {
+   public:
+    virtual ~AttributeInterface();
+
+    // Creates a copy of the attribute.
+    virtual std::unique_ptr<AttributeInterface> Copy() const = 0;
+
+    // Compares this attribute with another.
+    virtual int Cmp(const AttributeInterface* other) const = 0;
+  };
+
   // Takes ownership of args.
-  ServerAddress(const grpc_resolved_address& address, grpc_channel_args* args);
+  ServerAddress(const grpc_resolved_address& address, grpc_channel_args* args,
+                std::map<const char*, std::unique_ptr<AttributeInterface>>
+                    attributes = {});
   ServerAddress(const void* address, size_t address_len,
-                grpc_channel_args* args);
+                grpc_channel_args* args,
+                std::map<const char*, std::unique_ptr<AttributeInterface>>
+                    attributes = {});
 
   ~ServerAddress() { grpc_channel_args_destroy(args_); }
 
   // Copyable.
   ServerAddress(const ServerAddress& other)
-      : address_(other.address_), args_(grpc_channel_args_copy(other.args_)) {}
+      : address_(other.address_), args_(grpc_channel_args_copy(other.args_)) {
+    for (const auto& p : other.attributes_) {
+      attributes_[p.first] = p.second->Copy();
+    }
+  }
   ServerAddress& operator=(const ServerAddress& other) {
     address_ = other.address_;
     grpc_channel_args_destroy(args_);
     args_ = grpc_channel_args_copy(other.args_);
+    attributes_.clear();
+    for (const auto& p : other.attributes_) {
+      attributes_[p.first] = p.second->Copy();
+    }
     return *this;
   }
 
   // Movable.
   ServerAddress(ServerAddress&& other)
-      : address_(other.address_), args_(other.args_) {
+      : address_(other.address_),
+        args_(other.args_),
+        attributes_(std::move(other.attributes_)) {
     other.args_ = nullptr;
   }
   ServerAddress& operator=(ServerAddress&& other) {
@@ -64,6 +94,7 @@ class ServerAddress {
     grpc_channel_args_destroy(args_);
     args_ = other.args_;
     other.args_ = nullptr;
+    attributes_ = std::move(other.attributes_);
     return *this;
   }
 
@@ -74,9 +105,16 @@ class ServerAddress {
   const grpc_resolved_address& address() const { return address_; }
   const grpc_channel_args* args() const { return args_; }
 
+  const AttributeInterface* GetAttribute(const char* key) const {
+    auto it = attributes_.find(key);
+    if (it == attributes_.end()) return nullptr;
+    return it->second.get();
+  }
+
  private:
   grpc_resolved_address address_;
   grpc_channel_args* args_;
+  std::map<const char*, std::unique_ptr<AttributeInterface>> attributes_;
 };
 
 //