grpc 1.55.0 → 1.56.0.pre3

data/src/core/ext/filters/client_channel/resolver/xds/xds_resolver.cc

@@ -16,11 +16,12 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include <algorithm>
-#include <cstdint>
+#include <functional>
 #include <initializer_list>
 #include <map>
 #include <memory>
@@ -29,7 +30,6 @@
 #include <utility>
 #include <vector>
 
-#include "absl/functional/any_invocable.h"
 #include "absl/meta/type_traits.h"
 #include "absl/random/random.h"
 #include "absl/status/status.h"
@@ -57,8 +57,10 @@
 #include <grpc/status.h>
 #include <grpc/support/log.h>
 
+#include "src/core/ext/filters/client_channel/client_channel_internal.h"
 #include "src/core/ext/filters/client_channel/config_selector.h"
 #include "src/core/ext/filters/client_channel/lb_policy/ring_hash/ring_hash.h"
+#include "src/core/ext/filters/client_channel/resolver/xds/xds_resolver.h"
 #include "src/core/ext/xds/xds_bootstrap.h"
 #include "src/core/ext/xds/xds_bootstrap_grpc.h"
 #include "src/core/ext/xds/xds_client_grpc.h"
@@ -68,6 +70,9 @@
 #include "src/core/ext/xds/xds_routing.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
+#include "src/core/lib/channel/channel_stack.h"
+#include "src/core/lib/channel/context.h"
+#include "src/core/lib/channel/promise_based_filter.h"
 #include "src/core/lib/channel/status_util.h"
 #include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/debug/trace.h"
@@ -75,11 +80,14 @@
 #include "src/core/lib/gprpp/dual_ref_counted.h"
 #include "src/core/lib/gprpp/match.h"
 #include "src/core/lib/gprpp/orphanable.h"
+#include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/gprpp/work_serializer.h"
 #include "src/core/lib/iomgr/iomgr_fwd.h"
 #include "src/core/lib/iomgr/pollset_set.h"
+#include "src/core/lib/promise/arena_promise.h"
+#include "src/core/lib/promise/context.h"
 #include "src/core/lib/resolver/resolver.h"
 #include "src/core/lib/resolver/resolver_factory.h"
 #include "src/core/lib/resolver/server_address.h"
@@ -87,13 +95,14 @@
 #include "src/core/lib/service_config/service_config.h"
 #include "src/core/lib/service_config/service_config_impl.h"
 #include "src/core/lib/transport/metadata_batch.h"
+#include "src/core/lib/transport/transport.h"
 #include "src/core/lib/uri/uri_parser.h"
 
 namespace grpc_core {
 
 TraceFlag grpc_xds_resolver_trace(false, "xds_resolver");
 
-UniqueTypeName XdsClusterAttributeTypeName() {
+UniqueTypeName XdsClusterAttribute::TypeName() {
   static UniqueTypeName::Factory kFactory("xds_cluster_name");
   return kFactory.Create();
 }
@@ -239,14 +248,9 @@ class XdsResolver : public Resolver {
   // back into the WorkSerializer to remove the entry from the map.
   class ClusterState : public DualRefCounted<ClusterState> {
    public:
-    using ClusterStateMap =
-        std::map<std::string, WeakRefCountedPtr<ClusterState>>;
-
     ClusterState(RefCountedPtr<XdsResolver> resolver,
-                 const std::string& cluster_name)
-        : resolver_(std::move(resolver)),
-          it_(resolver_->cluster_state_map_.emplace(cluster_name, WeakRef())
-                  .first) {}
+                 absl::string_view cluster_name)
+        : resolver_(std::move(resolver)), cluster_name_(cluster_name) {}
 
     void Orphan() override {
       auto* resolver = resolver_.get();
@@ -257,11 +261,37 @@ class XdsResolver : public Resolver {
           DEBUG_LOCATION);
     }
 
-    const std::string& cluster() const { return it_->first; }
+    const std::string& cluster_name() const { return cluster_name_; }
 
    private:
     RefCountedPtr<XdsResolver> resolver_;
-    ClusterStateMap::iterator it_;
+    std::string cluster_name_;
+  };
+
+  // A map containing cluster refs held by the XdsConfigSelector. A ref to
+  // this map will be taken by each call processed by the XdsConfigSelector,
+  // stored in a the call's call attributes, and later unreffed
+  // by the ClusterSelection filter.
+  class XdsClusterMap : public RefCounted<XdsClusterMap> {
+   public:
+    explicit XdsClusterMap(
+        std::map<absl::string_view, RefCountedPtr<ClusterState>> clusters)
+        : clusters_(std::move(clusters)) {}
+
+    bool operator==(const XdsClusterMap& other) const {
+      return clusters_ == other.clusters_;
+    }
+
+    RefCountedPtr<ClusterState> Find(absl::string_view name) const {
+      auto it = clusters_.find(name);
+      if (it == clusters_.end()) {
+        return nullptr;
+      }
+      return it->second;
+    }
+
+   private:
+    std::map<absl::string_view, RefCountedPtr<ClusterState>> clusters_;
   };
 
   class XdsConfigSelector : public ConfigSelector {
@@ -276,10 +306,10 @@ class XdsResolver : public Resolver {
       const auto* other_xds = static_cast<const XdsConfigSelector*>(other);
       // Don't need to compare resolver_, since that will always be the same.
       return route_table_ == other_xds->route_table_ &&
-             clusters_ == other_xds->clusters_;
+             *cluster_map_ == *other_xds->cluster_map_;
     }
 
-    absl::StatusOr<CallConfig> GetCallConfig(GetCallConfigArgs args) override;
+    absl::Status GetCallConfig(GetCallConfigArgs args) override;
 
     std::vector<const grpc_channel_filter*> GetFilters() override {
       return filters_;
@@ -305,7 +335,6 @@ class XdsResolver : public Resolver {
 
     class RouteListIterator;
 
-    void MaybeAddCluster(const std::string& name);
     absl::StatusOr<RefCountedPtr<ServiceConfig>> CreateMethodConfig(
         const XdsRouteConfigResource::Route& route,
         const XdsRouteConfigResource::Route::RouteAction::ClusterWeight*
@@ -313,10 +342,92 @@ class XdsResolver : public Resolver {
 
     RefCountedPtr<XdsResolver> resolver_;
     RouteTable route_table_;
-    std::map<absl::string_view, RefCountedPtr<ClusterState>> clusters_;
+    RefCountedPtr<XdsClusterMap> cluster_map_;
     std::vector<const grpc_channel_filter*> filters_;
   };
 
+  class ClusterSelectionFilter : public ChannelFilter {
+   public:
+    const static grpc_channel_filter kFilter;
+
+    static absl::StatusOr<ClusterSelectionFilter> Create(
+        const ChannelArgs& /* unused */, ChannelFilter::Args filter_args) {
+      return ClusterSelectionFilter(filter_args);
+    }
+
+    // Construct a promise for one call.
+    ArenaPromise<ServerMetadataHandle> MakeCallPromise(
+        CallArgs call_args, NextPromiseFactory next_promise_factory) override {
+      auto* service_config_call_data =
+          static_cast<ClientChannelServiceConfigCallData*>(
+              GetContext<grpc_call_context_element>()
+                  [GRPC_CONTEXT_SERVICE_CONFIG_CALL_DATA]
+                      .value);
+      GPR_ASSERT(service_config_call_data != nullptr);
+      auto* cluster_data = static_cast<XdsClusterMapAttribute*>(
+          service_config_call_data->GetCallAttribute(
+              XdsClusterMapAttribute::TypeName()));
+      auto* cluster_name_attribute = static_cast<XdsClusterAttribute*>(
+          service_config_call_data->GetCallAttribute(
+              XdsClusterAttribute::TypeName()));
+      if (cluster_data != nullptr && cluster_name_attribute != nullptr) {
+        auto cluster =
+            cluster_data->LockAndGetCluster(cluster_name_attribute->cluster());
+        if (cluster != nullptr) {
+          service_config_call_data->SetOnCommit(
+              [cluster = std::move(cluster)]() mutable { cluster.reset(); });
+        }
+      }
+      return next_promise_factory(std::move(call_args));
+    }
+
+   private:
+    explicit ClusterSelectionFilter(ChannelFilter::Args filter_args)
+        : filter_args_(filter_args) {}
+
+    ChannelFilter::Args filter_args_;
+  };
+
+  RefCountedPtr<ClusterState> GetOrCreateClusterState(
+      absl::string_view cluster_name) {
+    auto it = cluster_state_map_.find(cluster_name);
+    if (it == cluster_state_map_.end()) {
+      auto cluster = MakeRefCounted<ClusterState>(Ref(), cluster_name);
+      cluster_state_map_.emplace(cluster->cluster_name(), cluster->WeakRef());
+      return cluster;
+    }
+    return it->second->Ref();
+  }
+
+  class XdsClusterMapAttribute
+      : public ServiceConfigCallData::CallAttributeInterface {
+   public:
+    static UniqueTypeName TypeName() {
+      static UniqueTypeName::Factory factory("xds_cluster_lb_data");
+      return factory.Create();
+    }
+
+    explicit XdsClusterMapAttribute(RefCountedPtr<XdsClusterMap> cluster_map)
+        : cluster_map_(std::move(cluster_map)) {}
+
+    // This method can be called only once. The first call will release the
+    // reference to the cluster map, and subsequent calls will return nullptr.
+    RefCountedPtr<ClusterState> LockAndGetCluster(
+        absl::string_view cluster_name) {
+      if (cluster_map_ == nullptr) {
+        return nullptr;
+      }
+      auto cluster = cluster_map_->Find(cluster_name);
+      cluster_map_.reset();
+      return cluster;
+    }
+
+    UniqueTypeName type() const override { return TypeName(); }
+
+   private:
+    RefCountedPtr<XdsClusterMap> cluster_map_;
+  };
+
   void OnListenerUpdate(XdsListenerResource listener);
   void OnRouteConfigUpdate(XdsRouteConfigResource rds_update);
   void OnError(absl::string_view context, absl::Status status);
@@ -350,7 +461,8 @@ class XdsResolver : public Resolver {
            std::string /*LB policy config*/>
       cluster_specifier_plugin_map_;
 
-  ClusterState::ClusterStateMap cluster_state_map_;
+  std::map<absl::string_view, WeakRefCountedPtr<ClusterState>>
+      cluster_state_map_;
 };
 
 //
@@ -363,6 +475,11 @@ bool MethodConfigsEqual(const ServiceConfig* sc1, const ServiceConfig* sc2) {
   return sc1->json_string() == sc2->json_string();
 }
 
+const grpc_channel_filter XdsResolver::ClusterSelectionFilter::kFilter =
+    MakePromiseBasedFilter<ClusterSelectionFilter, FilterEndpoint::kClient,
+                           kFilterExaminesServerInitialMetadata>(
+        "cluster_selection_filter");
+
 bool XdsResolver::XdsConfigSelector::Route::ClusterWeightState::operator==(
     const ClusterWeightState& other) const {
   return range_end == other.range_end && cluster == other.cluster &&
@@ -416,6 +533,13 @@ XdsResolver::XdsConfigSelector::XdsConfigSelector(
   // moving the entry in a reallocation will cause the string_view to point to
   // invalid data.
   route_table_.reserve(resolver_->current_virtual_host_->routes.size());
+  std::map<absl::string_view, RefCountedPtr<ClusterState>> clusters;
+  auto maybe_add_cluster = [&](absl::string_view cluster_name) {
+    if (clusters.find(cluster_name) != clusters.end()) return;
+    auto cluster_state = resolver_->GetOrCreateClusterState(cluster_name);
+    absl::string_view name = cluster_state->cluster_name();
+    clusters.emplace(name, std::move(cluster_state));
+  };
   for (auto& route : resolver_->current_virtual_host_->routes) {
     if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_resolver_trace)) {
       gpr_log(GPR_INFO, "[xds_resolver %p] XdsConfigSelector %p: route: %s",
@@ -445,7 +569,7 @@ XdsResolver::XdsConfigSelector::XdsConfigSelector(
               return;
             }
             route_entry.method_config = std::move(*result);
-            MaybeAddCluster(
+            maybe_add_cluster(
                 absl::StrCat("cluster:", cluster_name.cluster_name));
           },
           // WeightedClusters
@@ -467,7 +591,8 @@ XdsResolver::XdsConfigSelector::XdsConfigSelector(
               cluster_weight_state.cluster = weighted_cluster.name;
               route_entry.weighted_cluster_state.push_back(
                   std::move(cluster_weight_state));
-              MaybeAddCluster(absl::StrCat("cluster:", weighted_cluster.name));
+              maybe_add_cluster(
+                  absl::StrCat("cluster:", weighted_cluster.name));
             }
           },
           // ClusterSpecifierPlugin
@@ -479,13 +604,14 @@ XdsResolver::XdsConfigSelector::XdsConfigSelector(
               return;
             }
             route_entry.method_config = std::move(*result);
-            MaybeAddCluster(absl::StrCat(
+            maybe_add_cluster(absl::StrCat(
                 "cluster_specifier_plugin:",
                 cluster_specifier_plugin_name.cluster_specifier_plugin_name));
           });
       if (!status->ok()) return;
     }
   }
+  cluster_map_ = MakeRefCounted<XdsClusterMap>(std::move(clusters));
   // Populate filter list.
   const auto& http_filter_registry =
       static_cast<const GrpcXdsBootstrap&>(resolver_->xds_client_->bootstrap())
@@ -502,6 +628,7 @@ XdsResolver::XdsConfigSelector::XdsConfigSelector(
       filters_.push_back(filter_impl->channel_filter());
     }
   }
+  filters_.push_back(&ClusterSelectionFilter::kFilter);
 }
 
 XdsResolver::XdsConfigSelector::~XdsConfigSelector() {
@@ -509,7 +636,7 @@ XdsResolver::XdsConfigSelector::~XdsConfigSelector() {
     gpr_log(GPR_INFO, "[xds_resolver %p] destroying XdsConfigSelector %p",
             resolver_.get(), this);
   }
-  clusters_.clear();
+  cluster_map_.reset();
   resolver_->MaybeRemoveUnusedClusters();
 }
 
@@ -595,18 +722,6 @@ XdsResolver::XdsConfigSelector::CreateMethodConfig(
   return nullptr;
 }
 
-void XdsResolver::XdsConfigSelector::MaybeAddCluster(const std::string& name) {
-  if (clusters_.find(name) == clusters_.end()) {
-    auto it = resolver_->cluster_state_map_.find(name);
-    if (it == resolver_->cluster_state_map_.end()) {
-      auto new_cluster_state = MakeRefCounted<ClusterState>(resolver_, name);
-      clusters_[new_cluster_state->cluster()] = std::move(new_cluster_state);
-    } else {
-      clusters_[it->second->cluster()] = it->second->Ref();
-    }
-  }
-}
-
 absl::optional<uint64_t> HeaderHashHelper(
     const XdsRouteConfigResource::Route::RouteAction::HashPolicy::Header&
         header_policy,
@@ -628,8 +743,8 @@ absl::optional<uint64_t> HeaderHashHelper(
   return XXH64(header_value->data(), header_value->size(), 0);
 }
 
-absl::StatusOr<ConfigSelector::CallConfig>
-XdsResolver::XdsConfigSelector::GetCallConfig(GetCallConfigArgs args) {
+absl::Status XdsResolver::XdsConfigSelector::GetCallConfig(
+    GetCallConfigArgs args) {
   Slice* path = args.initial_metadata->get_pointer(HttpPathMetadata());
   GPR_ASSERT(path != nullptr);
   auto route_index = XdsRouting::GetRouteForRequest(
@@ -694,8 +809,8 @@ XdsResolver::XdsConfigSelector::GetCallConfig(GetCallConfigArgs args) {
             cluster_specifier_plugin_name.cluster_specifier_plugin_name);
         method_config = entry.method_config;
       });
-  auto it = clusters_.find(cluster_name);
-  GPR_ASSERT(it != clusters_.end());
+  auto cluster = cluster_map_->Find(cluster_name);
+  GPR_ASSERT(cluster != nullptr);
   // Generate a hash.
   absl::optional<uint64_t> hash;
   for (const auto& hash_policy : route_action->hash_policies) {
@@ -725,23 +840,25 @@ XdsResolver::XdsConfigSelector::GetCallConfig(GetCallConfigArgs args) {
   if (!hash.has_value()) {
     hash = absl::Uniform<uint64_t>(absl::BitGen());
   }
-  CallConfig call_config;
+  // Populate service config call data.
   if (method_config != nullptr) {
-    call_config.method_configs =
+    auto* parsed_method_configs =
         method_config->GetMethodParsedConfigVector(grpc_empty_slice());
-    call_config.service_config = std::move(method_config);
+    args.service_config_call_data->SetServiceConfig(std::move(method_config),
+                                                    parsed_method_configs);
   }
-  call_config.call_attributes[XdsClusterAttributeTypeName()] = it->first;
+  args.service_config_call_data->SetCallAttribute(
+      args.arena->New<XdsClusterAttribute>(cluster->cluster_name()));
   std::string hash_string = absl::StrCat(hash.value());
   char* hash_value =
       static_cast<char*>(args.arena->Alloc(hash_string.size() + 1));
   memcpy(hash_value, hash_string.c_str(), hash_string.size());
   hash_value[hash_string.size()] = '\0';
-  call_config.call_attributes[RequestHashAttributeName()] = hash_value;
-  call_config.on_commit = [cluster_state = it->second->Ref()]() mutable {
-    cluster_state.reset();
-  };
-  return std::move(call_config);
+  args.service_config_call_data->SetCallAttribute(
+      args.arena->New<RequestHashAttribute>(hash_value));
+  args.service_config_call_data->SetCallAttribute(
+      args.arena->ManagedNew<XdsClusterMapAttribute>(cluster_map_));
+  return absl::OkStatus();
 }
 
 //

data/src/core/ext/filters/client_channel/resolver/xds/xds_resolver.h

@@ -19,12 +19,27 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "absl/strings/string_view.h"
+
 #include "src/core/lib/gprpp/unique_type_name.h"
+#include "src/core/lib/service_config/service_config_call_data.h"
 
 namespace grpc_core {
 
-UniqueTypeName XdsClusterAttributeTypeName();
+class XdsClusterAttribute
+    : public ServiceConfigCallData::CallAttributeInterface {
+ public:
+  static UniqueTypeName TypeName();
+
+  explicit XdsClusterAttribute(absl::string_view cluster) : cluster_(cluster) {}
+
+  absl::string_view cluster() const { return cluster_; }
+
+ private:
+  UniqueTypeName type() const override { return TypeName(); }
 
+  absl::string_view cluster_;
+};
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_XDS_XDS_RESOLVER_H

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

@@ -29,6 +29,7 @@
 
 #include <grpc/grpc.h>
 #include <grpc/status.h>
+#include <grpc/support/json.h>
 #include <grpc/support/log.h>
 
 #include "src/core/lib/channel/channel_args.h"

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

@@ -34,11 +34,11 @@
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/channel/channel_stack_builder.h"
-#include "src/core/lib/channel/context.h"
 #include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/service_config/service_config.h"
 #include "src/core/lib/service_config/service_config_call_data.h"
 #include "src/core/lib/service_config/service_config_impl.h"
@@ -75,55 +75,25 @@ class ServiceConfigChannelArgChannelData {
   RefCountedPtr<ServiceConfig> service_config_;
 };
 
-class ServiceConfigChannelArgCallData {
- public:
-  ServiceConfigChannelArgCallData(
-      RefCountedPtr<ServiceConfig> service_config,
-      const ServiceConfigParser::ParsedConfigVector* method_config,
-      const grpc_call_element_args* args)
-      : call_context_(args->context),
-        service_config_call_data_(std::move(service_config), method_config,
-                                  /*call_attributes=*/{}) {
-    GPR_DEBUG_ASSERT(args->context != nullptr);
-    // No need to set the destroy function, since it will be cleaned up
-    // when this filter is destroyed in the filter stack.
-    args->context[GRPC_CONTEXT_SERVICE_CONFIG_CALL_DATA].value =
-        &service_config_call_data_;
-  }
-
-  ~ServiceConfigChannelArgCallData() {
-    // Remove the entry from call context, just in case anyone above us
-    // tries to look at it during call stack destruction.
-    call_context_[GRPC_CONTEXT_SERVICE_CONFIG_CALL_DATA].value = nullptr;
-  }
-
- private:
-  grpc_call_context_element* call_context_;
-  ServiceConfigCallData service_config_call_data_;
-};
-
 grpc_error_handle ServiceConfigChannelArgInitCallElem(
     grpc_call_element* elem, const grpc_call_element_args* args) {
   auto* chand =
       static_cast<ServiceConfigChannelArgChannelData*>(elem->channel_data);
-  auto* calld = static_cast<ServiceConfigChannelArgCallData*>(elem->call_data);
   RefCountedPtr<ServiceConfig> service_config = chand->service_config();
-  const ServiceConfigParser::ParsedConfigVector* method_config = nullptr;
+  const ServiceConfigParser::ParsedConfigVector* method_configs = nullptr;
   if (service_config != nullptr) {
-    method_config = service_config->GetMethodParsedConfigVector(args->path);
+    method_configs = service_config->GetMethodParsedConfigVector(args->path);
   }
-  new (calld) ServiceConfigChannelArgCallData(std::move(service_config),
-                                              method_config, args);
+  auto* service_config_call_data =
+      args->arena->New<ServiceConfigCallData>(args->arena, args->context);
+  service_config_call_data->SetServiceConfig(std::move(service_config),
+                                             method_configs);
   return absl::OkStatus();
 }
 
 void ServiceConfigChannelArgDestroyCallElem(
-    grpc_call_element* elem, const grpc_call_final_info* /* final_info */,
-    grpc_closure* /* then_schedule_closure */) {
-  ServiceConfigChannelArgCallData* calld =
-      static_cast<ServiceConfigChannelArgCallData*>(elem->call_data);
-  calld->~ServiceConfigChannelArgCallData();
-}
+    grpc_call_element* /*elem*/, const grpc_call_final_info* /*final_info*/,
+    grpc_closure* /*then_schedule_closure*/) {}
 
 grpc_error_handle ServiceConfigChannelArgInitChannelElem(
     grpc_channel_element* elem, grpc_channel_element_args* args) {
@@ -143,7 +113,7 @@ const grpc_channel_filter ServiceConfigChannelArgFilter = {
     grpc_call_next_op,
     nullptr,
     grpc_channel_next_op,
-    sizeof(ServiceConfigChannelArgCallData),
+    0,
     ServiceConfigChannelArgInitCallElem,
     grpc_call_stack_ignore_set_pollset_or_pollset_set,
     ServiceConfigChannelArgDestroyCallElem,