grpc 1.83.1 → 1.84.0

data/src/core/resolver/dns/{event_engine/event_engine_client_channel_resolver.cc → dns_resolver.cc}

@@ -11,7 +11,7 @@
 // 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.
-#include "src/core/resolver/dns/event_engine/event_engine_client_channel_resolver.h"
+#include "src/core/resolver/dns/dns_resolver.h"
 
 #include <grpc/event_engine/event_engine.h>
 #include <grpc/impl/channel_arg_names.h>
@@ -27,13 +27,13 @@
 #include <utility>
 #include <vector>
 
+#include "src/core/config/core_configuration.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/event_engine/resolved_address_internal.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
-#include "src/core/lib/iomgr/resolve_address.h"
 #include "src/core/load_balancing/grpclb/grpclb_balancer_addresses.h"
-#include "src/core/resolver/dns/event_engine/service_config_helper.h"
+#include "src/core/resolver/dns/service_config_helper.h"
 #include "src/core/resolver/endpoint_addresses.h"
 #include "src/core/resolver/polling_resolver.h"
 #include "src/core/resolver/resolver.h"
@@ -61,6 +61,8 @@
 namespace grpc_core {
 namespace {
 
+const char* kDefaultSecurePort = "https";
+
 #define GRPC_DNS_INITIAL_CONNECT_BACKOFF_SECONDS 1
 #define GRPC_DNS_RECONNECT_BACKOFF_MULTIPLIER 1.6
 #define GRPC_DNS_RECONNECT_MAX_BACKOFF_SECONDS 120
@@ -76,12 +78,12 @@ using grpc_event_engine::experimental::EventEngine;
 // addresses.
 
 // ----------------------------------------------------------------------------
-// EventEngineClientChannelDNSResolver
+// ClientChannelDNSResolver
 // ----------------------------------------------------------------------------
-class EventEngineClientChannelDNSResolver final : public PollingResolver {
+class ClientChannelDNSResolver final : public PollingResolver {
  public:
-  EventEngineClientChannelDNSResolver(ResolverArgs args,
-                                      Duration min_time_between_resolutions);
+  ClientChannelDNSResolver(ResolverArgs args,
+                           Duration min_time_between_resolutions);
   OrphanablePtr<Orphanable> StartRequest() override;
 
  private:
@@ -92,7 +94,7 @@ class EventEngineClientChannelDNSResolver final : public PollingResolver {
       : public InternallyRefCounted<EventEngineDNSRequestWrapper> {
    public:
     EventEngineDNSRequestWrapper(
-        RefCountedPtr<EventEngineClientChannelDNSResolver> resolver,
+        RefCountedPtr<ClientChannelDNSResolver> resolver,
         std::unique_ptr<EventEngine::DNSResolver> event_engine_resolver);
     ~EventEngineDNSRequestWrapper() override;
 
@@ -128,7 +130,7 @@ class EventEngineClientChannelDNSResolver final : public PollingResolver {
     void MaybePopulateServiceConfigLocked(Resolver::Result* result)
         ABSL_EXCLUSIVE_LOCKS_REQUIRED(on_resolved_mu_);
 
-    RefCountedPtr<EventEngineClientChannelDNSResolver> resolver_;
+    RefCountedPtr<ClientChannelDNSResolver> resolver_;
     Mutex on_resolved_mu_;
     // Lookup callbacks
     bool is_hostname_inflight_ ABSL_GUARDED_BY(on_resolved_mu_) = false;
@@ -160,7 +162,7 @@ class EventEngineClientChannelDNSResolver final : public PollingResolver {
   std::shared_ptr<EventEngine> event_engine_;
 };
 
-EventEngineClientChannelDNSResolver::EventEngineClientChannelDNSResolver(
+ClientChannelDNSResolver::ClientChannelDNSResolver(
     ResolverArgs args, Duration min_time_between_resolutions)
     : PollingResolver(std::move(args), min_time_between_resolutions,
                       BackOff::Options()
@@ -185,7 +187,7 @@ EventEngineClientChannelDNSResolver::EventEngineClientChannelDNSResolver(
                           .value_or(GRPC_DNS_DEFAULT_QUERY_TIMEOUT_MS)))),
       event_engine_(channel_args().GetObjectRef<EventEngine>()) {}
 
-OrphanablePtr<Orphanable> EventEngineClientChannelDNSResolver::StartRequest() {
+OrphanablePtr<Orphanable> ClientChannelDNSResolver::StartRequest() {
   auto dns_resolver =
       event_engine_->GetDNSResolver({/*dns_server=*/authority()});
   if (!dns_resolver.ok()) {
@@ -196,8 +198,7 @@ OrphanablePtr<Orphanable> EventEngineClientChannelDNSResolver::StartRequest() {
     return nullptr;
   }
   return MakeOrphanable<EventEngineDNSRequestWrapper>(
-      RefAsSubclass<EventEngineClientChannelDNSResolver>(DEBUG_LOCATION,
-                                                         "dns-resolving"),
+      RefAsSubclass<ClientChannelDNSResolver>(DEBUG_LOCATION, "dns-resolving"),
       std::move(*dns_resolver));
 }
 
@@ -205,9 +206,9 @@ OrphanablePtr<Orphanable> EventEngineClientChannelDNSResolver::StartRequest() {
 // EventEngineDNSRequestWrapper definition
 // ----------------------------------------------------------------------------
 
-EventEngineClientChannelDNSResolver::EventEngineDNSRequestWrapper::
+ClientChannelDNSResolver::EventEngineDNSRequestWrapper::
     EventEngineDNSRequestWrapper(
-        RefCountedPtr<EventEngineClientChannelDNSResolver> resolver,
+        RefCountedPtr<ClientChannelDNSResolver> resolver,
         std::unique_ptr<EventEngine::DNSResolver> event_engine_resolver)
     : resolver_(std::move(resolver)),
       event_engine_resolver_(std::move(event_engine_resolver)) {
@@ -270,13 +271,12 @@ EventEngineClientChannelDNSResolver::EventEngineDNSRequestWrapper::
       });
 }
 
-EventEngineClientChannelDNSResolver::EventEngineDNSRequestWrapper::
+ClientChannelDNSResolver::EventEngineDNSRequestWrapper::
     ~EventEngineDNSRequestWrapper() {
   resolver_.reset(DEBUG_LOCATION, "dns-resolving");
 }
 
-void EventEngineClientChannelDNSResolver::EventEngineDNSRequestWrapper::
-    Orphan() {
+void ClientChannelDNSResolver::EventEngineDNSRequestWrapper::Orphan() {
   {
     MutexLock lock(&on_resolved_mu_);
     orphaned_ = true;
@@ -291,8 +291,7 @@ void EventEngineClientChannelDNSResolver::EventEngineDNSRequestWrapper::
   Unref(DEBUG_LOCATION, "Orphan");
 }
 
-void EventEngineClientChannelDNSResolver::EventEngineDNSRequestWrapper::
-    OnTimeout() {
+void ClientChannelDNSResolver::EventEngineDNSRequestWrapper::OnTimeout() {
   MutexLock lock(&on_resolved_mu_);
   GRPC_TRACE_VLOG(event_engine_client_channel_resolver, 2)
       << "(event_engine client channel resolver) DNSResolver::"
@@ -301,9 +300,8 @@ void EventEngineClientChannelDNSResolver::EventEngineDNSRequestWrapper::
   event_engine_resolver_.reset();
 }
 
-void EventEngineClientChannelDNSResolver::EventEngineDNSRequestWrapper::
-    OnHostnameResolved(absl::StatusOr<std::vector<EventEngine::ResolvedAddress>>
-                           new_addresses) {
+void ClientChannelDNSResolver::EventEngineDNSRequestWrapper::OnHostnameResolved(
+    absl::StatusOr<std::vector<EventEngine::ResolvedAddress>> new_addresses) {
   std::optional<Resolver::Result> result;
   {
     MutexLock lock(&on_resolved_mu_);
@@ -326,10 +324,9 @@ void EventEngineClientChannelDNSResolver::EventEngineDNSRequestWrapper::
   }
 }
 
-void EventEngineClientChannelDNSResolver::EventEngineDNSRequestWrapper::
-    OnSRVResolved(
-        absl::StatusOr<std::vector<EventEngine::DNSResolver::SRVRecord>>
-            srv_records) {
+void ClientChannelDNSResolver::EventEngineDNSRequestWrapper::OnSRVResolved(
+    absl::StatusOr<std::vector<EventEngine::DNSResolver::SRVRecord>>
+        srv_records) {
   std::optional<Resolver::Result> result;
   auto cleanup = absl::MakeCleanup([&]() {
     if (result.has_value()) {
@@ -379,7 +376,7 @@ void EventEngineClientChannelDNSResolver::EventEngineDNSRequestWrapper::
   }
 }
 
-void EventEngineClientChannelDNSResolver::EventEngineDNSRequestWrapper::
+void ClientChannelDNSResolver::EventEngineDNSRequestWrapper::
     OnBalancerHostnamesResolved(
         std::string authority,
         absl::StatusOr<std::vector<EventEngine::ResolvedAddress>>
@@ -413,8 +410,8 @@ void EventEngineClientChannelDNSResolver::EventEngineDNSRequestWrapper::
   result = OnResolvedLocked();
 }
 
-void EventEngineClientChannelDNSResolver::EventEngineDNSRequestWrapper::
-    OnTXTResolved(absl::StatusOr<std::vector<std::string>> service_config) {
+void ClientChannelDNSResolver::EventEngineDNSRequestWrapper::OnTXTResolved(
+    absl::StatusOr<std::vector<std::string>> service_config) {
   std::optional<Resolver::Result> result;
   {
     MutexLock lock(&on_resolved_mu_);
@@ -456,13 +453,13 @@ void EventEngineClientChannelDNSResolver::EventEngineDNSRequestWrapper::
   }
 }
 
-void EventEngineClientChannelDNSResolver::EventEngineDNSRequestWrapper::
+void ClientChannelDNSResolver::EventEngineDNSRequestWrapper::
     MaybePopulateAddressesLocked(Resolver::Result* result) {
   if (addresses_.empty()) return;
   result->addresses = std::move(addresses_);
 }
 
-void EventEngineClientChannelDNSResolver::EventEngineDNSRequestWrapper::
+void ClientChannelDNSResolver::EventEngineDNSRequestWrapper::
     MaybePopulateBalancerAddressesLocked(Resolver::Result* result) {
   if (!balancer_addresses_.empty()) {
     result->args =
@@ -470,7 +467,7 @@ void EventEngineClientChannelDNSResolver::EventEngineDNSRequestWrapper::
   }
 }
 
-void EventEngineClientChannelDNSResolver::EventEngineDNSRequestWrapper::
+void ClientChannelDNSResolver::EventEngineDNSRequestWrapper::
     MaybePopulateServiceConfigLocked(Resolver::Result* result) {
   // This function is called only if we are returning addresses.  In that case,
   // we currently ignore TXT lookup failures.
@@ -498,8 +495,8 @@ void EventEngineClientChannelDNSResolver::EventEngineDNSRequestWrapper::
   }
 }
 
-std::optional<Resolver::Result> EventEngineClientChannelDNSResolver::
-    EventEngineDNSRequestWrapper::OnResolvedLocked() {
+std::optional<Resolver::Result>
+ClientChannelDNSResolver::EventEngineDNSRequestWrapper::OnResolvedLocked() {
   if (orphaned_) return std::nullopt;
   // Wait for all requested queries to return.
   if (is_hostname_inflight_ || is_srv_inflight_ || is_txt_inflight_ ||
@@ -552,8 +549,7 @@ std::optional<Resolver::Result> EventEngineClientChannelDNSResolver::
 
 }  // namespace
 
-bool EventEngineClientChannelDNSResolverFactory::IsValidUri(
-    const URI& uri) const {
+bool ClientChannelDNSResolverFactory::IsValidUri(const URI& uri) const {
   if (absl::StripPrefix(uri.path(), "/").empty()) {
     LOG(ERROR) << "no server name supplied in dns URI";
     return false;
@@ -561,16 +557,21 @@ bool EventEngineClientChannelDNSResolverFactory::IsValidUri(
   return true;
 }
 
-OrphanablePtr<Resolver>
-EventEngineClientChannelDNSResolverFactory::CreateResolver(
+OrphanablePtr<Resolver> ClientChannelDNSResolverFactory::CreateResolver(
     ResolverArgs args) const {
   Duration min_time_between_resolutions = std::max(
       Duration::Zero(), args.args
                             .GetDurationFromIntMillis(
                                 GRPC_ARG_DNS_MIN_TIME_BETWEEN_RESOLUTIONS_MS)
                             .value_or(Duration::Seconds(30)));
-  return MakeOrphanable<EventEngineClientChannelDNSResolver>(
-      std::move(args), min_time_between_resolutions);
+  return MakeOrphanable<ClientChannelDNSResolver>(std::move(args),
+                                                  min_time_between_resolutions);
+}
+
+void RegisterDnsResolver(CoreConfiguration::Builder* builder) {
+  VLOG(2) << "Using EventEngine dns resolver";
+  builder->resolver_registry()->RegisterResolverFactory(
+      std::make_unique<ClientChannelDNSResolverFactory>());
 }
 
 }  // namespace grpc_core

data/src/core/resolver/dns/{event_engine/event_engine_client_channel_resolver.h → dns_resolver.h}

@@ -11,10 +11,11 @@
 // 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_RESOLVER_DNS_EVENT_ENGINE_EVENT_ENGINE_CLIENT_CHANNEL_RESOLVER_H
-#define GRPC_SRC_CORE_RESOLVER_DNS_EVENT_ENGINE_EVENT_ENGINE_CLIENT_CHANNEL_RESOLVER_H
+#ifndef GRPC_SRC_CORE_RESOLVER_DNS_DNS_RESOLVER_H
+#define GRPC_SRC_CORE_RESOLVER_DNS_DNS_RESOLVER_H
 #include <grpc/support/port_platform.h>
 
+#include "src/core/config/core_configuration.h"
 #include "src/core/resolver/resolver.h"
 #include "src/core/resolver/resolver_factory.h"
 #include "src/core/util/orphanable.h"
@@ -23,14 +24,16 @@
 
 namespace grpc_core {
 
-class EventEngineClientChannelDNSResolverFactory final
-    : public ResolverFactory {
+class ClientChannelDNSResolverFactory final : public ResolverFactory {
  public:
   absl::string_view scheme() const override { return "dns"; }
   bool IsValidUri(const URI& uri) const override;
   OrphanablePtr<Resolver> CreateResolver(ResolverArgs args) const override;
 };
 
+// Centralized decision logic about which client channel DNS resolver to enable.
+void RegisterDnsResolver(CoreConfiguration::Builder* builder);
+
 }  // namespace grpc_core
 
-#endif  // GRPC_SRC_CORE_RESOLVER_DNS_EVENT_ENGINE_EVENT_ENGINE_CLIENT_CHANNEL_RESOLVER_H
+#endif  // GRPC_SRC_CORE_RESOLVER_DNS_DNS_RESOLVER_H

data/src/core/resolver/dns/{event_engine/service_config_helper.cc → service_config_helper.cc}

@@ -11,7 +11,7 @@
 // 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.
-#include "src/core/resolver/dns/event_engine/service_config_helper.h"
+#include "src/core/resolver/dns/service_config_helper.h"
 
 #include <grpc/support/port_platform.h>
 #include <stdlib.h>

data/src/core/resolver/dns/{event_engine/service_config_helper.h → service_config_helper.h}

@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef GRPC_SRC_CORE_RESOLVER_DNS_EVENT_ENGINE_SERVICE_CONFIG_HELPER_H
-#define GRPC_SRC_CORE_RESOLVER_DNS_EVENT_ENGINE_SERVICE_CONFIG_HELPER_H
+#ifndef GRPC_SRC_CORE_RESOLVER_DNS_SERVICE_CONFIG_HELPER_H
+#define GRPC_SRC_CORE_RESOLVER_DNS_SERVICE_CONFIG_HELPER_H
 
 #include <grpc/support/port_platform.h>
 
@@ -29,4 +29,4 @@ absl::StatusOr<std::string> ChooseServiceConfig(
 
 }  // namespace grpc_core
 
-#endif  // GRPC_SRC_CORE_RESOLVER_DNS_EVENT_ENGINE_SERVICE_CONFIG_HELPER_H
+#endif  // GRPC_SRC_CORE_RESOLVER_DNS_SERVICE_CONFIG_HELPER_H

data/src/core/resolver/endpoint_addresses.h

@@ -45,6 +45,9 @@
 // Backend service name associated with the addresses.
 #define GRPC_ARG_BACKEND_SERVICE "grpc.internal.backend_service"
 
+// Locality name associated with the addresses.
+#define GRPC_ARG_LB_LOCALITY "grpc.internal.lb_locality"
+
 namespace grpc_core {
 
 // A list of addresses for a given endpoint with an associated set of channel

data/src/core/resolver/google_c2p/google_c2p_resolver.cc

@@ -44,6 +44,7 @@
 #include "src/core/util/time.h"
 #include "src/core/util/uri.h"
 #include "src/core/util/work_serializer.h"
+#include "src/core/xds/grpc/xds_bootstrap_grpc_builder.h"
 #include "src/core/xds/grpc/xds_client_grpc.h"
 #include "src/core/xds/xds_client/xds_bootstrap.h"
 #include "absl/log/log.h"
@@ -237,7 +238,7 @@ std::shared_ptr<GrpcXdsBootstrap> GoogleCloud2ProdResolver::ConstructBootstrap()
        })},
       {"node", Json::FromObject(std::move(node))},
   });
-  return GrpcXdsBootstrap::Create(JsonDump(bootstrap)).value();
+  return GrpcXdsBootstrapBuilder::Build(JsonDump(bootstrap)).value();
 }
 
 void GoogleCloud2ProdResolver::StartXdsResolver() {

data/src/core/resolver/xds/xds_resolver.cc

@@ -79,6 +79,7 @@
 #include "src/core/xds/grpc/xds_route_config.h"
 #include "src/core/xds/grpc/xds_routing.h"
 #include "src/core/xds/xds_client/xds_bootstrap.h"
+#include "src/core/xds/xds_client/xds_transport.h"
 #include "absl/log/log.h"
 #include "absl/meta/type_traits.h"
 #include "absl/random/random.h"
@@ -219,7 +220,9 @@ class XdsResolver final : public Resolver {
 
     void BuildFilterChains(const XdsConfig& xds_config,
                            const XdsHttpFilterRegistry& http_filter_registry,
-                           FilterChainBuilder& builder, Blackboard& blackboard);
+                           FilterChainBuilder& builder,
+                           XdsTransportFactory& transport_factory,
+                           Blackboard& blackboard);
 
    private:
     class RouteListIterator;
@@ -318,6 +321,29 @@ class XdsResolver final : public Resolver {
     };
   };
 
+  // Wraps a FilterChainBuilder in an XdsFilterChainBuilder.
+  // Also adds the ClusterSelectionFilter to the end of each filter chain.
+  class FilterChainBuilderWrapper final
+      : public XdsRouting::RouteConfigFilterChainBuilder::
+            XdsFilterChainBuilder {
+   public:
+    explicit FilterChainBuilderWrapper(FilterChainBuilder& builder)
+        : builder_(builder) {}
+
+    void AddFilter(const XdsHttpFilterFactory* factory,
+                   RefCountedPtr<const FilterConfig> config) override {
+      factory->AddFilter(builder_, std::move(config));
+    }
+
+    absl::StatusOr<RefCountedPtr<FilterChain>> Build() override {
+      builder_.AddFilter<ClusterSelectionFilter>(nullptr);
+      return builder_.Build();
+    }
+
+   private:
+    FilterChainBuilder& builder_;
+  };
+
   RefCountedPtr<ClusterRef> GetOrCreateClusterRef(
       absl::string_view cluster_key, absl::string_view cluster_name) {
     auto it = cluster_ref_map_.find(cluster_key);
@@ -420,15 +446,14 @@ XdsResolver::RouteConfigData::GetRouteForRequest(
 void XdsResolver::RouteConfigData::BuildFilterChains(
     const XdsConfig& xds_config,
     const XdsHttpFilterRegistry& http_filter_registry,
-    FilterChainBuilder& builder, Blackboard& blackboard) {
+    FilterChainBuilder& builder, XdsTransportFactory& transport_factory,
+    Blackboard& blackboard) {
   const auto& hcm = std::get<XdsListenerResource::HttpConnectionManager>(
       xds_config.listener->listener);
+  FilterChainBuilderWrapper builder_wrapper(builder);
   XdsRouting::RouteConfigFilterChainBuilder route_config_builder(
-      hcm.http_filters, http_filter_registry, builder,
-      [](FilterChainBuilder& builder) {
-        builder.AddFilter<ClusterSelectionFilter>(nullptr);
-      },
-      blackboard);
+      hcm.http_filters, http_filter_registry, builder_wrapper,
+      transport_factory, blackboard);
   auto vhost_builder = route_config_builder.MakeVirtualHostFilterChainBuilder(
       *xds_config.virtual_host);
   // Set the filter chain for each route.
@@ -759,8 +784,9 @@ void XdsResolver::XdsConfigSelector::BuildFilterChains(
   const auto& http_filter_registry =
       DownCast<const GrpcXdsBootstrap&>(resolver_->xds_client_->bootstrap())
           .http_filter_registry();
-  route_config_data_->BuildFilterChains(*xds_config_, http_filter_registry,
-                                        builder, *resolver_->blackboard_);
+  route_config_data_->BuildFilterChains(
+      *xds_config_, http_filter_registry, builder,
+      *resolver_->xds_client_->transport_factory(), *resolver_->blackboard_);
 }
 
 //

data/src/core/server/server.cc

@@ -1323,9 +1323,7 @@ grpc_error_handle Server::SetupTransport(
         args.SetObject(transport).SetObject<channelz::BaseNode>(
             transport->GetSocketNode()),
         channel_stack_type);
-    if (!destination.ok()) {
-      return absl_status_to_grpc_error(destination.status());
-    }
+    if (!destination.ok()) return destination.status();
     t->SetCallDestination(std::move(*destination));
     MutexLock lock(&mu_global_);
     if (ShutdownCalled()) {
@@ -1347,9 +1345,7 @@ grpc_error_handle Server::SetupTransport(
         args.SetObject(transport).SetObject<channelz::BaseNode>(
             transport->GetSocketNode()),
         channel_stack_type);
-    if (!channel.ok()) {
-      return absl_status_to_grpc_error(channel.status());
-    }
+    if (!channel.ok()) return channel.status();
     GRPC_CHECK(*channel != nullptr);
     auto* channel_stack = (*channel)->channel_stack();
     GRPC_CHECK(channel_stack != nullptr);

data/src/core/server/server_config_selector.h

@@ -22,6 +22,7 @@
 #include <memory>
 
 #include "src/core/call/metadata_batch.h"
+#include "src/core/filter/filter_chain.h"
 #include "src/core/service_config/service_config.h"
 #include "src/core/service_config/service_config_parser.h"
 #include "src/core/util/dual_ref_counted.h"
@@ -37,17 +38,31 @@ namespace grpc_core {
 // server-side call based on the received initial metadata.
 class ServerConfigSelector : public RefCounted<ServerConfigSelector> {
  public:
+  // A base class for connection state.
+  class ConnectionState {
+   public:
+    virtual ~ConnectionState() = default;
+  };
+
+  // The server will call this when the provider returns a new
+  // ServerConfigSelector to initialize the filter chains that the
+  // ServerConfigSelector may need.
+  virtual std::unique_ptr<ConnectionState> BuildFilterChains(
+      FilterChainBuilder& builder) = 0;
+
   // Configuration to apply to an incoming call
+  // TODO(roth): When we remove the xds_server_filter_chain_per_route
+  // experiment, remove this struct and have GetCallConfig() return
+  // the filter chain directly.
   struct CallConfig {
     const ServiceConfigParser::ParsedConfigVector* method_configs = nullptr;
     RefCountedPtr<ServiceConfig> service_config;
+    absl::StatusOr<RefCountedPtr<const FilterChain>> filter_chain;
   };
 
-  ~ServerConfigSelector() override = default;
-
   // Returns the CallConfig to apply to a call based on the incoming \a metadata
   virtual absl::StatusOr<CallConfig> GetCallConfig(
-      grpc_metadata_batch* metadata) = 0;
+      const ConnectionState* state, grpc_metadata_batch* metadata) = 0;
 };
 
 // ServerConfigSelectorProvider allows for subscribers to watch for updates on