grpc 1.82.0 → 1.83.0.pre1

data/src/core/mitigation_engine/mitigation_provider.h

@@ -0,0 +1,62 @@
+//
+//
+// 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_MITIGATION_ENGINE_MITIGATION_PROVIDER_H
+#define GRPC_SRC_CORE_MITIGATION_ENGINE_MITIGATION_PROVIDER_H
+
+#include <cstdint>
+#include <vector>
+
+#include "src/core/mitigation_engine/mitigation.h"
+#include "src/core/util/ref_counted_ptr.h"
+#include "absl/functional/any_invocable.h"
+
+namespace grpc_core {
+
+// Opaque handle for unsubscription.
+struct MitigationSubscriptionHandle {
+  uintptr_t id = 0;
+  bool operator==(const MitigationSubscriptionHandle& other) const = default;
+};
+
+class MitigationProvider {
+ public:
+  virtual ~MitigationProvider() = default;
+
+  // Subscribes to mitigation configuration updates.
+  //
+  // The provided callback is invoked whenever the mitigation rules change.
+  //
+  // Returns an opaque MitigationSubscriptionHandle to be used as an
+  // unsubscription token for CancelWatch().
+  //
+  // Mitigations are passed as RefCountedPtrs to enable efficient shared
+  // ownership of the read-only rules among all listeners, avoiding costly
+  // deep copies during config updates.
+  virtual MitigationSubscriptionHandle ListenForMitigations(
+      absl::AnyInvocable<void(std::vector<RefCountedPtr<Mitigation>>)>
+          new_mitigations) = 0;
+
+  // Unsubscribes a previously registered callback using its original
+  // MitigationSubscriptionHandle token.
+  virtual void CancelWatch(MitigationSubscriptionHandle handle) = 0;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_MITIGATION_ENGINE_MITIGATION_PROVIDER_H

data/src/core/resolver/dns/dns_resolver_plugin.cc

@@ -36,12 +36,7 @@ void RegisterDnsResolver(CoreConfiguration::Builder* builder) {
       std::make_unique<EventEngineClientChannelDNSResolverFactory>());
   return;
 #endif
-#ifdef GRPC_PYTHON_BUILD
-  bool use_ee = IsEventEnginePollerForPythonEnabled();
-#else   // GRPC_PYTHON_BUILD
-  bool use_ee = true;
-#endif  // GRPC_PYTHON_BUILD
-  if (use_ee && IsEventEngineDnsEnabled()) {
+  if (IsEventEngineDnsEnabled()) {
     VLOG(2) << "Using EventEngine dns resolver";
     builder->resolver_registry()->RegisterResolverFactory(
         std::make_unique<EventEngineClientChannelDNSResolverFactory>());

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

@@ -423,12 +423,14 @@ void XdsResolver::RouteConfigData::BuildFilterChains(
     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);
       },
       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 =
@@ -441,20 +443,21 @@ 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);
     }
   }
 }

data/src/core/server/server.h

@@ -73,9 +73,6 @@
 #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"
 
@@ -100,7 +97,7 @@ class ServerConfigFetcher
     virtual void UpdateConnectionManager(
         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;
   };
 

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";

data/src/core/server/server_config_selector_filter.cc

@@ -27,6 +27,7 @@
 #include "src/core/lib/event_engine/event_engine_context.h"
 #include "src/core/lib/promise/arena_promise.h"
 #include "src/core/lib/promise/context.h"
+#include "src/core/lib/promise/observable.h"
 #include "src/core/lib/promise/promise.h"
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/transport/transport.h"
@@ -37,7 +38,6 @@
 #include "src/core/util/latent_see.h"
 #include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/status_helper.h"
-#include "src/core/util/sync.h"
 #include "absl/base/thread_annotations.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
@@ -103,6 +103,7 @@ class LegacyServerConfigSelectorFilter final
   };
 
   RefCountedPtr<ServerConfigSelectorProvider> server_config_selector_provider_;
+  std::shared_ptr<ServerConfigSelectorWatcher> watcher_;
   Mutex mu_;
   std::optional<absl::StatusOr<RefCountedPtr<ServerConfigSelector>>>
       config_selector_ ABSL_GUARDED_BY(mu_);
@@ -125,10 +126,8 @@ LegacyServerConfigSelectorFilter::LegacyServerConfigSelectorFilter(
     : 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));
+  watcher_ = std::make_shared<ServerConfigSelectorWatcher>(Ref());
+  auto config_selector = server_config_selector_provider_->Watch(watcher_);
   MutexLock lock(&mu_);
   // It's possible for the watcher to have already updated config_selector_
   if (!config_selector_.has_value()) {
@@ -138,7 +137,7 @@ LegacyServerConfigSelectorFilter::LegacyServerConfigSelectorFilter(
 
 void LegacyServerConfigSelectorFilter::Orphan() {
   if (server_config_selector_provider_ != nullptr) {
-    server_config_selector_provider_->CancelWatch();
+    server_config_selector_provider_->CancelWatch(std::move(watcher_));
   }
   Unref();
 }
@@ -172,27 +171,10 @@ class ServerConfigSelectorFilter final
     : public ImplementChannelFilter<ServerConfigSelectorFilter>,
       public InternallyRefCounted<ServerConfigSelectorFilter> {
  public:
-  explicit ServerConfigSelectorFilter(
-      RefCountedPtr<ServerConfigSelectorProvider>
-          server_config_selector_provider);
-
-  static absl::string_view TypeName() {
-    return "server_config_selector_filter";
-  }
-
-  ServerConfigSelectorFilter(const ServerConfigSelectorFilter&) = delete;
-  ServerConfigSelectorFilter& operator=(const ServerConfigSelectorFilter&) =
-      delete;
-
-  static absl::StatusOr<OrphanablePtr<ServerConfigSelectorFilter>> Create(
-      const ChannelArgs& args, ChannelFilter::Args);
-
-  void Orphan() override;
-
   class Call {
    public:
-    absl::Status OnClientInitialMetadata(ClientMetadata& md,
-                                         ServerConfigSelectorFilter* filter);
+    ArenaPromise<absl::Status> OnClientInitialMetadata(
+        ClientMetadata& md, ServerConfigSelectorFilter* filter);
     static inline const NoInterceptor OnServerInitialMetadata;
     static inline const NoInterceptor OnServerTrailingMetadata;
     static inline const NoInterceptor OnClientToServerMessage;
@@ -201,9 +183,42 @@ class ServerConfigSelectorFilter final
     static inline const NoInterceptor OnFinalize;
   };
 
-  absl::StatusOr<RefCountedPtr<ServerConfigSelector>> config_selector() {
-    MutexLock lock(&mu_);
-    return config_selector_.value();
+  static absl::StatusOr<OrphanablePtr<ServerConfigSelectorFilter>> Create(
+      const ChannelArgs& args, ChannelFilter::Args) {
+    auto server_config_selector_provider =
+        args.GetObjectRef<ServerConfigSelectorProvider>();
+    if (server_config_selector_provider == nullptr) {
+      return absl::UnknownError("No ServerConfigSelectorProvider object found");
+    }
+    return MakeOrphanable<ServerConfigSelectorFilter>(
+        std::move(server_config_selector_provider));
+  }
+
+  explicit ServerConfigSelectorFilter(
+      RefCountedPtr<ServerConfigSelectorProvider>
+          server_config_selector_provider)
+      : server_config_selector_provider_(
+            std::move(server_config_selector_provider)),
+        config_selector_(nullptr) {
+    watcher_ = std::make_shared<ServerConfigSelectorWatcher>(Ref());
+    // TODO(roth): Remove the void cast when removing the
+    // xds_server_filter_chain_per_route experiment.
+    (void)server_config_selector_provider_->Watch(watcher_);
+  }
+
+  ServerConfigSelectorFilter(const ServerConfigSelectorFilter&) = delete;
+  ServerConfigSelectorFilter& operator=(const ServerConfigSelectorFilter&) =
+      delete;
+
+  void Orphan() override {
+    if (server_config_selector_provider_ != nullptr) {
+      server_config_selector_provider_->CancelWatch(std::move(watcher_));
+    }
+    Unref();
+  }
+
+  static absl::string_view TypeName() {
+    return "server_config_selector_filter";
   }
 
  private:
@@ -215,8 +230,8 @@ class ServerConfigSelectorFilter final
         : filter_(filter) {}
     void OnServerConfigSelectorUpdate(
         absl::StatusOr<RefCountedPtr<ServerConfigSelector>> update) override {
-      MutexLock lock(&filter_->mu_);
-      filter_->config_selector_ = std::move(update);
+      // TODO(roth): Build filter chains here.
+      filter_->config_selector_.Set(std::move(update));
     }
 
    private:
@@ -224,61 +239,33 @@ class ServerConfigSelectorFilter final
   };
 
   RefCountedPtr<ServerConfigSelectorProvider> server_config_selector_provider_;
-  Mutex mu_;
-  std::optional<absl::StatusOr<RefCountedPtr<ServerConfigSelector>>>
-      config_selector_ ABSL_GUARDED_BY(mu_);
+  std::shared_ptr<ServerConfigSelectorWatcher> watcher_;
+  Observable<absl::StatusOr<RefCountedPtr<ServerConfigSelector>>>
+      config_selector_;
 };
 
-absl::StatusOr<OrphanablePtr<ServerConfigSelectorFilter>>
-ServerConfigSelectorFilter::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<ServerConfigSelectorFilter>(
-      server_config_selector_provider->Ref());
-}
-
-ServerConfigSelectorFilter::ServerConfigSelectorFilter(
-    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 ServerConfigSelectorFilter::Orphan() {
-  if (server_config_selector_provider_ != nullptr) {
-    server_config_selector_provider_->CancelWatch();
-  }
-  Unref();
-}
-
-absl::Status ServerConfigSelectorFilter::Call::OnClientInitialMetadata(
+ArenaPromise<absl::Status>
+ServerConfigSelectorFilter::Call::OnClientInitialMetadata(
     ClientMetadata& md, ServerConfigSelectorFilter* filter) {
   GRPC_LATENT_SEE_SCOPE(
       "ServerConfigSelectorFilter::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();
+  return TrySeq(
+      filter->config_selector_.Next(nullptr),
+      [&md](
+          absl::StatusOr<RefCountedPtr<ServerConfigSelector>> config_selector) {
+        if (!config_selector.ok()) return config_selector.status();
+        auto call_config = (*config_selector)->GetCallConfig(&md);
+        if (!call_config.ok()) {
+          return absl::UnavailableError(StatusToString(call_config.status()));
+        }
+        auto* arena = GetContext<Arena>();
+        auto* service_config_call_data =
+            arena->New<ServiceConfigCallData>(arena);
+        service_config_call_data->SetServiceConfig(
+            std::move(call_config->service_config),
+            call_config->method_configs);
+        return absl::OkStatus();
+      });
 }
 
 }  // namespace