grpc 1.81.1 → 1.83.1

data/src/core/load_balancing/xds/cds.cc

@@ -19,7 +19,6 @@
 #include <grpc/grpc_security.h>
 #include <grpc/impl/connectivity_state.h>
 #include <grpc/support/json.h>
-#include <grpc/support/port_platform.h>
 
 #include <algorithm>
 #include <map>
@@ -34,6 +33,7 @@
 
 #include "src/core/client_channel/client_channel_internal.h"
 #include "src/core/config/core_configuration.h"
+#include "src/core/config/experiment_env_var.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/iomgr/pollset_set.h"
@@ -43,10 +43,10 @@
 #include "src/core/load_balancing/lb_policy_factory.h"
 #include "src/core/load_balancing/lb_policy_registry.h"
 #include "src/core/load_balancing/outlier_detection/outlier_detection.h"
+#include "src/core/load_balancing/pick_first/pick_first.h"
 #include "src/core/load_balancing/xds/xds_channel_args.h"
 #include "src/core/resolver/xds/xds_dependency_manager.h"
 #include "src/core/util/debug_location.h"
-#include "src/core/util/env.h"
 #include "src/core/util/grpc_check.h"
 #include "src/core/util/json/json.h"
 #include "src/core/util/json/json_args.h"
@@ -165,11 +165,8 @@ namespace {
 
 // TODO(roth): Remove this after the 1.63 release.
 bool XdsAggregateClusterBackwardCompatibilityEnabled() {
-  auto value = GetEnv("GRPC_XDS_AGGREGATE_CLUSTER_BACKWARD_COMPAT");
-  if (!value.has_value()) return false;
-  bool parsed_value;
-  bool parse_succeeded = gpr_parse_bool_value(value->c_str(), &parsed_value);
-  return parse_succeeded && parsed_value;
+  return IsExperimentEnvVarEnabled(
+      "GRPC_XDS_AGGREGATE_CLUSTER_BACKWARD_COMPAT");
 }
 
 constexpr absl::string_view kCds = "cds_experimental";
@@ -317,54 +314,6 @@ std::string MakeChildPolicyName(absl::string_view cluster,
                       "}");
 }
 
-class PriorityEndpointIterator final : public EndpointAddressesIterator {
- public:
-  PriorityEndpointIterator(
-      RefCountedStringValue cluster_name, bool use_http_connect,
-      std::shared_ptr<const XdsEndpointResource> endpoints,
-      std::vector<size_t /*child_number*/> priority_child_numbers)
-      : cluster_name_(std::move(cluster_name)),
-        use_http_connect_(use_http_connect),
-        endpoints_(std::move(endpoints)),
-        priority_child_numbers_(std::move(priority_child_numbers)) {}
-
-  void ForEach(absl::FunctionRef<void(const EndpointAddresses&)> callback)
-      const override {
-    const auto& priority_list = GetUpdatePriorityList(endpoints_.get());
-    for (size_t priority = 0; priority < priority_list.size(); ++priority) {
-      const auto& priority_entry = priority_list[priority];
-      std::string priority_child_name = MakeChildPolicyName(
-          cluster_name_.as_string_view(), priority_child_numbers_[priority]);
-      for (const auto& [locality_name, locality] : priority_entry.localities) {
-        std::vector<RefCountedStringValue> hierarchical_path = {
-            RefCountedStringValue(priority_child_name),
-            locality_name->human_readable_string()};
-        auto hierarchical_path_attr =
-            MakeRefCounted<HierarchicalPathArg>(std::move(hierarchical_path));
-        for (const auto& endpoint : locality.endpoints) {
-          uint32_t endpoint_weight =
-              locality.lb_weight *
-              endpoint.args().GetInt(GRPC_ARG_ADDRESS_WEIGHT).value_or(1);
-          ChannelArgs args =
-              endpoint.args()
-                  .SetObject(hierarchical_path_attr)
-                  .Set(GRPC_ARG_ADDRESS_WEIGHT, endpoint_weight)
-                  .SetObject(locality_name->Ref())
-                  .Set(GRPC_ARG_XDS_LOCALITY_WEIGHT, locality.lb_weight);
-          if (!use_http_connect_) args = args.Remove(GRPC_ARG_XDS_HTTP_PROXY);
-          callback(EndpointAddresses(endpoint.addresses(), args));
-        }
-      }
-    }
-  }
-
- private:
-  RefCountedStringValue cluster_name_;
-  bool use_http_connect_;
-  std::shared_ptr<const XdsEndpointResource> endpoints_;
-  std::vector<size_t /*child_number*/> priority_child_numbers_;
-};
-
 absl::Status CdsLb::UpdateLocked(UpdateArgs args) {
   // Get new config.
   auto new_config = args.config.TakeAsSubclass<CdsLbConfig>();
@@ -491,7 +440,7 @@ absl::Status CdsLb::UpdateLocked(UpdateArgs args) {
         // Compute new child numbers.
         child_name_state_.Update(old_cluster_config, endpoint_config);
         // Populate addresses and resolution_note for child policy.
-        update_args.addresses = std::make_shared<PriorityEndpointIterator>(
+        update_args.addresses = std::make_shared<CdsPriorityEndpointIterator>(
             cluster_name_, new_cluster_config->cluster->use_http_connect,
             endpoint_config.endpoints,
             child_name_state_.priority_child_numbers());
@@ -752,6 +701,81 @@ class CdsLbFactory final : public LoadBalancingPolicyFactory {
 
 }  // namespace
 
+CdsPriorityEndpointIterator::CdsPriorityEndpointIterator(
+    RefCountedStringValue cluster_name, bool use_http_connect,
+    std::shared_ptr<const XdsEndpointResource> endpoints,
+    std::vector<size_t /*child_number*/> priority_child_numbers)
+    : cluster_name_(std::move(cluster_name)),
+      use_http_connect_(use_http_connect),
+      endpoints_(std::move(endpoints)),
+      priority_child_numbers_(std::move(priority_child_numbers)) {}
+
+void CdsPriorityEndpointIterator::ForEach(
+    absl::FunctionRef<void(const EndpointAddresses&)> callback) const {
+  const auto& priority_list = GetUpdatePriorityList(endpoints_.get());
+  bool weighted_shuffling_enabled = PfWeightedShufflingEnabled();
+  for (size_t priority = 0; priority < priority_list.size(); ++priority) {
+    const auto& priority_entry = priority_list[priority];
+    std::string priority_child_name = MakeChildPolicyName(
+        cluster_name_.as_string_view(), priority_child_numbers_[priority]);
+    uint64_t locality_weight_sum = 0;
+    if (weighted_shuffling_enabled) {
+      for (const auto& [_, locality] : priority_entry.localities) {
+        locality_weight_sum += locality.lb_weight;
+      }
+      // This should never happen because the resource parsing code will strip
+      // out any localities with weight 0. However, we check this defensively.
+      if (locality_weight_sum == 0) locality_weight_sum = 1;
+    }
+    for (const auto& [locality_name, locality] : priority_entry.localities) {
+      uint32_t normalized_locality_weight = 1;
+      uint64_t endpoint_weight_sum = 0;
+      if (weighted_shuffling_enabled) {
+        normalized_locality_weight =
+            (locality.lb_weight * (uint64_t(1) << 31)) / locality_weight_sum;
+        for (const auto& endpoint : locality.endpoints) {
+          int weight =
+              endpoint.args().GetInt(GRPC_ARG_ADDRESS_WEIGHT).value_or(1);
+          endpoint_weight_sum += weight <= 0 ? 1 : weight;
+        }
+        // This should never happen because the resource validation code will
+        // reject the resource if any endpoint has weight 0. However, we check
+        // this defensively.
+        if (endpoint_weight_sum == 0) endpoint_weight_sum = 1;
+      }
+      std::vector<RefCountedStringValue> hierarchical_path = {
+          RefCountedStringValue(priority_child_name),
+          locality_name->human_readable_string()};
+      auto hierarchical_path_attr =
+          MakeRefCounted<HierarchicalPathArg>(std::move(hierarchical_path));
+      for (const auto& endpoint : locality.endpoints) {
+        int weight_arg =
+            endpoint.args().GetInt(GRPC_ARG_ADDRESS_WEIGHT).value_or(1);
+        uint32_t raw_endpoint_weight = weight_arg <= 0 ? 1 : weight_arg;
+        uint32_t endpoint_weight;
+        if (weighted_shuffling_enabled) {
+          uint32_t normalized_endpoint_weight =
+              (raw_endpoint_weight * (uint64_t(1) << 31)) / endpoint_weight_sum;
+          endpoint_weight = (uint64_t(normalized_locality_weight) *
+                             normalized_endpoint_weight) >>
+                            31;
+          if (endpoint_weight == 0) endpoint_weight = 1;
+        } else {
+          endpoint_weight = locality.lb_weight * raw_endpoint_weight;
+        }
+        ChannelArgs args =
+            endpoint.args()
+                .SetObject(hierarchical_path_attr)
+                .Set(GRPC_ARG_ADDRESS_WEIGHT, endpoint_weight)
+                .SetObject(locality_name->Ref())
+                .Set(GRPC_ARG_XDS_LOCALITY_WEIGHT, locality.lb_weight);
+        if (!use_http_connect_) args = args.Remove(GRPC_ARG_XDS_HTTP_PROXY);
+        callback(EndpointAddresses(endpoint.addresses(), args));
+      }
+    }
+  }
+}
+
 void RegisterCdsLbPolicy(CoreConfiguration::Builder* builder) {
   builder->lb_policy_registry()->RegisterLoadBalancingPolicyFactory(
       std::make_unique<CdsLbFactory>());

data/src/core/load_balancing/xds/cds.h

@@ -17,9 +17,13 @@
 #ifndef GRPC_SRC_CORE_LOAD_BALANCING_XDS_CDS_H
 #define GRPC_SRC_CORE_LOAD_BALANCING_XDS_CDS_H
 
+#include <memory>
 #include <vector>
 
+#include "src/core/resolver/endpoint_addresses.h"
 #include "src/core/resolver/xds/xds_config.h"
+#include "src/core/util/ref_counted_string.h"
+#include "src/core/xds/grpc/xds_endpoint.h"
 
 namespace grpc_core {
 
@@ -53,6 +57,23 @@ class CdsChildNameState {
   size_t next_available_child_number_ = 0;
 };
 
+class CdsPriorityEndpointIterator final : public EndpointAddressesIterator {
+ public:
+  CdsPriorityEndpointIterator(
+      RefCountedStringValue cluster_name, bool use_http_connect,
+      std::shared_ptr<const XdsEndpointResource> endpoints,
+      std::vector<size_t /*child_number*/> priority_child_numbers);
+
+  void ForEach(absl::FunctionRef<void(const EndpointAddresses&)> callback)
+      const override;
+
+ private:
+  RefCountedStringValue cluster_name_;
+  bool use_http_connect_;
+  std::shared_ptr<const XdsEndpointResource> endpoints_;
+  std::vector<size_t /*child_number*/> priority_child_numbers_;
+};
+
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_LOAD_BALANCING_XDS_CDS_H

data/src/core/mitigation_engine/mitigation.h

@@ -0,0 +1,53 @@
+//
+//
+// 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_H
+#define GRPC_SRC_CORE_MITIGATION_ENGINE_MITIGATION_H
+
+#include <optional>
+
+#include "src/core/call/metadata_batch.h"
+#include "src/core/mitigation_engine/mitigation_engine.h"
+#include "src/core/util/ref_counted.h"
+#include "absl/strings/string_view.h"
+
+namespace grpc_core {
+
+// Mitigations represent read-only configuration rules.
+class Mitigation : public RefCounted<Mitigation> {
+ public:
+  ~Mitigation() override = default;
+
+  virtual std::optional<MitigationEngine::Action>
+  EvaluateIncomingMetadataParsed(absl::string_view key,
+                                 absl::string_view value) const = 0;
+  virtual std::optional<MitigationEngine::Action>
+  EvaluateIncomingMetadataAllParsed(
+      const grpc_metadata_batch& metadata) const = 0;
+
+  Mitigation() = default;
+  // Not movable or copyable.
+  Mitigation(Mitigation&&) = delete;
+  Mitigation& operator=(Mitigation&&) = delete;
+  Mitigation(const Mitigation&) = delete;
+  Mitigation& operator=(const Mitigation&) = delete;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_MITIGATION_ENGINE_MITIGATION_H

data/src/core/mitigation_engine/mitigation_engine.h

@@ -0,0 +1,81 @@
+//
+//
+// 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_ENGINE_H
+#define GRPC_SRC_CORE_MITIGATION_ENGINE_MITIGATION_ENGINE_H
+
+#include <optional>
+
+#include "src/core/call/metadata_batch.h"
+#include "src/core/util/dual_ref_counted.h"
+#include "src/core/util/ref_counted.h"
+#include "src/core/util/ref_counted_ptr.h"
+#include "src/core/util/useful.h"
+#include "absl/strings/string_view.h"
+
+namespace grpc_core {
+
+class MitigationEngine : public RefCounted<MitigationEngine> {
+ public:
+  enum class Action { kCloseConnection, kRejectRpc };
+  static absl::string_view ActionToString(Action action) {
+    switch (action) {
+      case Action::kCloseConnection:
+        return "Close Connection";
+      case Action::kRejectRpc:
+        return "Reject RPC";
+    }
+    return "Unknown Action";
+  }
+  ~MitigationEngine() override = default;
+  // Evaluates an incoming connection based on the peer address.
+  virtual std::optional<Action> EvaluateIncomingConnection(
+      absl::string_view peer_address) = 0;
+  // Evaluates an incoming metadata key/value pair. Please note that this
+  // function only evaluates *new* key/value pairs; if an incoming header has
+  // already been seen by the connection, it will not be evaluated again.
+  virtual std::optional<Action> EvaluateIncomingMetadata(
+      absl::string_view key, absl::string_view value) = 0;
+  // Evaluates all incoming metadata after they have been parsed.
+  virtual std::optional<Action> EvaluateAllIncomingMetadata(
+      const grpc_metadata_batch& metadata) = 0;
+};
+
+class MitigationEngineProvider
+    : public DualRefCounted<MitigationEngineProvider> {
+ public:
+  static absl::string_view ChannelArgName() {
+    return "grpc.internal.mitigation_engine_provider";
+  }
+
+  static int ChannelArgsCompare(const MitigationEngineProvider* a,
+                                const MitigationEngineProvider* b) {
+    return QsortCompare(a, b);
+  }
+
+  // Returns a reference to the current MitigationEngine, or nullptr if none
+  // is configured. An old engine will not be destroyed until all references
+  // to it are dropped.
+  virtual RefCountedPtr<MitigationEngine> GetEngine() = 0;
+
+  void Orphaned() override {}
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_MITIGATION_ENGINE_MITIGATION_ENGINE_H

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/plugin_registry/grpc_plugin_registry.cc

@@ -53,7 +53,6 @@ extern void RegisterServiceConfigChannelArgFilter(
     CoreConfiguration::Builder* builder);
 extern void RegisterExtraFilters(CoreConfiguration::Builder* builder);
 extern void RegisterResourceQuota(CoreConfiguration::Builder* builder);
-extern void FaultInjectionFilterRegister(CoreConfiguration::Builder* builder);
 extern void RegisterDnsResolver(CoreConfiguration::Builder* builder);
 extern void RegisterBackendMetricFilter(CoreConfiguration::Builder* builder);
 extern void RegisterSockaddrResolver(CoreConfiguration::Builder* builder);
@@ -127,7 +126,6 @@ void BuildCoreConfiguration(CoreConfiguration::Builder* builder) {
   RegisterMessageSizeFilter(builder);
   RegisterServiceConfigChannelArgFilter(builder);
   RegisterResourceQuota(builder);
-  FaultInjectionFilterRegister(builder);
   RegisterDnsResolver(builder);
   RegisterSockaddrResolver(builder);
   RegisterFakeResolver(builder);

data/src/core/plugin_registry/grpc_plugin_registry_extra.cc

@@ -22,9 +22,6 @@
 namespace grpc_core {
 #ifndef GRPC_NO_XDS
 extern void RbacFilterRegister(CoreConfiguration::Builder* builder);
-extern void StatefulSessionFilterRegister(CoreConfiguration::Builder* builder);
-extern void GcpAuthenticationFilterRegister(
-    CoreConfiguration::Builder* builder);
 extern void RegisterXdsChannelStackModifier(
     CoreConfiguration::Builder* builder);
 extern void RegisterChannelDefaultCreds(CoreConfiguration::Builder* builder);
@@ -49,8 +46,6 @@ void RegisterExtraFilters(CoreConfiguration::Builder* builder) {
   // rbac_filter is being guarded with GRPC_NO_XDS to avoid a dependency on the
   // re2 library by default
   RbacFilterRegister(builder);
-  StatefulSessionFilterRegister(builder);
-  GcpAuthenticationFilterRegister(builder);
   RegisterXdsChannelStackModifier(builder);
   RegisterChannelDefaultCreds(builder);
   RegisterDefaultCallCreds(builder);

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>());