grpc 1.54.2 → 1.56.0.pre3

data/src/core/ext/filters/client_channel/resolver/dns/event_engine/service_config_helper.h

@@ -0,0 +1,32 @@
+// Copyright 2023 The gRPC Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_DNS_EVENT_ENGINE_SERVICE_CONFIG_HELPER_H
+#define GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_DNS_EVENT_ENGINE_SERVICE_CONFIG_HELPER_H
+
+#include <grpc/support/port_platform.h>
+
+#include <string>
+
+#include "absl/status/statusor.h"
+#include "absl/strings/string_view.h"
+
+namespace grpc_core {
+
+absl::StatusOr<std::string> ChooseServiceConfig(
+    absl::string_view service_config_json);
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_DNS_EVENT_ENGINE_SERVICE_CONFIG_HELPER_H

data/src/core/ext/filters/client_channel/resolver/dns/native/dns_resolver.cc

@@ -25,7 +25,6 @@
 #include "absl/functional/bind_front.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
-#include "absl/strings/match.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
 #include "absl/strings/strip.h"
@@ -37,7 +36,6 @@
 #include "src/core/ext/filters/client_channel/resolver/polling_resolver.h"
 #include "src/core/lib/backoff/backoff.h"
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/config/config_vars.h"
 #include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/debug_location.h"
@@ -179,17 +177,8 @@ class NativeClientChannelDNSResolverFactory : public ResolverFactory {
 }  // namespace
 
 void RegisterNativeDnsResolver(CoreConfiguration::Builder* builder) {
-  if (absl::EqualsIgnoreCase(ConfigVars::Get().DnsResolver(), "native")) {
-    gpr_log(GPR_DEBUG, "Using native dns resolver");
-    builder->resolver_registry()->RegisterResolverFactory(
-        std::make_unique<NativeClientChannelDNSResolverFactory>());
-  } else {
-    if (!builder->resolver_registry()->HasResolverFactory("dns")) {
-      gpr_log(GPR_DEBUG, "Using native dns resolver");
-      builder->resolver_registry()->RegisterResolverFactory(
-          std::make_unique<NativeClientChannelDNSResolverFactory>());
-    }
-  }
+  builder->resolver_registry()->RegisterResolverFactory(
+      std::make_unique<NativeClientChannelDNSResolverFactory>());
 }
 
 }  // namespace grpc_core

data/src/core/ext/filters/client_channel/resolver/dns/native/dns_resolver.h

@@ -0,0 +1,24 @@
+// Copyright 2022 The gRPC Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#ifndef GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_DNS_NATIVE_DNS_RESOLVER_H
+#define GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_DNS_NATIVE_DNS_RESOLVER_H
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/config/core_configuration.h"
+
+namespace grpc_core {
+void RegisterNativeDnsResolver(CoreConfiguration::Builder* builder);
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_DNS_NATIVE_DNS_RESOLVER_H

data/src/core/ext/filters/client_channel/resolver/google_c2p/google_c2p_resolver.cc

@@ -29,6 +29,7 @@
 #include "absl/strings/strip.h"
 #include "absl/types/optional.h"
 
+#include <grpc/support/json.h>
 #include <grpc/support/log.h>
 
 #include "src/core/ext/gcp/metadata_query.h"
@@ -44,6 +45,7 @@
 #include "src/core/lib/gprpp/work_serializer.h"
 #include "src/core/lib/iomgr/polling_entity.h"
 #include "src/core/lib/json/json.h"
+#include "src/core/lib/json/json_writer.h"
 #include "src/core/lib/resolver/resolver.h"
 #include "src/core/lib/resolver/resolver_factory.h"
 #include "src/core/lib/resolver/resolver_registry.h"
@@ -218,17 +220,17 @@ void GoogleCloud2ProdResolver::StartXdsResolver() {
   std::mt19937 mt(rd());
   std::uniform_int_distribution<uint64_t> dist(1, UINT64_MAX);
   Json::Object node = {
-      {"id", absl::StrCat("C2P-", dist(mt))},
+      {"id", Json::FromString(absl::StrCat("C2P-", dist(mt)))},
   };
   if (!zone_->empty()) {
-    node["locality"] = Json::Object{
-        {"zone", *zone_},
-    };
+    node["locality"] = Json::FromObject({
+        {"zone", Json::FromString(*zone_)},
+    });
   };
   if (*supports_ipv6_) {
-    node["metadata"] = Json::Object{
-        {"TRAFFICDIRECTOR_DIRECTPATH_C2P_IPV6_CAPABLE", true},
-    };
+    node["metadata"] = Json::FromObject({
+        {"TRAFFICDIRECTOR_DIRECTPATH_C2P_IPV6_CAPABLE", Json::FromBool(true)},
+    });
   }
   // Allow the TD server uri to be overridden for testing purposes.
   auto override_server =
@@ -237,31 +239,31 @@ void GoogleCloud2ProdResolver::StartXdsResolver() {
       override_server.has_value() && !override_server->empty()
           ? override_server->c_str()
           : "directpath-pa.googleapis.com";
-  Json xds_server = Json::Array{
-      Json::Object{
-          {"server_uri", server_uri},
+  Json xds_server = Json::FromArray({
+      Json::FromObject({
+          {"server_uri", Json::FromString(server_uri)},
           {"channel_creds",
-           Json::Array{
-               Json::Object{
-                   {"type", "google_default"},
-               },
-           }},
-          {"server_features", Json::Array{"xds_v3"}},
-      },
-  };
-  Json bootstrap = Json::Object{
+           Json::FromArray({
+               Json::FromObject({
+                   {"type", Json::FromString("google_default")},
+               }),
+           })},
+          {"server_features",
+           Json::FromArray({Json::FromString("ignore_resource_deletion")})},
+      }),
+  });
+  Json bootstrap = Json::FromObject({
       {"xds_servers", xds_server},
       {"authorities",
-       Json::Object{
-           {kC2PAuthority,
-            Json::Object{
-                {"xds_servers", std::move(xds_server)},
-            }},
-       }},
-      {"node", std::move(node)},
-  };
+       Json::FromObject({
+           {kC2PAuthority, Json::FromObject({
+                               {"xds_servers", std::move(xds_server)},
+                           })},
+       })},
+      {"node", Json::FromObject(std::move(node))},
+  });
   // Inject bootstrap JSON as fallback config.
-  internal::SetXdsFallbackBootstrapConfig(bootstrap.Dump().c_str());
+  internal::SetXdsFallbackBootstrapConfig(JsonDump(bootstrap).c_str());
   // Now start xDS resolver.
   child_resolver_->StartLocked();
 }

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>
@@ -56,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"
@@ -67,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"
@@ -74,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"
@@ -86,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();
 }
@@ -238,58 +248,50 @@ 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_.release();
+      auto* resolver = resolver_.get();
       resolver->work_serializer_->Run(
-          [resolver]() {
+          [resolver = std::move(resolver_)]() {
             resolver->MaybeRemoveUnusedClusters();
-            resolver->Unref();
           },
           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_;
   };
 
-  // Call dispatch controller, created for each call handled by the
-  // ConfigSelector.  Holds a ref to the ClusterState object until the
-  // call is committed.
-  class XdsCallDispatchController
-      : public ConfigSelector::CallDispatchController {
+  // 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 XdsCallDispatchController(
-        RefCountedPtr<ClusterState> cluster_state)
-        : cluster_state_(std::move(cluster_state)) {}
+    explicit XdsClusterMap(
+        std::map<absl::string_view, RefCountedPtr<ClusterState>> clusters)
+        : clusters_(std::move(clusters)) {}
 
-    bool ShouldRetry() override {
-      // TODO(donnadionne): Implement the retry circuit breaker here.
-      return true;
+    bool operator==(const XdsClusterMap& other) const {
+      return clusters_ == other.clusters_;
     }
 
-    void Commit() override {
-      // TODO(donnadionne): If ShouldRetry() was called previously,
-      // decrement the retry circuit breaker counter.
-      cluster_state_.reset();
+    RefCountedPtr<ClusterState> Find(absl::string_view name) const {
+      auto it = clusters_.find(name);
+      if (it == clusters_.end()) {
+        return nullptr;
+      }
+      return it->second;
     }
 
    private:
-    // Note: The XdsCallDispatchController object is never actually destroyed,
-    // so do not add any data members that require destruction unless you have
-    // some other way to clean them up.
-    RefCountedPtr<ClusterState> cluster_state_;
+    std::map<absl::string_view, RefCountedPtr<ClusterState>> clusters_;
   };
 
   class XdsConfigSelector : public ConfigSelector {
@@ -304,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_;
@@ -333,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*
@@ -341,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);
@@ -378,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_;
 };
 
 //
@@ -391,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 &&
@@ -444,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",
@@ -473,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
@@ -495,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
@@ -507,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())
@@ -530,6 +628,7 @@ XdsResolver::XdsConfigSelector::XdsConfigSelector(
       filters_.push_back(filter_impl->channel_filter());
     }
   }
+  filters_.push_back(&ClusterSelectionFilter::kFilter);
 }
 
 XdsResolver::XdsConfigSelector::~XdsConfigSelector() {
@@ -537,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();
 }
 
@@ -623,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,
@@ -656,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(
@@ -722,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) {
@@ -753,22 +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.call_dispatch_controller =
-      args.arena->New<XdsCallDispatchController>(it->second->Ref());
-  return 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