grpc 1.81.1 → 1.83.0

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,31 +417,20 @@ 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(
-      hcm.http_filters, http_filter_registry, *xds_config.virtual_host, builder,
+  XdsRouting::RouteConfigFilterChainBuilder route_config_builder(
+      hcm.http_filters, http_filter_registry, builder,
       [](FilterChainBuilder& builder) {
         builder.AddFilter<ClusterSelectionFilter>(nullptr);
       },
-      old_blackboard, new_blackboard);
+      blackboard);
+  auto vhost_builder = route_config_builder.MakeVirtualHostFilterChainBuilder(
+      *xds_config.virtual_host);
   // Set the filter chain for each route.
   for (auto& route_entry : routes_) {
     const auto* route_action =
@@ -468,29 +443,28 @@ void XdsResolver::RouteConfigData::BuildFilterChains(
             XdsRouteConfigResource::Route::RouteAction::ClusterWeight>>(
             &route_action->action);
         weighted_clusters != nullptr) {
-      per_route_builder.BuildFilterChainForRouteWithWeightedClusters(
-          route_entry.route,
-          [&](size_t index,
-              absl::StatusOr<RefCountedPtr<const FilterChain>> filter_chain) {
-            GRPC_CHECK_LT(index, route_entry.weighted_cluster_state.size());
-            route_entry.weighted_cluster_state[index].filter_chain =
-                std::move(filter_chain);
-          });
+      auto weighted_cluster_builder =
+          vhost_builder.MakeWeightedClusterRouteFilterChainBuilder(
+              route_entry.route);
+      for (size_t i = 0; i < weighted_clusters->size(); ++i) {
+        GRPC_CHECK_LT(i, route_entry.weighted_cluster_state.size());
+        route_entry.weighted_cluster_state[i].filter_chain =
+            weighted_cluster_builder.BuildFilterChainForClusterWeight(
+                (*weighted_clusters)[i]);
+      }
     }
     // If the route does not use WeightedClusters, then we generate a
     // filter chain for the route.
     else {
       route_entry.filter_chain =
-          per_route_builder.BuildFilterChainForRoute(route_entry.route);
+          vhost_builder.BuildFilterChainForRoute(route_entry.route);
     }
   }
 }
 
 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 +512,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 +524,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 +553,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 +572,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 +581,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 +658,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 +666,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 +694,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 +702,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 +737,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 +750,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 +970,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"
@@ -72,21 +73,19 @@
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 
-#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 +95,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.
+    // only resume when UpdateConnectionManager() 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 +345,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 +445,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 +473,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 +665,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.h

@@ -62,11 +62,12 @@ class ServerConfigSelectorProvider
         absl::StatusOr<RefCountedPtr<ServerConfigSelector>> update) = 0;
   };
 
-  ~ServerConfigSelectorProvider() override = default;
-  // Only a single watcher is allowed at present
+  // TODO(roth): Change this to return void after removing
+  // xds_server_filter_chain_per_route experiment.
   virtual absl::StatusOr<RefCountedPtr<ServerConfigSelector>> Watch(
-      std::unique_ptr<ServerConfigSelectorWatcher> watcher) = 0;
-  virtual void CancelWatch() = 0;
+      std::shared_ptr<ServerConfigSelectorWatcher> watcher) = 0;
+  virtual void CancelWatch(
+      std::shared_ptr<ServerConfigSelectorWatcher> watcher) = 0;
 
   static absl::string_view ChannelArgName() {
     return "grpc.internal.server_config_selector_provider";