grpc 1.56.2 → 1.58.0

data/src/core/ext/filters/client_channel/lb_policy/address_filtering.cc

@@ -23,76 +23,50 @@
 #include <algorithm>
 #include <utility>
 
-#include "absl/strings/str_cat.h"
-#include "absl/strings/str_join.h"
-
-#define GRPC_ARG_HIERARCHICAL_PATH "grpc.internal.address.hierarchical_path"
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
 
 namespace grpc_core {
 
-const char* kHierarchicalPathAttributeKey = "hierarchical_path";
-
-namespace {
-
-class HierarchicalPathAttribute : public ServerAddress::AttributeInterface {
- public:
-  explicit HierarchicalPathAttribute(std::vector<std::string> path)
-      : path_(std::move(path)) {}
-
-  std::unique_ptr<AttributeInterface> Copy() const override {
-    return std::make_unique<HierarchicalPathAttribute>(path_);
-  }
-
-  int Cmp(const AttributeInterface* other) const override {
-    const std::vector<std::string>& other_path =
-        static_cast<const HierarchicalPathAttribute*>(other)->path_;
-    for (size_t i = 0; i < path_.size(); ++i) {
-      if (other_path.size() == i) return 1;
-      int r = path_[i].compare(other_path[i]);
-      if (r != 0) return r;
-    }
-    if (other_path.size() > path_.size()) return -1;
-    return 0;
-  }
+absl::string_view HierarchicalPathArg::ChannelArgName() {
+  return GRPC_ARG_NO_SUBCHANNEL_PREFIX "address.hierarchical_path";
+}
 
-  std::string ToString() const override {
-    return absl::StrCat("[", absl::StrJoin(path_, ", "), "]");
+int HierarchicalPathArg::ChannelArgsCompare(const HierarchicalPathArg* a,
+                                            const HierarchicalPathArg* b) {
+  for (size_t i = 0; i < a->path_.size(); ++i) {
+    if (b->path_.size() == i) return 1;
+    int r = a->path_[i].as_string_view().compare(b->path_[i].as_string_view());
+    if (r != 0) return r;
   }
-
-  const std::vector<std::string>& path() const { return path_; }
-
- private:
-  std::vector<std::string> path_;
-};
-
-}  // namespace
-
-std::unique_ptr<ServerAddress::AttributeInterface>
-MakeHierarchicalPathAttribute(std::vector<std::string> path) {
-  return std::make_unique<HierarchicalPathAttribute>(std::move(path));
+  if (b->path_.size() > a->path_.size()) return -1;
+  return 0;
 }
 
 absl::StatusOr<HierarchicalAddressMap> MakeHierarchicalAddressMap(
     const absl::StatusOr<ServerAddressList>& addresses) {
   if (!addresses.ok()) return addresses.status();
   HierarchicalAddressMap result;
+  RefCountedPtr<HierarchicalPathArg> remaining_path_attr;
   for (const ServerAddress& address : *addresses) {
-    const HierarchicalPathAttribute* path_attribute =
-        static_cast<const HierarchicalPathAttribute*>(
-            address.GetAttribute(kHierarchicalPathAttributeKey));
-    if (path_attribute == nullptr) continue;
-    const std::vector<std::string>& path = path_attribute->path();
+    const auto* path_arg = address.args().GetObject<HierarchicalPathArg>();
+    if (path_arg == nullptr) continue;
+    const std::vector<RefCountedStringValue>& path = path_arg->path();
     auto it = path.begin();
+    if (it == path.end()) continue;
     ServerAddressList& target_list = result[*it];
-    std::unique_ptr<HierarchicalPathAttribute> new_attribute;
+    ChannelArgs args = address.args();
     ++it;
     if (it != path.end()) {
-      std::vector<std::string> remaining_path(it, path.end());
-      new_attribute = std::make_unique<HierarchicalPathAttribute>(
-          std::move(remaining_path));
+      std::vector<RefCountedStringValue> remaining_path(it, path.end());
+      if (remaining_path_attr == nullptr ||
+          remaining_path_attr->path() != remaining_path) {
+        remaining_path_attr =
+            MakeRefCounted<HierarchicalPathArg>(std::move(remaining_path));
+      }
+      args = args.SetObject(remaining_path_attr);
     }
-    target_list.emplace_back(address.WithAttribute(
-        kHierarchicalPathAttributeKey, std::move(new_attribute)));
+    target_list.emplace_back(address.address(), args);
   }
   return result;
 }

data/src/core/ext/filters/client_channel/lb_policy/address_filtering.h

@@ -20,12 +20,14 @@
 #include <grpc/support/port_platform.h>
 
 #include <map>
-#include <memory>
-#include <string>
+#include <utility>
 #include <vector>
 
 #include "absl/status/statusor.h"
+#include "absl/strings/string_view.h"
 
+#include "src/core/lib/gprpp/ref_counted.h"
+#include "src/core/lib/gprpp/ref_counted_string.h"
 #include "src/core/lib/resolver/server_address.h"
 
 // The resolver returns a flat list of addresses.  When a hierarchy of
@@ -82,17 +84,29 @@
 
 namespace grpc_core {
 
-// The attribute key to be used for hierarchical paths in ServerAddress.
-extern const char* kHierarchicalPathAttributeKey;
-
-// Constructs an address attribute containing the hierarchical path
+// An address channel arg containing the hierarchical path
 // to be associated with the address.
-std::unique_ptr<ServerAddress::AttributeInterface>
-MakeHierarchicalPathAttribute(std::vector<std::string> path);
+class HierarchicalPathArg : public RefCounted<HierarchicalPathArg> {
+ public:
+  explicit HierarchicalPathArg(std::vector<RefCountedStringValue> path)
+      : path_(std::move(path)) {}
+
+  // Channel arg traits methods.
+  static absl::string_view ChannelArgName();
+  static int ChannelArgsCompare(const HierarchicalPathArg* a,
+                                const HierarchicalPathArg* b);
+
+  const std::vector<RefCountedStringValue>& path() const { return path_; }
+
+ private:
+  std::vector<RefCountedStringValue> path_;
+};
 
 // A map from the next path element to the addresses that fall under
 // that path element.
-using HierarchicalAddressMap = std::map<std::string, ServerAddressList>;
+using HierarchicalAddressMap =
+    std::map<RefCountedStringValue, ServerAddressList,
+             RefCountedStringValueLessThan>;
 
 // Splits up the addresses into a separate list for each child.
 absl::StatusOr<HierarchicalAddressMap> MakeHierarchicalAddressMap(

data/src/core/ext/filters/client_channel/lb_policy/child_policy_handler.cc

@@ -25,7 +25,6 @@
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
 
-#include <grpc/event_engine/event_engine.h>
 #include <grpc/impl/connectivity_state.h>
 #include <grpc/support/log.h>
 
@@ -33,6 +32,7 @@
 #include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/iomgr/pollset_set.h"
+#include "src/core/lib/load_balancing/delegating_helper.h"
 #include "src/core/lib/load_balancing/lb_policy_registry.h"
 #include "src/core/lib/load_balancing/subchannel_interface.h"
 #include "src/core/lib/resolver/server_address.h"
@@ -45,78 +45,69 @@ namespace grpc_core {
 //
 
 class ChildPolicyHandler::Helper
-    : public LoadBalancingPolicy::ChannelControlHelper {
+    : public LoadBalancingPolicy::ParentOwningDelegatingChannelControlHelper<
+          ChildPolicyHandler> {
  public:
   explicit Helper(RefCountedPtr<ChildPolicyHandler> parent)
-      : parent_(std::move(parent)) {}
-
-  ~Helper() override { parent_.reset(DEBUG_LOCATION, "Helper"); }
+      : ParentOwningDelegatingChannelControlHelper(std::move(parent)) {}
 
   RefCountedPtr<SubchannelInterface> CreateSubchannel(
       ServerAddress address, const ChannelArgs& args) override {
-    if (parent_->shutting_down_) return nullptr;
+    if (parent()->shutting_down_) return nullptr;
     if (!CalledByCurrentChild() && !CalledByPendingChild()) return nullptr;
-    return parent_->channel_control_helper()->CreateSubchannel(
+    return parent()->channel_control_helper()->CreateSubchannel(
         std::move(address), args);
   }
 
   void UpdateState(grpc_connectivity_state state, const absl::Status& status,
                    RefCountedPtr<SubchannelPicker> picker) override {
-    if (parent_->shutting_down_) return;
+    if (parent()->shutting_down_) return;
     // If this request is from the pending child policy, ignore it until
     // it reports something other than CONNECTING, at which point we swap it
     // into place.
     if (CalledByPendingChild()) {
-      if (GRPC_TRACE_FLAG_ENABLED(*(parent_->tracer_))) {
+      if (GRPC_TRACE_FLAG_ENABLED(*(parent()->tracer_))) {
         gpr_log(GPR_INFO,
                 "[child_policy_handler %p] helper %p: pending child policy %p "
                 "reports state=%s (%s)",
-                parent_.get(), this, child_, ConnectivityStateName(state),
+                parent(), this, child_, ConnectivityStateName(state),
                 status.ToString().c_str());
       }
       if (state == GRPC_CHANNEL_CONNECTING) return;
       grpc_pollset_set_del_pollset_set(
-          parent_->child_policy_->interested_parties(),
-          parent_->interested_parties());
-      parent_->child_policy_ = std::move(parent_->pending_child_policy_);
+          parent()->child_policy_->interested_parties(),
+          parent()->interested_parties());
+      parent()->child_policy_ = std::move(parent()->pending_child_policy_);
     } else if (!CalledByCurrentChild()) {
       // This request is from an outdated child, so ignore it.
       return;
     }
-    parent_->channel_control_helper()->UpdateState(state, status,
-                                                   std::move(picker));
+    parent()->channel_control_helper()->UpdateState(state, status,
+                                                    std::move(picker));
   }
 
   void RequestReresolution() override {
-    if (parent_->shutting_down_) return;
+    if (parent()->shutting_down_) return;
     // Only forward re-resolution requests from the most recent child,
     // since that's the one that will be receiving any update we receive
     // from the resolver.
     const LoadBalancingPolicy* latest_child_policy =
-        parent_->pending_child_policy_ != nullptr
-            ? parent_->pending_child_policy_.get()
-            : parent_->child_policy_.get();
+        parent()->pending_child_policy_ != nullptr
+            ? parent()->pending_child_policy_.get()
+            : parent()->child_policy_.get();
     if (child_ != latest_child_policy) return;
-    if (GRPC_TRACE_FLAG_ENABLED(*(parent_->tracer_))) {
+    if (GRPC_TRACE_FLAG_ENABLED(*(parent()->tracer_))) {
       gpr_log(GPR_INFO, "[child_policy_handler %p] started name re-resolving",
-              parent_.get());
+              parent());
     }
-    parent_->channel_control_helper()->RequestReresolution();
-  }
-
-  absl::string_view GetAuthority() override {
-    return parent_->channel_control_helper()->GetAuthority();
-  }
-
-  grpc_event_engine::experimental::EventEngine* GetEventEngine() override {
-    return parent_->channel_control_helper()->GetEventEngine();
+    parent()->channel_control_helper()->RequestReresolution();
   }
 
   void AddTraceEvent(TraceSeverity severity,
                      absl::string_view message) override {
-    if (parent_->shutting_down_) return;
+    if (parent()->shutting_down_) return;
     if (!CalledByPendingChild() && !CalledByCurrentChild()) return;
-    parent_->channel_control_helper()->AddTraceEvent(severity, message);
+    parent()->channel_control_helper()->AddTraceEvent(severity, message);
   }
 
   void set_child(LoadBalancingPolicy* child) { child_ = child; }
@@ -124,15 +115,14 @@ class ChildPolicyHandler::Helper
  private:
   bool CalledByPendingChild() const {
     GPR_ASSERT(child_ != nullptr);
-    return child_ == parent_->pending_child_policy_.get();
+    return child_ == parent()->pending_child_policy_.get();
   }
 
   bool CalledByCurrentChild() const {
     GPR_ASSERT(child_ != nullptr);
-    return child_ == parent_->child_policy_.get();
+    return child_ == parent()->child_policy_.get();
   };
 
-  RefCountedPtr<ChildPolicyHandler> parent_;
   LoadBalancingPolicy* child_ = nullptr;
 };