grpc 1.81.1 → 1.82.0.pre2

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

@@ -38,7 +38,6 @@
 #include "src/core/client_channel/client_channel_internal.h"
 #include "src/core/client_channel/config_selector.h"
 #include "src/core/config/core_configuration.h"
-#include "src/core/filter/blackboard.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"
@@ -72,6 +71,7 @@
 #include "src/core/util/uri.h"
 #include "src/core/util/work_serializer.h"
 #include "src/core/util/xxhash_inline.h"
+#include "src/core/xds/grpc/blackboard.h"
 #include "src/core/xds/grpc/xds_bootstrap_grpc.h"
 #include "src/core/xds/grpc/xds_client_grpc.h"
 #include "src/core/xds/grpc/xds_http_filter.h"
@@ -109,7 +109,8 @@ class XdsResolver final : public Resolver {
         interested_parties_(args.pollset_set),
         uri_(std::move(args.uri)),
         data_plane_authority_(std::move(data_plane_authority)),
-        channel_id_(absl::Uniform<uint64_t>(absl::BitGen())) {
+        channel_id_(absl::Uniform<uint64_t>(absl::BitGen())),
+        blackboard_(MakeRefCounted<Blackboard>()) {
     GRPC_TRACE_LOG(xds_resolver, INFO)
         << "[xds_resolver " << this << "] created for URI " << uri_.ToString()
         << "; data plane authority is " << data_plane_authority_;
@@ -192,14 +193,9 @@ class XdsResolver final : public Resolver {
         uint32_t range_end;
         absl::string_view cluster;
         absl::StatusOr<RefCountedPtr<const FilterChain>> filter_chain;
-        // TODO(roth): Remove this field as part of removing the
-        // xds_channel_filter_chain_per_route experiment.
-        RefCountedPtr<ServiceConfig> method_config;
       };
 
       XdsRouteConfigResource::Route route;
-      // TODO(roth): Remove this field as part of removing the
-      // xds_channel_filter_chain_per_route experiment.
       RefCountedPtr<ServiceConfig> method_config;
       absl::StatusOr<RefCountedPtr<const FilterChain>> filter_chain;
       std::vector<ClusterWeightState> weighted_cluster_state;
@@ -223,19 +219,13 @@ class XdsResolver final : public Resolver {
 
     void BuildFilterChains(const XdsConfig& xds_config,
                            const XdsHttpFilterRegistry& http_filter_registry,
-                           FilterChainBuilder& builder,
-                           const Blackboard* old_blackboard,
-                           Blackboard* new_blackboard);
+                           FilterChainBuilder& builder, Blackboard& blackboard);
 
    private:
     class RouteListIterator;
 
     static absl::StatusOr<RefCountedPtr<ServiceConfig>> CreateMethodConfig(
-        XdsResolver* resolver, const XdsRouteConfigResource::Route& route,
-        // TODO(roth): Remove this field as part of removing the
-        // xds_channel_filter_chain_per_route experiment.
-        const XdsRouteConfigResource::Route::RouteAction::ClusterWeight*
-            cluster_weight);
+        XdsResolver* resolver, const XdsRouteConfigResource::Route& route);
 
     absl::Status AddRouteEntry(XdsResolver* resolver,
                                const XdsRouteConfigResource::Route& route,
@@ -265,9 +255,7 @@ class XdsResolver final : public Resolver {
                  *other_xds->xds_config_->route_config;
     }
 
-    void BuildFilterChains(FilterChainBuilder& builder,
-                           const Blackboard* old_blackboard,
-                           Blackboard* new_blackboard) override;
+    void BuildFilterChains(FilterChainBuilder& builder) override;
 
     absl::StatusOr<RefCountedPtr<const FilterChain>> GetCallConfig(
         GetCallConfigArgs args) override;
@@ -276,9 +264,6 @@ class XdsResolver final : public Resolver {
     RefCountedPtr<XdsResolver> resolver_;
     RefCountedPtr<const XdsConfig> xds_config_;
     RefCountedPtr<RouteConfigData> route_config_data_;
-    // TODO(roth): Remove this field as part of removing the
-    // xds_channel_filter_chain_per_route experiment.
-    absl::StatusOr<RefCountedPtr<const FilterChain>> filter_chain_;
   };
 
   class XdsRouteStateAttributeImpl final : public XdsRouteStateAttribute {
@@ -368,6 +353,7 @@ class XdsResolver final : public Resolver {
   std::string data_plane_authority_;
   const uint64_t channel_id_;
 
+  RefCountedPtr<Blackboard> blackboard_;
   OrphanablePtr<XdsDependencyManager> dependency_mgr_;
   RefCountedPtr<const XdsConfig> current_config_;
   std::map<absl::string_view, WeakRefCountedPtr<ClusterRef>> cluster_ref_map_;
@@ -431,23 +417,10 @@ XdsResolver::RouteConfigData::GetRouteForRequest(
   return &routes_[*route_index];
 }
 
-RefCountedPtr<const FilterConfig> GetOverrideConfig(
-    const XdsHttpFilterImpl* filter_impl,
-    const XdsRouteConfigResource::TypedPerFilterConfig& typed_per_filter_config,
-    const std::string& name) {
-  auto it = typed_per_filter_config.find(name);
-  if (it == typed_per_filter_config.end()) return nullptr;
-  if (it->second.config_proto_type != filter_impl->OverrideConfigProtoName()) {
-    return nullptr;
-  }
-  return it->second.filter_config;
-}
-
 void XdsResolver::RouteConfigData::BuildFilterChains(
     const XdsConfig& xds_config,
     const XdsHttpFilterRegistry& http_filter_registry,
-    FilterChainBuilder& builder, const Blackboard* old_blackboard,
-    Blackboard* new_blackboard) {
+    FilterChainBuilder& builder, Blackboard& blackboard) {
   const auto& hcm = std::get<XdsListenerResource::HttpConnectionManager>(
       xds_config.listener->listener);
   XdsRouting::PerRouteFilterChainBuilder per_route_builder(
@@ -455,7 +428,7 @@ void XdsResolver::RouteConfigData::BuildFilterChains(
       [](FilterChainBuilder& builder) {
         builder.AddFilter<ClusterSelectionFilter>(nullptr);
       },
-      old_blackboard, new_blackboard);
+      blackboard);
   // Set the filter chain for each route.
   for (auto& route_entry : routes_) {
     const auto* route_action =
@@ -488,9 +461,7 @@ void XdsResolver::RouteConfigData::BuildFilterChains(
 
 absl::StatusOr<RefCountedPtr<ServiceConfig>>
 XdsResolver::RouteConfigData::CreateMethodConfig(
-    XdsResolver* resolver, const XdsRouteConfigResource::Route& route,
-    const XdsRouteConfigResource::Route::RouteAction::ClusterWeight*
-        cluster_weight) {
+    XdsResolver* resolver, const XdsRouteConfigResource::Route& route) {
   std::vector<std::string> fields;
   const auto& route_action =
       std::get<XdsRouteConfigResource::Route::RouteAction>(route.action);
@@ -538,23 +509,6 @@ XdsResolver::RouteConfigData::CreateMethodConfig(
         absl::StrFormat("    \"timeout\": \"%s\"",
                         route_action.max_stream_duration->ToJsonString()));
   }
-  ChannelArgs args = resolver->args_;
-  if (!IsXdsChannelFilterChainPerRouteEnabled()) {
-    // Handle xDS HTTP filters.
-    const auto& hcm = std::get<XdsListenerResource::HttpConnectionManager>(
-        resolver->current_config_->listener->listener);
-    auto result = XdsRouting::GeneratePerHTTPFilterConfigsForMethodConfig(
-        DownCast<const GrpcXdsBootstrap&>(resolver->xds_client_->bootstrap())
-            .http_filter_registry(),
-        hcm.http_filters, *resolver->current_config_->virtual_host, route,
-        cluster_weight, resolver->args_);
-    if (!result.ok()) return result.status();
-    for (const auto& [name, config] : result->per_filter_configs) {
-      fields.emplace_back(absl::StrCat(
-          "    \"", name, "\": [\n", absl::StrJoin(config, ",\n"), "\n    ]"));
-    }
-    args = result->args;
-  }
   // Construct service config.
   if (!fields.empty()) {
     std::string json = absl::StrCat(
@@ -567,7 +521,7 @@ XdsResolver::RouteConfigData::CreateMethodConfig(
         absl::StrJoin(fields, ",\n"),
         "\n  } ]\n"
         "}");
-    return ServiceConfigImpl::Create(args, json.c_str());
+    return ServiceConfigImpl::Create(resolver->args_, json.c_str());
   }
   return nullptr;
 }
@@ -596,20 +550,18 @@ absl::Status XdsResolver::RouteConfigData::AddRouteEntry(
     if (!route_action->max_stream_duration.has_value()) {
       route_action->max_stream_duration = default_max_stream_duration;
     }
-    absl::Status status = Match(
+    // Generate method config for the route.
+    auto method_config = CreateMethodConfig(resolver, route_entry->route);
+    if (!method_config.ok()) return method_config.status();
+    route_entry->method_config = std::move(*method_config);
+    // Add cluster(s) for the route.
+    Match(
         route_action->action,
         // cluster name
         [&](const XdsRouteConfigResource::Route::RouteAction::ClusterName&
                 cluster_name) {
-          auto result =
-              CreateMethodConfig(resolver, route_entry->route, nullptr);
-          if (!result.ok()) {
-            return result.status();
-          }
-          route_entry->method_config = std::move(*result);
           maybe_add_cluster(absl::StrCat("cluster:", cluster_name.cluster_name),
                             cluster_name.cluster_name);
-          return absl::OkStatus();
         },
         // WeightedClusters
         [&](const std::vector<
@@ -617,13 +569,7 @@ absl::Status XdsResolver::RouteConfigData::AddRouteEntry(
                 weighted_clusters) {
           uint32_t end = 0;
           for (const auto& weighted_cluster : weighted_clusters) {
-            auto result = CreateMethodConfig(resolver, route_entry->route,
-                                             &weighted_cluster);
-            if (!result.ok()) {
-              return result.status();
-            }
             RouteEntry::ClusterWeightState cluster_weight_state;
-            cluster_weight_state.method_config = std::move(*result);
             end += weighted_cluster.weight;
             cluster_weight_state.range_end = end;
             cluster_weight_state.cluster = weighted_cluster.name;
@@ -632,27 +578,16 @@ absl::Status XdsResolver::RouteConfigData::AddRouteEntry(
             maybe_add_cluster(absl::StrCat("cluster:", weighted_cluster.name),
                               weighted_cluster.name);
           }
-          return absl::OkStatus();
         },
         // ClusterSpecifierPlugin
         [&](const XdsRouteConfigResource::Route::RouteAction::
                 ClusterSpecifierPluginName& cluster_specifier_plugin_name) {
-          auto result =
-              CreateMethodConfig(resolver, route_entry->route, nullptr);
-          if (!result.ok()) {
-            return result.status();
-          }
-          route_entry->method_config = std::move(*result);
           maybe_add_cluster(
               absl::StrCat(
                   "cluster_specifier_plugin:",
                   cluster_specifier_plugin_name.cluster_specifier_plugin_name),
               /*subscription_name=*/"");
-          return absl::OkStatus();
         });
-    if (!status.ok()) {
-      return status;
-    }
   }
   return absl::OkStatus();
 }
@@ -720,7 +655,6 @@ XdsResolver::XdsConfigSelector::GetCallConfig(GetCallConfigArgs args) {
     return absl::UnavailableError("Matching route has inappropriate action");
   }
   std::string cluster_name;
-  RefCountedPtr<ServiceConfig> method_config;
   absl::StatusOr<RefCountedPtr<const FilterChain>> filter_chain;
   Match(
       route_action->action,
@@ -729,7 +663,6 @@ XdsResolver::XdsConfigSelector::GetCallConfig(GetCallConfigArgs args) {
               action_cluster_name) {
         cluster_name =
             absl::StrCat("cluster:", action_cluster_name.cluster_name);
-        method_config = entry->method_config;
         filter_chain = entry->filter_chain;
       },
       // WeightedClusters
@@ -758,7 +691,6 @@ XdsResolver::XdsConfigSelector::GetCallConfig(GetCallConfigArgs args) {
         const auto& cluster_weight = entry->weighted_cluster_state[index];
         GRPC_CHECK(cluster_weight.range_end > key);
         cluster_name = absl::StrCat("cluster:", cluster_weight.cluster);
-        method_config = cluster_weight.method_config;
         filter_chain = cluster_weight.filter_chain;
       },
       // ClusterSpecifierPlugin
@@ -767,12 +699,9 @@ XdsResolver::XdsConfigSelector::GetCallConfig(GetCallConfigArgs args) {
         cluster_name = absl::StrCat(
             "cluster_specifier_plugin:",
             cluster_specifier_plugin_name.cluster_specifier_plugin_name);
-        method_config = entry->method_config;
         filter_chain = entry->filter_chain;
       });
-  if (IsXdsChannelFilterChainPerRouteEnabled() && !filter_chain.ok()) {
-    return filter_chain.status();
-  }
+  if (!filter_chain.ok()) return filter_chain.status();
   auto cluster = route_config_data_->FindClusterRef(cluster_name);
   GRPC_CHECK(cluster != nullptr);
   // Generate a hash.
@@ -805,10 +734,10 @@ XdsResolver::XdsConfigSelector::GetCallConfig(GetCallConfigArgs args) {
     hash = absl::Uniform<uint64_t>(absl::BitGen());
   }
   // Populate service config call data.
-  if (method_config != nullptr) {
+  if (entry->method_config != nullptr) {
     auto* parsed_method_configs =
-        method_config->GetMethodParsedConfigVector(grpc_empty_slice());
-    args.service_config_call_data->SetServiceConfig(std::move(method_config),
+        entry->method_config->GetMethodParsedConfigVector(grpc_empty_slice());
+    args.service_config_call_data->SetServiceConfig(entry->method_config,
                                                     parsed_method_configs);
   }
   args.service_config_call_data->SetCallAttribute(
@@ -818,41 +747,17 @@ XdsResolver::XdsConfigSelector::GetCallConfig(GetCallConfigArgs args) {
   args.service_config_call_data->SetCallAttribute(
       args.arena->ManagedNew<XdsRouteStateAttributeImpl>(route_config_data_,
                                                          entry));
-  if (!IsXdsChannelFilterChainPerRouteEnabled()) return filter_chain_;
   return filter_chain;
 }
 
 void XdsResolver::XdsConfigSelector::BuildFilterChains(
-    FilterChainBuilder& builder, const Blackboard* old_blackboard,
-    Blackboard* new_blackboard) {
-  if (!IsXdsChannelFilterChainPerRouteEnabled()) {
-    const auto& http_filter_registry =
-        DownCast<const GrpcXdsBootstrap&>(resolver_->xds_client_->bootstrap())
-            .http_filter_registry();
-    const auto& hcm = std::get<XdsListenerResource::HttpConnectionManager>(
-        xds_config_->listener->listener);
-    for (const auto& http_filter : hcm.http_filters) {
-      // Find filter.  This is guaranteed to succeed, because it's checked
-      // at config validation time.
-      const XdsHttpFilterImpl* filter_impl =
-          http_filter_registry.GetFilterForTopLevelType(
-              http_filter.config_proto_type);
-      GRPC_CHECK_NE(filter_impl, nullptr);
-      filter_impl->AddFilter(builder, nullptr);
-      filter_impl->UpdateBlackboard(http_filter.config, old_blackboard,
-                                    new_blackboard);
-    }
-    builder.AddFilter<ClusterSelectionFilter>(nullptr);
-    filter_chain_ = builder.Build();
-    return;
-  }
+    FilterChainBuilder& builder) {
   // Build filter chains.
   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, old_blackboard,
-                                        new_blackboard);
+                                        builder, *resolver_->blackboard_);
 }
 
 //
@@ -1062,21 +967,6 @@ XdsResolver::CreateServiceConfig() {
                    "    } }\n"
                    "  ]"));
   ChannelArgs args = args_;
-  if (!IsXdsChannelFilterChainPerRouteEnabled()) {
-    auto& hcm = std::get<XdsListenerResource::HttpConnectionManager>(
-        current_config_->listener->listener);
-    auto filter_configs =
-        XdsRouting::GeneratePerHTTPFilterConfigsForServiceConfig(
-            static_cast<const GrpcXdsBootstrap&>(xds_client_->bootstrap())
-                .http_filter_registry(),
-            hcm.http_filters, args_);
-    if (!filter_configs.ok()) return filter_configs.status();
-    for (const auto& [name, config] : filter_configs->per_filter_configs) {
-      config_parts.emplace_back(absl::StrCat(
-          "  \"", name, "\": [\n", absl::StrJoin(config, ",\n"), "\n  ]"));
-    }
-    args = filter_configs->args;
-  }
   std::string json = absl::StrCat("{", absl::StrJoin(config_parts, ",\n"), "}");
   return ServiceConfigImpl::Create(args, json.c_str());
 }

data/src/core/server/server.cc

@@ -685,6 +685,12 @@ class Server::RealRequestMatcher : public RequestMatcherInterface {
         }
       }
       if (rc == nullptr) {
+        if (IsOptimization04Enabled() &&
+            server_->pending_backlog_protector_.Reject(
+                pending_filter_stack_.size(), SharedBitGen())) {
+          calld->FailCallCreation();
+          return;
+        }
         calld->SetState(CallData::CallState::PENDING);
         pending_filter_stack_.push(PendingCallFilterStack{calld});
         return;
@@ -1139,9 +1145,15 @@ auto Server::MatchAndPublishCall(CallHandler call_handler) {
           auto md = std::move(std::get<2>(r));
           auto* rc = mr.TakeCall();
           rc->Complete(std::move(std::get<0>(r)), *md);
-          grpc_call* call =
-              MakeServerCall(call_handler, std::move(md), this,
-                             rc->cq_bound_to_call, rc->initial_metadata);
+          RefCountedPtr<Arena> parent_arena = nullptr;
+          Arena* raw_arena = channel_args_.GetPointer<Arena>(
+              GRPC_ARG_SERVER_INTERNAL_PARENT_CALL_ARENA);
+          if (raw_arena != nullptr) {
+            parent_arena = raw_arena->Ref();
+          }
+          grpc_call* call = MakeServerCall(
+              call_handler, std::move(md), this, rc->cq_bound_to_call,
+              rc->initial_metadata, std::move(parent_arena));
           *rc->call = call;
           return Map(WaitForCqEndOp(false, rc->tag, absl::OkStatus(), mr.cq()),
                      [rc = std::unique_ptr<RequestedCall>(rc)](Empty) {
@@ -1175,6 +1187,7 @@ Server::Server(const ChannelArgs& args)
                          ? nullptr
                          : channelz::DataSource::channelz_node()
                                ->RefAsSubclass<channelz::ServerNode>()),
+      config_fetcher_(channel_args_.GetObjectRef<ServerConfigFetcher>()),
       server_call_tracer_factory_(ServerCallTracerFactory::Get(channel_args_)),
       compression_options_(CompressionOptionsFromChannelArgs(channel_args_)),
       max_time_in_pending_queue_(Duration::Seconds(
@@ -1357,10 +1370,18 @@ grpc_error_handle Server::SetupTransport(
       socket_node->AddParent(channelz_node_.get());
     }
 
-    // Initialize chand.
+    // Keep a local reference to the channel alive during setup to prevent
+    // premature destruction if the transport fails concurrently.
+    RefCountedPtr<Channel> channel_keep_alive = *channel;
     chand->InitTransport(Ref(), std::move(*channel), cq_idx, transport,
                          channelz_socket_uuid);
 
+    auto* parent_arena =
+        args.GetPointer<Arena>(GRPC_ARG_SERVER_INTERNAL_PARENT_CALL_ARENA);
+    if (parent_arena != nullptr) {
+      chand->set_parent_arena(parent_arena->Ref());
+    }
+
     stream_quota_->IncrementOpenChannels();
   }
   return absl::OkStatus();
@@ -1805,6 +1826,13 @@ void Server::ChannelData::AcceptStream(void* arg, Transport* /*transport*/,
   args.send_deadline = Timestamp::InfFuture();
   grpc_call* call;
   grpc_error_handle error = grpc_call_create(&args, &call);
+
+  if (chand->parent_arena() != nullptr && call != nullptr) {
+    auto* call_arena = grpc_call_get_arena(call);
+    auto* parent_link = call_arena->New<ParentCallContext>();
+    parent_link->arena = chand->parent_arena()->Ref();
+    call_arena->SetContext<ParentCallContext>(parent_link);
+  }
   grpc_call_stack* call_stack = grpc_call_get_call_stack(call);
   GRPC_CHECK_NE(call_stack, nullptr);
   grpc_call_element* elem = grpc_call_stack_element(call_stack, 0);
@@ -2242,22 +2270,16 @@ grpc_call_error grpc_server_request_registered_call(
       cq_for_notification, tag_new);
 }
 
-void grpc_server_set_config_fetcher(
-    grpc_server* server, grpc_server_config_fetcher* server_config_fetcher) {
-  grpc_core::ExecCtx exec_ctx;
-  GRPC_TRACE_LOG(api, INFO)
-      << "grpc_server_set_config_fetcher(server=" << server
-      << ", config_fetcher=" << server_config_fetcher << ")";
-  grpc_core::Server::FromC(server)->set_config_fetcher(
-      std::unique_ptr<grpc_core::ServerConfigFetcher>(
-          grpc_core::ServerConfigFetcher::FromC(server_config_fetcher)));
-}
-
-void grpc_server_config_fetcher_destroy(
+void grpc_server_config_fetcher_unref(
     grpc_server_config_fetcher* server_config_fetcher) {
   grpc_core::ExecCtx exec_ctx;
   GRPC_TRACE_LOG(api, INFO)
-      << "grpc_server_config_fetcher_destroy(config_fetcher="
+      << "grpc_server_config_fetcher_unref(config_fetcher="
       << server_config_fetcher << ")";
-  delete grpc_core::ServerConfigFetcher::FromC(server_config_fetcher);
+  grpc_core::ServerConfigFetcher::FromC(server_config_fetcher)->Unref();
+}
+
+const grpc_arg_pointer_vtable* grpc_server_config_fetcher_arg_vtable(void) {
+  return grpc_core::ChannelArgTypeTraits<
+      grpc_core::ServerConfigFetcher>::VTable();
 }

data/src/core/server/server.h

@@ -52,6 +52,7 @@
 #include "src/core/lib/resource_quota/connection_quota.h"
 #include "src/core/lib/resource_quota/stream_quota.h"
 #include "src/core/lib/slice/slice.h"
+#include "src/core/lib/surface/call.h"
 #include "src/core/lib/surface/channel.h"
 #include "src/core/lib/surface/completion_queue.h"
 #include "src/core/lib/transport/transport.h"
@@ -75,18 +76,19 @@
 #define GRPC_ARG_SERVER_MAX_PENDING_REQUESTS "grpc.server.max_pending_requests"
 #define GRPC_ARG_SERVER_MAX_PENDING_REQUESTS_HARD_LIMIT \
   "grpc.server.max_pending_requests_hard_limit"
+#define GRPC_ARG_SERVER_INTERNAL_PARENT_CALL_ARENA \
+  "grpc.internal.parent_call_arena"
 
 namespace grpc_core {
 
 class ServerConfigFetcher
-    : public CppImplOf<ServerConfigFetcher, grpc_server_config_fetcher> {
+    : public CppImplOf<ServerConfigFetcher, grpc_server_config_fetcher>,
+      public RefCounted<ServerConfigFetcher> {
  public:
-  class ConnectionManager
-      : public grpc_core::DualRefCounted<ConnectionManager> {
+  class ConnectionManager : public DualRefCounted<ConnectionManager> {
    public:
-    virtual absl::StatusOr<grpc_core::ChannelArgs>
-    UpdateChannelArgsForConnection(const grpc_core::ChannelArgs& args,
-                                   grpc_endpoint* tcp) = 0;
+    virtual absl::StatusOr<ChannelArgs> UpdateChannelArgsForConnection(
+        const ChannelArgs& args, grpc_endpoint* tcp) = 0;
   };
 
   class WatcherInterface {
@@ -96,18 +98,24 @@ class ServerConfigFetcher
     // config is available. Implementations should update the connection manager
     // and start serving if not already serving.
     virtual void UpdateConnectionManager(
-        grpc_core::RefCountedPtr<ConnectionManager> manager) = 0;
+        RefCountedPtr<ConnectionManager> manager) = 0;
     // Implementations should stop serving when this is called. Serving should
     // only resume when UpdateConfig() is invoked.
     virtual void StopServing() = 0;
   };
 
-  virtual ~ServerConfigFetcher() = default;
-
   virtual void StartWatch(std::string listening_address,
                           std::unique_ptr<WatcherInterface> watcher) = 0;
   virtual void CancelWatch(WatcherInterface* watcher) = 0;
   virtual grpc_pollset_set* interested_parties() = 0;
+
+  static absl::string_view ChannelArgName() {
+    return GRPC_ARG_SERVER_CONFIG_FETCHER;
+  }
+  static int ChannelArgsCompare(const ServerConfigFetcher* a,
+                                const ServerConfigFetcher* b) {
+    return QsortCompare(a, b);
+  }
 };
 
 namespace experimental {
@@ -340,10 +348,6 @@ class Server : public ServerInterface,
     return server_call_tracer_factory_;
   }
 
-  void set_config_fetcher(std::unique_ptr<ServerConfigFetcher> config_fetcher) {
-    config_fetcher_ = std::move(config_fetcher);
-  }
-
   bool HasOpenConnections() ABSL_LOCKS_EXCLUDED(mu_global_);
 
   // Adds a listener to the server.  When the server starts, it will call
@@ -444,6 +448,11 @@ class Server : public ServerInterface,
     Channel* channel() const { return channel_.get(); }
     size_t cq_idx() const { return cq_idx_; }
 
+    RefCountedPtr<Arena> parent_arena() const { return parent_arena_; }
+    void set_parent_arena(RefCountedPtr<Arena> parent_arena) {
+      parent_arena_ = std::move(parent_arena);
+    }
+
     // Filter vtable functions.
     static grpc_error_handle InitChannelElement(
         grpc_channel_element* elem, grpc_channel_element_args* args);
@@ -467,6 +476,8 @@ class Server : public ServerInterface,
     std::optional<std::list<ChannelData*>::iterator> list_position_;
     grpc_closure finish_destroy_channel_closure_;
     intptr_t channelz_socket_uuid_;
+
+    RefCountedPtr<Arena> parent_arena_;
   };
 
   class CallData {
@@ -657,7 +668,7 @@ class Server : public ServerInterface,
 
   ChannelArgs const channel_args_;
   RefCountedPtr<channelz::ServerNode> channelz_node_;
-  std::unique_ptr<ServerConfigFetcher> config_fetcher_;
+  RefCountedPtr<ServerConfigFetcher> config_fetcher_;
   ServerCallTracerFactory* const server_call_tracer_factory_;
 
   std::vector<grpc_completion_queue*> cqs_;

data/src/core/server/server_config_selector_filter.cc

@@ -46,6 +46,128 @@ namespace grpc_core {
 
 namespace {
 
+class LegacyServerConfigSelectorFilter final
+    : public ImplementChannelFilter<LegacyServerConfigSelectorFilter>,
+      public InternallyRefCounted<LegacyServerConfigSelectorFilter> {
+ public:
+  explicit LegacyServerConfigSelectorFilter(
+      RefCountedPtr<ServerConfigSelectorProvider>
+          server_config_selector_provider);
+
+  static absl::string_view TypeName() {
+    return "server_config_selector_filter";
+  }
+
+  LegacyServerConfigSelectorFilter(const LegacyServerConfigSelectorFilter&) =
+      delete;
+  LegacyServerConfigSelectorFilter& operator=(
+      const LegacyServerConfigSelectorFilter&) = delete;
+
+  static absl::StatusOr<OrphanablePtr<LegacyServerConfigSelectorFilter>> Create(
+      const ChannelArgs& args, ChannelFilter::Args);
+
+  void Orphan() override;
+
+  class Call {
+   public:
+    absl::Status OnClientInitialMetadata(
+        ClientMetadata& md, LegacyServerConfigSelectorFilter* filter);
+    static inline const NoInterceptor OnServerInitialMetadata;
+    static inline const NoInterceptor OnServerTrailingMetadata;
+    static inline const NoInterceptor OnClientToServerMessage;
+    static inline const NoInterceptor OnClientToServerHalfClose;
+    static inline const NoInterceptor OnServerToClientMessage;
+    static inline const NoInterceptor OnFinalize;
+  };
+
+  absl::StatusOr<RefCountedPtr<ServerConfigSelector>> config_selector() {
+    MutexLock lock(&mu_);
+    return config_selector_.value();
+  }
+
+ private:
+  class ServerConfigSelectorWatcher
+      : public ServerConfigSelectorProvider::ServerConfigSelectorWatcher {
+   public:
+    explicit ServerConfigSelectorWatcher(
+        RefCountedPtr<LegacyServerConfigSelectorFilter> filter)
+        : filter_(filter) {}
+    void OnServerConfigSelectorUpdate(
+        absl::StatusOr<RefCountedPtr<ServerConfigSelector>> update) override {
+      MutexLock lock(&filter_->mu_);
+      filter_->config_selector_ = std::move(update);
+    }
+
+   private:
+    RefCountedPtr<LegacyServerConfigSelectorFilter> filter_;
+  };
+
+  RefCountedPtr<ServerConfigSelectorProvider> server_config_selector_provider_;
+  Mutex mu_;
+  std::optional<absl::StatusOr<RefCountedPtr<ServerConfigSelector>>>
+      config_selector_ ABSL_GUARDED_BY(mu_);
+};
+
+absl::StatusOr<OrphanablePtr<LegacyServerConfigSelectorFilter>>
+LegacyServerConfigSelectorFilter::Create(const ChannelArgs& args,
+                                         ChannelFilter::Args) {
+  ServerConfigSelectorProvider* server_config_selector_provider =
+      args.GetObject<ServerConfigSelectorProvider>();
+  if (server_config_selector_provider == nullptr) {
+    return absl::UnknownError("No ServerConfigSelectorProvider object found");
+  }
+  return MakeOrphanable<LegacyServerConfigSelectorFilter>(
+      server_config_selector_provider->Ref());
+}
+
+LegacyServerConfigSelectorFilter::LegacyServerConfigSelectorFilter(
+    RefCountedPtr<ServerConfigSelectorProvider> server_config_selector_provider)
+    : server_config_selector_provider_(
+          std::move(server_config_selector_provider)) {
+  GRPC_CHECK(server_config_selector_provider_ != nullptr);
+  auto server_config_selector_watcher =
+      std::make_unique<ServerConfigSelectorWatcher>(Ref());
+  auto config_selector = server_config_selector_provider_->Watch(
+      std::move(server_config_selector_watcher));
+  MutexLock lock(&mu_);
+  // It's possible for the watcher to have already updated config_selector_
+  if (!config_selector_.has_value()) {
+    config_selector_ = std::move(config_selector);
+  }
+}
+
+void LegacyServerConfigSelectorFilter::Orphan() {
+  if (server_config_selector_provider_ != nullptr) {
+    server_config_selector_provider_->CancelWatch();
+  }
+  Unref();
+}
+
+absl::Status LegacyServerConfigSelectorFilter::Call::OnClientInitialMetadata(
+    ClientMetadata& md, LegacyServerConfigSelectorFilter* filter) {
+  GRPC_LATENT_SEE_SCOPE(
+      "LegacyServerConfigSelectorFilter::Call::OnClientInitialMetadata");
+  auto sel = filter->config_selector();
+  if (!sel.ok()) return sel.status();
+  auto call_config = sel.value()->GetCallConfig(&md);
+  if (!call_config.ok()) {
+    return absl::UnavailableError(StatusToString(call_config.status()));
+  }
+  auto* service_config_call_data =
+      GetContext<Arena>()->New<ServiceConfigCallData>(GetContext<Arena>());
+  service_config_call_data->SetServiceConfig(
+      std::move(call_config->service_config), call_config->method_configs);
+  return absl::OkStatus();
+}
+
+}  // namespace
+
+const grpc_channel_filter kLegacyServerConfigSelectorFilter =
+    MakePromiseBasedFilter<LegacyServerConfigSelectorFilter,
+                           FilterEndpoint::kServer>();
+
+namespace {
+
 class ServerConfigSelectorFilter final
     : public ImplementChannelFilter<ServerConfigSelectorFilter>,
       public InternallyRefCounted<ServerConfigSelectorFilter> {