grpc 1.83.1 → 1.84.0

data/src/core/server/xds_server_config_fetcher.cc

@@ -16,12 +16,13 @@
 //
 //
 
+#include "src/core/server/xds_server_config_fetcher.h"
+
 #include <grpc/credentials.h>
 #include <grpc/grpc.h>
 #include <grpc/grpc_security.h>
 #include <grpc/slice.h>
 #include <grpc/status.h>
-#include <grpc/support/port_platform.h>
 #include <string.h>
 
 #include <algorithm>
@@ -67,6 +68,7 @@
 #include "src/core/util/sync.h"
 #include "src/core/util/unique_type_name.h"
 #include "src/core/util/uri.h"
+#include "src/core/xds/grpc/blackboard.h"
 #include "src/core/xds/grpc/certificate_provider_store.h"
 #include "src/core/xds/grpc/xds_bootstrap_grpc.h"
 #include "src/core/xds/grpc/xds_certificate_provider.h"
@@ -101,10 +103,14 @@ using ReadDelayHandle = XdsClient::ReadDelayHandle;
 // annotations and save a bit of memory.
 struct FetcherState final : public RefCounted<FetcherState> {
   RefCountedPtr<GrpcXdsClient> xds_client;
+  RefCountedPtr<XdsResourceNameGenerator> resource_name_generator;
   WorkSerializer work_serializer;
 
-  explicit FetcherState(RefCountedPtr<GrpcXdsClient> xds_client_in)
+  FetcherState(
+      RefCountedPtr<GrpcXdsClient> xds_client_in,
+      RefCountedPtr<XdsResourceNameGenerator> resource_name_generator_in)
       : xds_client(std::move(xds_client_in)),
+        resource_name_generator(std::move(resource_name_generator_in)),
         work_serializer(
             grpc_event_engine::experimental::GetDefaultEventEngine()) {
     GRPC_CHECK(xds_client != nullptr);
@@ -119,8 +125,10 @@ struct FetcherState final : public RefCounted<FetcherState> {
 // listeners from the xDS control plane.
 class XdsServerConfigFetcher final : public ServerConfigFetcher {
  public:
-  XdsServerConfigFetcher(RefCountedPtr<GrpcXdsClient> xds_client,
-                         grpc_server_xds_status_notifier notifier);
+  XdsServerConfigFetcher(
+      RefCountedPtr<GrpcXdsClient> xds_client,
+      grpc_server_xds_status_notifier notifier,
+      RefCountedPtr<XdsResourceNameGenerator> resource_name_generator);
 
   ~XdsServerConfigFetcher() override {
     fetcher_state_.reset(DEBUG_LOCATION, "XdsServerConfigFetcher");
@@ -179,6 +187,8 @@ class XdsServerConfigFetcher::ListenerWatcher final
 
   const std::string& listening_address() const { return listening_address_; }
 
+  std::string ResourceName() const;
+
  private:
   class XdsConnectionManager;
 
@@ -202,6 +212,9 @@ class XdsServerConfigFetcher::ListenerWatcher final
       ABSL_GUARDED_BY(&FetcherState::work_serializer);
   RefCountedPtr<XdsConnectionManager> pending_connection_manager_
       ABSL_GUARDED_BY(&FetcherState::work_serializer);
+
+  RefCountedPtr<Blackboard> blackboard_
+      ABSL_GUARDED_BY(&FetcherState::work_serializer);
 };
 
 // A connection manager used by the server listener code to inject channel args
@@ -262,6 +275,9 @@ class XdsServerConfigFetcher::ListenerWatcher::XdsConnectionManager final
   // ready.
   RefCountedPtr<ListenerWatcher> listener_watcher_
       ABSL_GUARDED_BY(&FetcherState::work_serializer);
+
+  RefCountedPtr<Blackboard> blackboard_
+      ABSL_GUARDED_BY(&FetcherState::work_serializer);
 };
 
 class XdsServerConfigFetcher::ListenerWatcher::XdsConnectionManager::
@@ -328,6 +344,30 @@ class XdsServerConfigFetcher::ListenerWatcher::XdsConnectionManager::
       ABSL_GUARDED_BY(&FetcherState::work_serializer);
 };
 
+using FilterInstance =
+    std::pair<const XdsHttpFilterFactory*, RefCountedPtr<const FilterConfig>>;
+
+struct FilterList final : public FilterChain {
+  std::vector<FilterInstance> filters;
+};
+
+class FilterListBuilder final
+    : public XdsRouting::RouteConfigFilterChainBuilder::XdsFilterChainBuilder {
+ public:
+  void AddFilter(const XdsHttpFilterFactory* factory,
+                 RefCountedPtr<const FilterConfig> config) override {
+    if (filters_ == nullptr) filters_ = MakeRefCounted<FilterList>();
+    filters_->filters.emplace_back(factory, std::move(config));
+  }
+
+  absl::StatusOr<RefCountedPtr<FilterChain>> Build() override {
+    if (filters_ == nullptr) return MakeRefCounted<FilterList>();
+    return std::move(filters_);
+  }
+
+  RefCountedPtr<FilterList> filters_;
+};
+
 // An implementation of ServerConfigSelector that stores parsed xDS filter
 // configs for each route, constructs filter chains for each, and
 // selects the appropriate filter chain for each RPC.
@@ -336,12 +376,17 @@ class XdsServerConfigFetcher::ListenerWatcher::XdsConnectionManager::
  public:
   static absl::StatusOr<RefCountedPtr<XdsServerConfigSelector>> Create(
       const XdsHttpFilterRegistry& http_filter_registry,
+      XdsTransportFactory& transport_factory,
       const std::vector<XdsListenerResource::HttpConnectionManager::HttpFilter>&
           http_filters,
-      std::shared_ptr<const XdsRouteConfigResource> route_config);
+      std::shared_ptr<const XdsRouteConfigResource> route_config,
+      Blackboard& blackboard);
+
+  std::unique_ptr<ConnectionState> BuildFilterChains(
+      FilterChainBuilder& builder) override;
 
   absl::StatusOr<CallConfig> GetCallConfig(
-      grpc_metadata_batch* metadata) override;
+      const ConnectionState* state, grpc_metadata_batch* metadata) override;
 
  private:
   struct VirtualHost {
@@ -350,7 +395,8 @@ class XdsServerConfigFetcher::ListenerWatcher::XdsConnectionManager::
       bool unsupported_action;
       // Points inside of XdsServerConfigSelector::route_config_.
       const XdsRouteConfigResource::Route::Matchers* matchers;
-      RefCountedPtr<ServiceConfig> method_config;
+      // The list of filter instances and configs to use for this route.
+      RefCountedPtr<const FilterList> filter_list;
     };
 
     class RouteListIterator final : public XdsRouting::RouteListIterator {
@@ -392,6 +438,12 @@ class XdsServerConfigFetcher::ListenerWatcher::XdsConnectionManager::
     const std::vector<VirtualHost>& virtual_hosts_;
   };
 
+  struct XdsConnectionState final : public ConnectionState {
+    absl::flat_hash_map<const VirtualHost::Route*,
+                        absl::StatusOr<RefCountedPtr<const FilterChain>>>
+        filter_chains;
+  };
+
   std::shared_ptr<const XdsRouteConfigResource> route_config_;
   std::vector<VirtualHost> virtual_hosts_;
 };
@@ -402,21 +454,12 @@ class XdsServerConfigFetcher::ListenerWatcher::XdsConnectionManager::
 
 XdsServerConfigFetcher::XdsServerConfigFetcher(
     RefCountedPtr<GrpcXdsClient> xds_client,
-    grpc_server_xds_status_notifier notifier)
-    : fetcher_state_(MakeRefCounted<FetcherState>(std::move(xds_client))),
+    grpc_server_xds_status_notifier notifier,
+    RefCountedPtr<XdsResourceNameGenerator> resource_name_generator)
+    : fetcher_state_(MakeRefCounted<FetcherState>(
+          std::move(xds_client), std::move(resource_name_generator))),
       serving_status_notifier_(notifier) {}
 
-std::string ListenerResourceName(absl::string_view resource_name_template,
-                                 absl::string_view listening_address) {
-  std::string tmp;
-  if (absl::StartsWith(resource_name_template, "xdstp:")) {
-    tmp = URI::PercentEncodePath(listening_address);
-    listening_address = tmp;
-  }
-  return absl::StrReplaceAll(resource_name_template,
-                             {{"%s", listening_address}});
-}
-
 void XdsServerConfigFetcher::StartWatch(
     std::string listening_address,
     std::unique_ptr<ServerConfigFetcher::WatcherInterface> watcher) {
@@ -426,20 +469,16 @@ void XdsServerConfigFetcher::StartWatch(
        watcher = std::move(watcher)]()
           ABSL_EXCLUSIVE_LOCKS_REQUIRED(
               &FetcherState::work_serializer) mutable {
-            std::string resource_name = ListenerResourceName(
-                DownCast<const GrpcXdsBootstrap&>(
-                    self->fetcher_state_->xds_client->bootstrap())
-                    .server_listener_resource_name_template(),
-                listening_address);
-            GRPC_TRACE_LOG(xds_server_config_fetcher, INFO)
-                << "[XdsServerConfigFetcher " << self.get()
-                << "]: starting watch for LDS resource " << resource_name;
             ServerConfigFetcher::WatcherInterface* watcher_ptr = watcher.get();
             auto listener_watcher = MakeRefCounted<ListenerWatcher>(
                 self->fetcher_state_.Ref(DEBUG_LOCATION, "ListenerWatcher"),
                 std::move(watcher), self->serving_status_notifier_,
                 listening_address);
             auto* listener_watcher_ptr = listener_watcher.get();
+            std::string resource_name = listener_watcher->ResourceName();
+            GRPC_TRACE_LOG(xds_server_config_fetcher, INFO)
+                << "[XdsServerConfigFetcher " << self.get()
+                << "]: starting watch for LDS resource " << resource_name;
             XdsListenerResourceType::StartWatch(
                 self->fetcher_state_->xds_client.get(), resource_name,
                 std::move(listener_watcher));
@@ -454,18 +493,13 @@ void XdsServerConfigFetcher::CancelWatch(
           ABSL_EXCLUSIVE_LOCKS_REQUIRED(&FetcherState::work_serializer) {
             auto it = self->listener_watchers_.find(watcher);
             if (it == self->listener_watchers_.end()) return;
-            std::string resource_name = ListenerResourceName(
-                DownCast<const GrpcXdsBootstrap&>(
-                    self->fetcher_state_->xds_client->bootstrap())
-                    .server_listener_resource_name_template(),
-                it->second->listening_address());
+            std::string resource_name = it->second->ResourceName();
             GRPC_TRACE_LOG(xds_server_config_fetcher, INFO)
                 << "[XdsServerConfigFetcher " << self.get()
                 << "]: cancelling watch for LDS resource " << resource_name;
             XdsListenerResourceType::CancelWatch(
                 self->fetcher_state_->xds_client.get(), resource_name,
-                it->second,
-                /*delay_unsubscription=*/false);
+                it->second, /*delay_unsubscription=*/false);
             self->listener_watchers_.erase(it);
           });
 }
@@ -483,12 +517,32 @@ XdsServerConfigFetcher::ListenerWatcher::ListenerWatcher(
     : fetcher_state_(std::move(fetcher_state)),
       server_config_watcher_(std::move(server_config_watcher)),
       serving_status_notifier_(serving_status_notifier),
-      listening_address_(std::move(listening_address)) {
+      listening_address_(std::move(listening_address)),
+      blackboard_(MakeRefCounted<Blackboard>()) {
   GRPC_TRACE_LOG(xds_server_config_fetcher, INFO)
       << "[ListenerWatcher " << this << "]: created for address "
       << listening_address_;
 }
 
+// Returns true if the listener address matches the address that the
+// server is actually listening on.
+bool ListenerAddressMatches(absl::string_view listener_address,
+                            absl::string_view server_address) {
+  if (listener_address == server_address) return true;
+  absl::string_view listener_host;
+  absl::string_view listener_port;
+  if (!SplitHostPort(listener_address, &listener_host, &listener_port)) {
+    return false;
+  }
+  absl::string_view server_host;
+  absl::string_view server_port;
+  if (!SplitHostPort(server_address, &server_host, &server_port)) {
+    return false;
+  }
+  if (listener_host != server_host) return false;
+  return listener_port == "0" || listener_port == server_port;
+}
+
 void XdsServerConfigFetcher::ListenerWatcher::OnResourceChanged(
     absl::StatusOr<std::shared_ptr<const XdsListenerResource>> listener,
     RefCountedPtr<ReadDelayHandle> read_delay_handle) {
@@ -498,9 +552,9 @@ void XdsServerConfigFetcher::ListenerWatcher::OnResourceChanged(
           ABSL_EXCLUSIVE_LOCKS_REQUIRED(
               &FetcherState::work_serializer) mutable {
             if (!listener.ok()) {
-              self->OnFatalError(absl::Status(
-                  listener.status().code(),
-                  absl::StrCat("LDS resource: ", listener.status().message())));
+              self->OnFatalError(AddMessagePrefix(
+                  absl::StrCat("LDS resource ", self->ResourceName()),
+                  listener.status()));
               return;
             }
             GRPC_TRACE_LOG(xds_server_config_fetcher, INFO)
@@ -512,12 +566,15 @@ void XdsServerConfigFetcher::ListenerWatcher::OnResourceChanged(
                 &(*listener)->listener);
             if (tcp_listener == nullptr) {
               self->OnFatalError(absl::FailedPreconditionError(
-                  "LDS resource is not a TCP listener"));
+                  absl::StrCat("LDS resource ", self->ResourceName(),
+                               " is not a TCP listener")));
               return;
             }
-            if (tcp_listener->address != self->listening_address_) {
+            if (!ListenerAddressMatches(tcp_listener->address,
+                                        self->listening_address_)) {
               self->OnFatalError(absl::FailedPreconditionError(
-                  "Address in LDS update does not match listening address"));
+                  absl::StrCat("LDS resource ", self->ResourceName(),
+                               " address does not match listening address")));
               return;
             }
             if (self->connection_manager_ != nullptr &&
@@ -593,6 +650,24 @@ void XdsServerConfigFetcher::ListenerWatcher::MaybeUpdateConnectionManager(
   }
 }
 
+std::string XdsServerConfigFetcher::ListenerWatcher::ResourceName() const {
+  if (fetcher_state_->resource_name_generator != nullptr) {
+    return fetcher_state_->resource_name_generator->GetResourceName(
+        listening_address_);
+  }
+  absl::string_view resource_name_template =
+      DownCast<const GrpcXdsBootstrap&>(fetcher_state_->xds_client->bootstrap())
+          .server_listener_resource_name_template();
+  absl::string_view listening_address = listening_address_;
+  std::string tmp;
+  if (absl::StartsWith(resource_name_template, "xdstp:")) {
+    tmp = URI::PercentEncodePath(listening_address);
+    listening_address = tmp;
+  }
+  return absl::StrReplaceAll(resource_name_template,
+                             {{"%s", listening_address}});
+}
+
 //
 // XdsServerConfigFetcher::ListenerWatcher::XdsConnectionManager
 //
@@ -604,7 +679,8 @@ XdsServerConfigFetcher::ListenerWatcher::XdsConnectionManager::
         RefCountedPtr<ListenerWatcher> listener_watcher)
     : fetcher_state_(std::move(fetcher_state)),
       listener_resource_(std::move(listener_resource)),
-      listener_watcher_(std::move(listener_watcher)) {
+      listener_watcher_(std::move(listener_watcher)),
+      blackboard_(listener_watcher_->blackboard_) {
   GRPC_TRACE_LOG(xds_server_config_fetcher, INFO)
       << "[XdsConnectionManager " << this << "]: created";
 }
@@ -1087,43 +1163,12 @@ absl::StatusOr<ChannelArgs> XdsServerConfigFetcher::ListenerWatcher::
     XdsConnectionManager::L4FilterChain::UpdateChannelArgsForConnection(
         const ChannelArgs& args) const {
   if (!certificate_provider_.ok()) return certificate_provider_.status();
-  ChannelArgs new_args = args.SetObject(*certificate_provider_);
-  // Add channel stack modifier to insert HTTP filters.
-  // TODO(roth): Instead of using a channel stack modifier, register the
-  // ServerConfigSelectorInterceptor whenever there is a
-  // ServerConfigSelectorProvider in channel args, and have that
-  // interceptor inject the necessary HTTP filters.
-  std::vector<const grpc_channel_filter*> filters;
-  const auto& http_filter_registry =
-      DownCast<const GrpcXdsBootstrap&>(fetcher_state_->xds_client->bootstrap())
-          .http_filter_registry();
-  for (const auto& http_filter :
-       filter_chain_data_.http_connection_manager.http_filters) {
-    // Find filter.  This is guaranteed to succeed, because it's checked
-    // at config validation time in the XdsApi code.
-    const XdsHttpFilterImpl* filter_impl =
-        http_filter_registry.GetFilterForTopLevelType(
-            http_filter.config_proto_type);
-    GRPC_CHECK_NE(filter_impl, nullptr);
-    // Some filters like the router filter are no-op filters and do not have
-    // an implementation.
-    if (filter_impl->channel_filter() != nullptr) {
-      filters.push_back(filter_impl->channel_filter());
-    }
-  }
-  // Reverse the order, since filters flow *up* the stack on the server side.
-  std::reverse(filters.begin(), filters.end());
-  // Add config selector filter.
-  filters.push_back(&kServerConfigSelectorFilter);
-  new_args = new_args.SetObject(
-      MakeRefCounted<XdsChannelStackModifier>(std::move(filters)));
-  // TODO(roth): Don't add ConfigSelectorProvider if there are no filters.
-  new_args = new_args.SetObject(
-      // This is the only place where the provider is accessed from outside
-      // of the WorkSerializer, and it will always be set before this
-      // happens, so this read is safe even though the compiler can't tell.
-      ABSL_TS_UNCHECKED_READ(config_selector_provider_));
-  return new_args;
+  return args.SetObject(*certificate_provider_)
+      .SetObject(
+          // This is the only place where the provider is accessed from outside
+          // of the WorkSerializer, and it will always be set before this
+          // happens, so this read is safe even though the compiler can't tell.
+          ABSL_TS_UNCHECKED_READ(config_selector_provider_));
 }
 
 absl::StatusOr<RefCountedPtr<ServerConfigSelector>>
@@ -1135,8 +1180,9 @@ XdsServerConfigFetcher::ListenerWatcher::XdsConnectionManager::L4FilterChain::
   return XdsServerConfigSelector::Create(
       DownCast<const GrpcXdsBootstrap&>(fetcher_state_->xds_client->bootstrap())
           .http_filter_registry(),
+      *fetcher_state_->xds_client->transport_factory(),
       filter_chain_data_.http_connection_manager.http_filters,
-      std::move(*route_config));
+      std::move(*route_config), *connection_manager_->blackboard_);
 }
 
 void XdsServerConfigFetcher::ListenerWatcher::XdsConnectionManager::
@@ -1166,6 +1212,7 @@ void XdsServerConfigFetcher::ListenerWatcher::XdsConnectionManager::
             route_config) {
   GRPC_TRACE_LOG(xds_server_config_fetcher, INFO)
       << "[L4FilterChain " << this << "]: received RDS update";
+  if (connection_manager_ == nullptr) return;
   if (!route_config.ok()) {
     auto& hcm = filter_chain_data_.http_connection_manager;
     auto& rds_resource_name = std::get<std::string>(hcm.route_config);
@@ -1195,60 +1242,71 @@ absl::StatusOr<RefCountedPtr<
 XdsServerConfigFetcher::ListenerWatcher::XdsConnectionManager::L4FilterChain::
     XdsServerConfigSelector::Create(
         const XdsHttpFilterRegistry& http_filter_registry,
+        XdsTransportFactory& transport_factory,
         const std::vector<
             XdsListenerResource::HttpConnectionManager::HttpFilter>&
             http_filters,
-        std::shared_ptr<const XdsRouteConfigResource> route_config) {
-  // TODO(roth): For each route, construct merged filter configs and
-  // update blackboard.  Also add support for building filter chains for
-  // each connection.  And make sure to reverse the order of the filters
-  // when we construct the filter chain.
+        std::shared_ptr<const XdsRouteConfigResource> route_config,
+        Blackboard& blackboard) {
   auto config_selector = MakeRefCounted<XdsServerConfigSelector>();
+  FilterListBuilder filter_list_builder;
+  XdsRouting::RouteConfigFilterChainBuilder route_config_builder(
+      http_filters, http_filter_registry, filter_list_builder,
+      transport_factory, blackboard);
   for (auto& vhost : route_config->virtual_hosts) {
-    config_selector->virtual_hosts_.emplace_back();
-    auto& virtual_host = config_selector->virtual_hosts_.back();
+    auto vhost_builder =
+        route_config_builder.MakeVirtualHostFilterChainBuilder(vhost);
+    auto& virtual_host = config_selector->virtual_hosts_.emplace_back();
     virtual_host.domains = &vhost.domains;
     for (auto& route : vhost.routes) {
-      virtual_host.routes.emplace_back();
-      auto& config_selector_route = virtual_host.routes.back();
+      auto& config_selector_route = virtual_host.routes.emplace_back();
       config_selector_route.matchers = &route.matchers;
       config_selector_route.unsupported_action =
           std::get_if<XdsRouteConfigResource::Route::NonForwardingAction>(
               &route.action) == nullptr;
-      auto result = XdsRouting::GeneratePerHTTPFilterConfigsForMethodConfig(
-          http_filter_registry, http_filters, vhost, route, nullptr,
-          ChannelArgs());
-      if (!result.ok()) return result.status();
-      std::vector<std::string> fields;
-      fields.reserve(result->per_filter_configs.size());
-      for (const auto& p : result->per_filter_configs) {
-        fields.emplace_back(absl::StrCat("    \"", p.first, "\": [\n",
-                                         absl::StrJoin(p.second, ",\n"),
-                                         "\n    ]"));
-      }
-      if (!fields.empty()) {
-        std::string json = absl::StrCat(
-            "{\n"
-            "  \"methodConfig\": [ {\n"
-            "    \"name\": [\n"
-            "      {}\n"
-            "    ],\n"
-            "    ",
-            absl::StrJoin(fields, ",\n"),
-            "\n  } ]\n"
-            "}");
-        config_selector_route.method_config =
-            ServiceConfigImpl::Create(result->args, json.c_str()).value();
-      }
+      auto filter_list = vhost_builder.BuildFilterChainForRoute(route);
+      if (!filter_list.ok()) return filter_list.status();
+      config_selector_route.filter_list =
+          filter_list->TakeAsSubclass<const FilterList>();
     }
   }
   config_selector->route_config_ = std::move(route_config);
   return config_selector;
 }
 
+std::unique_ptr<ServerConfigSelector::ConnectionState>
+XdsServerConfigFetcher::ListenerWatcher::XdsConnectionManager::L4FilterChain::
+    XdsServerConfigSelector::BuildFilterChains(FilterChainBuilder& builder) {
+  auto connection_state = std::make_unique<XdsConnectionState>();
+  // It's likely that multiple routes have the same filter list, so we
+  // reuse filter chains if possible.
+  absl::flat_hash_map<const FilterList*,
+                      absl::StatusOr<RefCountedPtr<const FilterChain>>>
+      cache;
+  for (const auto& vhost : virtual_hosts_) {
+    for (const auto& route : vhost.routes) {
+      absl::StatusOr<RefCountedPtr<const FilterChain>> filter_chain;
+      auto it = cache.find(route.filter_list.get());
+      if (it == cache.end()) {
+        // Not found in cache, so construct a new filter chain.
+        for (const auto& [factory, config] : route.filter_list->filters) {
+          factory->AddFilter(builder, config);
+        }
+        filter_chain = builder.Build();
+        cache.emplace(route.filter_list.get(), filter_chain);
+      } else {
+        filter_chain = it->second;
+      }
+      connection_state->filter_chains.emplace(&route, std::move(filter_chain));
+    }
+  }
+  return connection_state;
+}
+
 absl::StatusOr<ServerConfigSelector::CallConfig>
 XdsServerConfigFetcher::ListenerWatcher::XdsConnectionManager::L4FilterChain::
-    XdsServerConfigSelector::GetCallConfig(grpc_metadata_batch* metadata) {
+    XdsServerConfigSelector::GetCallConfig(const ConnectionState* state,
+                                           grpc_metadata_batch* metadata) {
   CallConfig call_config;
   if (metadata->get_pointer(HttpPathMetadata()) == nullptr) {
     return absl::InternalError("no path found");
@@ -1278,12 +1336,17 @@ XdsServerConfigFetcher::ListenerWatcher::XdsConnectionManager::L4FilterChain::
   if (route.unsupported_action) {
     return absl::UnavailableError("matching route has unsupported action");
   }
-  if (route.method_config != nullptr) {
-    call_config.method_configs =
-        route.method_config->GetMethodParsedConfigVector(grpc_empty_slice());
-    call_config.service_config = route.method_config;
+  // Find filter chain.
+  const auto& filter_chains =
+      DownCast<const XdsConnectionState*>(state)->filter_chains;
+  auto it = filter_chains.find(&route);
+  if (it == filter_chains.end()) {
+    // Should never happen.
+    call_config.filter_chain =
+        absl::InternalError("no filter chain found for route");
+  } else {
+    call_config.filter_chain = it->second;
   }
-  // TODO(roth): Return the filter chain to use for this call.
   return call_config;
 }
 
@@ -1314,15 +1377,19 @@ grpc_server_config_fetcher* grpc_server_config_fetcher_xds_create(
     LOG(ERROR) << "Failed to create xds client: " << xds_client.status();
     return nullptr;
   }
-  if (grpc_core::DownCast<const grpc_core::GrpcXdsBootstrap&>(
-          (*xds_client)->bootstrap())
-          .server_listener_resource_name_template()
-          .empty()) {
-    LOG(ERROR) << "server_listener_resource_name_template not provided in "
-                  "bootstrap file.";
-    return nullptr;
+  auto generator =
+      channel_args.GetObjectRef<grpc_core::XdsResourceNameGenerator>();
+  if (generator == nullptr) {
+    if (grpc_core::DownCast<const grpc_core::GrpcXdsBootstrap&>(
+            (*xds_client)->bootstrap())
+            .server_listener_resource_name_template()
+            .empty()) {
+      LOG(ERROR) << "server_listener_resource_name_template not provided in "
+                    "bootstrap file.";
+      return nullptr;
+    }
   }
   return (new grpc_core::XdsServerConfigFetcher(std::move(*xds_client),
-                                                notifier))
+                                                notifier, std::move(generator)))
       ->c_ptr();
 }

data/src/core/server/xds_server_config_fetcher.h

@@ -0,0 +1,49 @@
+//
+//
+// Copyright 2026 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_SERVER_XDS_SERVER_CONFIG_FETCHER_H
+#define GRPC_SRC_CORE_SERVER_XDS_SERVER_CONFIG_FETCHER_H
+
+#include <string>
+
+#include "src/core/util/ref_counted.h"
+#include "src/core/util/useful.h"
+#include "absl/strings/string_view.h"
+
+namespace grpc_core {
+
+// Generates the LDS resource name to watch for a given listening address.
+// An implementation can be supplied via a channel arg to override the default
+// behavior of formatting the resource name from the bootstrap's
+// server_listener_resource_name_template.
+class XdsResourceNameGenerator : public RefCounted<XdsResourceNameGenerator> {
+ public:
+  virtual std::string GetResourceName(absl::string_view listening_address) = 0;
+
+  static absl::string_view ChannelArgName() {
+    return "grpc.xds_resource_name_generator";
+  }
+  static int ChannelArgsCompare(const XdsResourceNameGenerator* a,
+                                const XdsResourceNameGenerator* b) {
+    return QsortCompare(a, b);
+  }
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_SERVER_XDS_SERVER_CONFIG_FETCHER_H