grpc 1.31.1 → 1.35.0.pre1

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

@@ -23,6 +23,8 @@
 #include <limits.h>
 #include <string.h>
 
+#include <string>
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/atm.h>
 #include <grpc/support/string_util.h>
@@ -164,20 +166,20 @@ void ServerRetryThrottleMap::Shutdown() {
 }
 
 RefCountedPtr<ServerRetryThrottleData> ServerRetryThrottleMap::GetDataForServer(
-    const char* server_name, intptr_t max_milli_tokens,
+    const std::string& server_name, intptr_t max_milli_tokens,
     intptr_t milli_token_ratio) {
   RefCountedPtr<ServerRetryThrottleData> result;
   gpr_mu_lock(&g_mu);
   ServerRetryThrottleData* throttle_data =
       static_cast<ServerRetryThrottleData*>(
-          grpc_avl_get(g_avl, const_cast<char*>(server_name), nullptr));
+          grpc_avl_get(g_avl, const_cast<char*>(server_name.c_str()), nullptr));
   if (throttle_data == nullptr ||
       throttle_data->max_milli_tokens() != max_milli_tokens ||
       throttle_data->milli_token_ratio() != milli_token_ratio) {
     // Entry not found, or found with old parameters.  Create a new one.
     result = MakeRefCounted<ServerRetryThrottleData>(
         max_milli_tokens, milli_token_ratio, throttle_data);
-    g_avl = grpc_avl_add(g_avl, gpr_strdup(server_name),
+    g_avl = grpc_avl_add(g_avl, gpr_strdup(server_name.c_str()),
                          result->Ref().release(), nullptr);
   } else {
     // Entry found.  Return a new ref to it.

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

@@ -21,6 +21,8 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <string>
+
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 
@@ -32,7 +34,7 @@ class ServerRetryThrottleData : public RefCounted<ServerRetryThrottleData> {
  public:
   ServerRetryThrottleData(intptr_t max_milli_tokens, intptr_t milli_token_ratio,
                           ServerRetryThrottleData* old_throttle_data);
-  ~ServerRetryThrottleData();
+  ~ServerRetryThrottleData() override;
 
   /// Records a failure.  Returns true if it's okay to send a retry.
   bool RecordFailure();
@@ -67,7 +69,7 @@ class ServerRetryThrottleMap {
   /// Returns the failure data for \a server_name, creating a new entry if
   /// needed.
   static RefCountedPtr<ServerRetryThrottleData> GetDataForServer(
-      const char* server_name, intptr_t max_milli_tokens,
+      const std::string& server_name, intptr_t max_milli_tokens,
       intptr_t milli_token_ratio);
 };
 

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

@@ -20,29 +20,142 @@
 
 #include "src/core/ext/filters/client_channel/server_address.h"
 
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_join.h"
+
+#include "src/core/lib/iomgr/sockaddr_utils.h"
+
 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);
 }
 
+ServerAddress::ServerAddress(const ServerAddress& other)
+    : address_(other.address_), args_(grpc_channel_args_copy(other.args_)) {
+  for (const auto& p : other.attributes_) {
+    attributes_[p.first] = p.second->Copy();
+  }
+}
+ServerAddress& 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;
+}
+
+ServerAddress::ServerAddress(ServerAddress&& other) noexcept
+    : address_(other.address_),
+      args_(other.args_),
+      attributes_(std::move(other.attributes_)) {
+  other.args_ = nullptr;
+}
+ServerAddress& ServerAddress::operator=(ServerAddress&& other) noexcept {
+  address_ = other.address_;
+  grpc_channel_args_destroy(args_);
+  args_ = other.args_;
+  other.args_ = nullptr;
+  attributes_ = std::move(other.attributes_);
+  return *this;
+}
+
+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_);
+}
+
+const ServerAddress::AttributeInterface* ServerAddress::GetAttribute(
+    const char* key) const {
+  auto it = attributes_.find(key);
+  if (it == attributes_.end()) return nullptr;
+  return it->second.get();
+}
+
+// Returns a copy of the address with a modified attribute.
+// If the new value is null, the attribute is removed.
+ServerAddress ServerAddress::WithAttribute(
+    const char* key, std::unique_ptr<AttributeInterface> value) const {
+  ServerAddress address = *this;
+  if (value == nullptr) {
+    address.attributes_.erase(key);
+  } else {
+    address.attributes_[key] = std::move(value);
+  }
+  return address;
+}
+
+std::string ServerAddress::ToString() const {
+  std::vector<std::string> parts = {
+      grpc_sockaddr_to_string(&address_, false),
+  };
+  if (args_ != nullptr) {
+    parts.emplace_back(
+        absl::StrCat("args={", grpc_channel_args_string(args_), "}"));
+  }
+  if (!attributes_.empty()) {
+    std::vector<std::string> attrs;
+    for (const auto& p : attributes_) {
+      attrs.emplace_back(absl::StrCat(p.first, "=", p.second->ToString()));
+    }
+    parts.emplace_back(
+        absl::StrCat("attributes={", absl::StrJoin(attrs, ", "), "}"));
+  }
+  return absl::StrJoin(parts, " ");
 }
 
 }  // namespace grpc_core

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

@@ -21,6 +21,9 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <map>
+#include <memory>
+
 #include "absl/container/inlined_vector.h"
 
 #include "src/core/lib/channel/channel_args.h"
@@ -37,35 +40,45 @@ 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.
+  //
+  // Attributes are keyed by a C string that is unique by address, not
+  // by value.  All attributes added with the same key must be of the
+  // same type.
+  class AttributeInterface {
+   public:
+    virtual ~AttributeInterface() = default;
+
+    // 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;
+
+    // Returns a human-readable representation of the attribute.
+    virtual std::string ToString() 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_)) {}
-  ServerAddress& operator=(const ServerAddress& other) {
-    address_ = other.address_;
-    grpc_channel_args_destroy(args_);
-    args_ = grpc_channel_args_copy(other.args_);
-    return *this;
-  }
+  ServerAddress(const ServerAddress& other);
+  ServerAddress& operator=(const ServerAddress& other);
 
   // Movable.
-  ServerAddress(ServerAddress&& other)
-      : address_(other.address_), args_(other.args_) {
-    other.args_ = nullptr;
-  }
-  ServerAddress& operator=(ServerAddress&& other) {
-    address_ = other.address_;
-    grpc_channel_args_destroy(args_);
-    args_ = other.args_;
-    other.args_ = nullptr;
-    return *this;
-  }
+  ServerAddress(ServerAddress&& other) noexcept;
+  ServerAddress& operator=(ServerAddress&& other) noexcept;
 
   bool operator==(const ServerAddress& other) const { return Cmp(other) == 0; }
 
@@ -74,9 +87,19 @@ 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;
+
+  // Returns a copy of the address with a modified attribute.
+  // If the new value is null, the attribute is removed.
+  ServerAddress WithAttribute(const char* key,
+                              std::unique_ptr<AttributeInterface> value) const;
+
+  std::string ToString() const;
+
  private:
   grpc_resolved_address address_;
   grpc_channel_args* args_;
+  std::map<const char*, std::unique_ptr<AttributeInterface>> attributes_;
 };
 
 //

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

@@ -31,16 +31,17 @@
 namespace grpc_core {
 
 RefCountedPtr<ServiceConfig> ServiceConfig::Create(
-    absl::string_view json_string, grpc_error** error) {
+    const grpc_channel_args* args, absl::string_view json_string,
+    grpc_error** error) {
   GPR_DEBUG_ASSERT(error != nullptr);
   Json json = Json::Parse(json_string, error);
   if (*error != GRPC_ERROR_NONE) return nullptr;
-  return MakeRefCounted<ServiceConfig>(
-      std::string(json_string.data(), json_string.size()), std::move(json),
-      error);
+  return MakeRefCounted<ServiceConfig>(args, std::string(json_string),
+                                       std::move(json), error);
 }
 
-ServiceConfig::ServiceConfig(std::string json_string, Json json,
+ServiceConfig::ServiceConfig(const grpc_channel_args* args,
+                             std::string json_string, Json json,
                              grpc_error** error)
     : json_string_(std::move(json_string)), json_(std::move(json)) {
   GPR_DEBUG_ASSERT(error != nullptr);
@@ -52,9 +53,9 @@ ServiceConfig::ServiceConfig(std::string json_string, Json json,
   std::vector<grpc_error*> error_list;
   grpc_error* global_error = GRPC_ERROR_NONE;
   parsed_global_configs_ =
-      ServiceConfigParser::ParseGlobalParameters(json_, &global_error);
+      ServiceConfigParser::ParseGlobalParameters(args, json_, &global_error);
   if (global_error != GRPC_ERROR_NONE) error_list.push_back(global_error);
-  grpc_error* local_error = ParsePerMethodParams();
+  grpc_error* local_error = ParsePerMethodParams(args);
   if (local_error != GRPC_ERROR_NONE) error_list.push_back(local_error);
   if (!error_list.empty()) {
     *error = GRPC_ERROR_CREATE_FROM_VECTOR("Service config parsing error",
@@ -68,14 +69,15 @@ ServiceConfig::~ServiceConfig() {
   }
 }
 
-grpc_error* ServiceConfig::ParseJsonMethodConfig(const Json& json) {
+grpc_error* ServiceConfig::ParseJsonMethodConfig(const grpc_channel_args* args,
+                                                 const Json& json) {
   std::vector<grpc_error*> error_list;
   // Parse method config with each registered parser.
   auto parsed_configs =
       absl::make_unique<ServiceConfigParser::ParsedConfigVector>();
   grpc_error* parser_error = GRPC_ERROR_NONE;
   *parsed_configs =
-      ServiceConfigParser::ParsePerMethodParameters(json, &parser_error);
+      ServiceConfigParser::ParsePerMethodParameters(args, json, &parser_error);
   if (parser_error != GRPC_ERROR_NONE) {
     error_list.push_back(parser_error);
   }
@@ -128,7 +130,7 @@ grpc_error* ServiceConfig::ParseJsonMethodConfig(const Json& json) {
   return GRPC_ERROR_CREATE_FROM_VECTOR("methodConfig", &error_list);
 }
 
-grpc_error* ServiceConfig::ParsePerMethodParams() {
+grpc_error* ServiceConfig::ParsePerMethodParams(const grpc_channel_args* args) {
   std::vector<grpc_error*> error_list;
   auto it = json_.object_value().find("methodConfig");
   if (it != json_.object_value().end()) {
@@ -142,7 +144,7 @@ grpc_error* ServiceConfig::ParsePerMethodParams() {
             "field:methodConfig error:not of type Object"));
         continue;
       }
-      grpc_error* error = ParseJsonMethodConfig(method_config);
+      grpc_error* error = ParseJsonMethodConfig(args, method_config);
       if (error != GRPC_ERROR_NONE) {
         error_list.push_back(error);
       }
@@ -202,15 +204,18 @@ std::string ServiceConfig::ParseJsonMethodName(const Json& json,
 
 const ServiceConfigParser::ParsedConfigVector*
 ServiceConfig::GetMethodParsedConfigVector(const grpc_slice& path) const {
+  if (parsed_method_configs_map_.empty()) {
+    return default_method_config_vector_;
+  }
   // Try looking up the full path in the map.
   auto it = parsed_method_configs_map_.find(path);
   if (it != parsed_method_configs_map_.end()) return it->second;
   // If we didn't find a match for the path, try looking for a wildcard
   // entry (i.e., change "/service/method" to "/service/").
   UniquePtr<char> path_str(grpc_slice_to_c_string(path));
-  char* sep = strrchr(path_str.get(), '/') + 1;
+  char* sep = strrchr(path_str.get(), '/');
   if (sep == nullptr) return nullptr;  // Shouldn't ever happen.
-  *sep = '\0';
+  sep[1] = '\0';
   grpc_slice wildcard_path = grpc_slice_from_static_string(path_str.get());
   it = parsed_method_configs_map_.find(wildcard_path);
   if (it != parsed_method_configs_map_.end()) return it->second;

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

@@ -65,11 +65,13 @@ class ServiceConfig : public RefCounted<ServiceConfig> {
  public:
   /// Creates a new service config from parsing \a json_string.
   /// Returns null on parse error.
-  static RefCountedPtr<ServiceConfig> Create(absl::string_view json_string,
+  static RefCountedPtr<ServiceConfig> Create(const grpc_channel_args* args,
+                                             absl::string_view json_string,
                                              grpc_error** error);
 
-  ServiceConfig(std::string json_string, Json json, grpc_error** error);
-  ~ServiceConfig();
+  ServiceConfig(const grpc_channel_args* args, std::string json_string,
+                Json json, grpc_error** error);
+  ~ServiceConfig() override;
 
   const std::string& json_string() const { return json_string_; }
 
@@ -89,8 +91,9 @@ class ServiceConfig : public RefCounted<ServiceConfig> {
 
  private:
   // Helper functions for parsing the method configs.
-  grpc_error* ParsePerMethodParams();
-  grpc_error* ParseJsonMethodConfig(const Json& json);
+  grpc_error* ParsePerMethodParams(const grpc_channel_args* args);
+  grpc_error* ParseJsonMethodConfig(const grpc_channel_args* args,
+                                    const Json& json);
 
   // Returns a path string for the JSON name object specified by json.
   // Sets *error on error.

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

@@ -19,6 +19,10 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <map>
+
+#include "absl/strings/string_view.h"
+
 #include "src/core/ext/filters/client_channel/service_config.h"
 #include "src/core/ext/filters/client_channel/service_config_parser.h"
 #include "src/core/lib/channel/context.h"
@@ -35,13 +39,22 @@ class ServiceConfigCallData {
   ServiceConfigCallData(
       RefCountedPtr<ServiceConfig> service_config,
       const ServiceConfigParser::ParsedConfigVector* method_configs,
+      std::map<const char*, absl::string_view> call_attributes,
       grpc_call_context_element* call_context)
       : service_config_(std::move(service_config)),
-        method_configs_(method_configs) {
+        method_configs_(method_configs),
+        call_attributes_(std::move(call_attributes)) {
     call_context[GRPC_CONTEXT_SERVICE_CONFIG_CALL_DATA].value = this;
     call_context[GRPC_CONTEXT_SERVICE_CONFIG_CALL_DATA].destroy = Destroy;
   }
 
+  ServiceConfigCallData(
+      RefCountedPtr<ServiceConfig> service_config,
+      const ServiceConfigParser::ParsedConfigVector* method_configs,
+      grpc_call_context_element* call_context)
+      : ServiceConfigCallData(std::move(service_config), method_configs, {},
+                              call_context) {}
+
   ServiceConfig* service_config() { return service_config_.get(); }
 
   ServiceConfigParser::ParsedConfig* GetMethodParsedConfig(size_t index) const {
@@ -53,6 +66,10 @@ class ServiceConfigCallData {
     return service_config_->GetGlobalParsedConfig(index);
   }
 
+  const std::map<const char*, absl::string_view>& call_attributes() const {
+    return call_attributes_;
+  }
+
  private:
   static void Destroy(void* ptr) {
     ServiceConfigCallData* self = static_cast<ServiceConfigCallData*>(ptr);
@@ -61,6 +78,7 @@ class ServiceConfigCallData {
 
   RefCountedPtr<ServiceConfig> service_config_;
   const ServiceConfigParser::ParsedConfigVector* method_configs_ = nullptr;
+  std::map<const char*, absl::string_view> call_attributes_;
 };
 
 }  // namespace grpc_core