grpc 1.82.0 → 1.83.0.pre1

data/src/core/lib/transport/error_utils.cc

@@ -63,159 +63,47 @@ void grpc_error_get_status(grpc_error_handle error,
                            grpc_status_code* code, std::string* message,
                            Http2ErrorCode* http_error,
                            const char** error_string) {
-  if (grpc_core::IsErrorFlattenEnabled()) {
-    auto http_error_code = GetHttp2Error(error);
-    if (code != nullptr) {
-      // If the top-level status code is UNKNOWN and there is an HTTP2 error
-      // code attribute set, convert from that.  Otherwise, use the top-level
-      // status code.
-      if (error.code() == absl::StatusCode::kUnknown &&
-          http_error_code.has_value()) {
-        *code = grpc_http2_error_to_grpc_status(*http_error_code, deadline);
-      } else {
-        *code = static_cast<grpc_status_code>(error.code());
-      }
-    }
-    if (message != nullptr) *message = std::string(error.message());
-    if (error_string != nullptr && !error.ok()) {
-      *error_string = gpr_strdup(grpc_core::StatusToString(error).c_str());
-    }
-    if (http_error != nullptr) {
-      // If the HTTP2 error code attribute is present, use it.  Otherwise,
-      // if the status code is something other than UNKNOWN, convert from
-      // that.  Otherwise, set a default based on whether the status
-      // code is OK.
-      if (http_error_code.has_value()) {
-        *http_error = *http_error_code;
-      } else if (error.code() != absl::StatusCode::kUnknown) {
-        *http_error = grpc_status_to_http2_error(
-            static_cast<grpc_status_code>(error.code()));
-      } else {
-        *http_error = error.ok() ? Http2ErrorCode::kNoError
-                                 : Http2ErrorCode::kInternalError;
-      }
-    }
-    return;
-  }
-
-  // Fast path: We expect no error.
-  if (GPR_LIKELY(error.ok())) {
-    if (code != nullptr) *code = GRPC_STATUS_OK;
-    if (message != nullptr) {
-      // Normally, we call grpc_error_get_str(
-      //   error, grpc_core::StatusStrProperty::kGrpcMessage, message).
-      // We can fastpath since we know that:
-      // 1) Error is null
-      // 2) which == grpc_core::StatusStrProperty::kGrpcMessage
-      // 3) The resulting message is statically known.
-      // 4) Said resulting message is "".
-      // This means 3 movs, instead of 10s of instructions and a strlen.
-      *message = "";
-    }
-    if (http_error != nullptr) {
-      *http_error = Http2ErrorCode::kNoError;
+  auto http_error_code = GetHttp2Error(error);
+  if (code != nullptr) {
+    // If the top-level status code is UNKNOWN and there is an HTTP2 error
+    // code attribute set, convert from that.  Otherwise, use the top-level
+    // status code.
+    if (error.code() == absl::StatusCode::kUnknown &&
+        http_error_code.has_value()) {
+      *code = grpc_http2_error_to_grpc_status(*http_error_code, deadline);
+    } else {
+      *code = static_cast<grpc_status_code>(error.code());
     }
-    return;
   }
-
-  // Start with the parent error and recurse through the tree of children
-  // until we find the first one that has a status code.
-  grpc_error_handle found_error = recursively_find_error_with_field(
-      error, grpc_core::StatusIntProperty::kRpcStatus);
-  if (found_error.ok()) {
-    /// If no grpc-status exists, retry through the tree to find a http2 error
-    /// code
-    found_error = recursively_find_error_with_field(
-        error, grpc_core::StatusIntProperty::kHttp2Error);
-  }
-
-  // If we found an error with a status code above, use that; otherwise,
-  // fall back to using the parent error.
-  if (found_error.ok()) found_error = error;
-
-  grpc_status_code status = GRPC_STATUS_UNKNOWN;
-  intptr_t integer;
-  if (grpc_error_get_int(found_error, grpc_core::StatusIntProperty::kRpcStatus,
-                         &integer)) {
-    status = static_cast<grpc_status_code>(integer);
-  } else if (grpc_error_get_int(found_error,
-                                grpc_core::StatusIntProperty::kHttp2Error,
-                                &integer)) {
-    status = grpc_http2_error_to_grpc_status(
-        static_cast<Http2ErrorCode>(integer), deadline);
-  } else {
-    status = static_cast<grpc_status_code>(found_error.code());
-  }
-  if (code != nullptr) *code = status;
-
-  if (error_string != nullptr && status != GRPC_STATUS_OK) {
+  if (message != nullptr) *message = std::string(error.message());
+  if (error_string != nullptr && !error.ok()) {
     *error_string = gpr_strdup(grpc_core::StatusToString(error).c_str());
   }
-
   if (http_error != nullptr) {
-    if (grpc_error_get_int(
-            found_error, grpc_core::StatusIntProperty::kHttp2Error, &integer)) {
-      *http_error = static_cast<Http2ErrorCode>(integer);
-    } else if (grpc_error_get_int(found_error,
-                                  grpc_core::StatusIntProperty::kRpcStatus,
-                                  &integer)) {
-      *http_error =
-          grpc_status_to_http2_error(static_cast<grpc_status_code>(integer));
+    // If the HTTP2 error code attribute is present, use it.  Otherwise,
+    // if the status code is something other than UNKNOWN, convert from
+    // that.  Otherwise, set a default based on whether the status
+    // code is OK.
+    if (http_error_code.has_value()) {
+      *http_error = *http_error_code;
+    } else if (error.code() != absl::StatusCode::kUnknown) {
+      *http_error = grpc_status_to_http2_error(
+          static_cast<grpc_status_code>(error.code()));
     } else {
-      *http_error = found_error.ok() ? Http2ErrorCode::kNoError
-                                     : Http2ErrorCode::kInternalError;
-    }
-  }
-
-  // If the error has a status message, use it.  Otherwise, fall back to
-  // the error description.
-  if (message != nullptr) {
-    if (!grpc_error_get_str(
-            found_error, grpc_core::StatusStrProperty::kGrpcMessage, message)) {
-      *message = found_error.message().empty()
-                     ? grpc_core::StatusToString(error)
-                     : std::string(found_error.message());
+      *http_error = error.ok() ? Http2ErrorCode::kNoError
+                               : Http2ErrorCode::kInternalError;
     }
   }
 }
 
 absl::Status grpc_error_to_absl_status(grpc_error_handle error) {
-  if (grpc_core::IsErrorFlattenEnabled()) return error;
-  grpc_status_code status;
-  // TODO(yashykt): This should be updated once we decide on how to use the
-  // absl::Status payload to capture all the contents of grpc_error.
-  std::string message;
-  grpc_error_get_status(error, grpc_core::Timestamp::InfFuture(), &status,
-                        &message, nullptr /* http_error */,
-                        nullptr /* error_string */);
-  return absl::Status(static_cast<absl::StatusCode>(status), message);
+  return error;
 }
 
 grpc_error_handle absl_status_to_grpc_error(absl::Status status) {
-  if (grpc_core::IsErrorFlattenEnabled()) return status;
-  // Special error checks
-  if (status.ok()) {
-    return absl::OkStatus();
-  }
-  return grpc_error_set_int(GRPC_ERROR_CREATE(status.message()),
-                            grpc_core::StatusIntProperty::kRpcStatus,
-                            static_cast<grpc_status_code>(status.code()));
+  return status;
 }
 
 bool grpc_error_has_clear_grpc_status(grpc_error_handle error) {
-  if (grpc_core::IsErrorFlattenEnabled()) {
-    return error.code() != absl::StatusCode::kUnknown;
-  }
-  intptr_t unused;
-  if (grpc_error_get_int(error, grpc_core::StatusIntProperty::kRpcStatus,
-                         &unused)) {
-    return true;
-  }
-  std::vector<absl::Status> children = grpc_core::StatusGetChildren(error);
-  for (const absl::Status& child : children) {
-    if (grpc_error_has_clear_grpc_status(child)) {
-      return true;
-    }
-  }
-  return false;
+  return error.code() != absl::StatusCode::kUnknown;
 }

data/src/core/lib/transport/promise_endpoint.h

@@ -222,14 +222,12 @@ class PromiseEndpoint {
                });
   }
 
-  // Enables RPC receive coalescing and alignment of memory holding received
-  // RPCs.
-  void EnforceRxMemoryAlignmentAndCoalescing() {
+  // Enables RPC receive coalescing and memory alignment for received RPCs.
+  void EnableRpcReceiveCoalescing() {
     auto* ext = grpc_event_engine::experimental::QueryExtension<
         grpc_event_engine::experimental::ReceiveCoalescingExtension>(
         endpoint_.get());
     if (ext != nullptr) {
-      ext->EnforceRxMemoryAlignment();
       ext->EnableRpcReceiveCoalescing();
     }
   }

data/src/core/load_balancing/grpclb/grpclb.cc

@@ -880,7 +880,8 @@ GrpcLb::BalancerCallState::BalancerCallState(
       /*parent_call=*/nullptr, GRPC_PROPAGATE_DEFAULTS,
       /*cq=*/nullptr, grpclb_policy_->interested_parties(),
       Slice::FromStaticString("/grpc.lb.v1.LoadBalancer/BalanceLoad"),
-      /*authority=*/std::nullopt, deadline, /*registered_method=*/true);
+      /*authority=*/std::nullopt, deadline, /*registered_method=*/true,
+      /*arena_init_function=*/std::nullopt);
   // Init the LB call request payload.
   upb::Arena arena;
   grpc_slice request_payload_slice = GrpcLbRequestCreate(

data/src/core/load_balancing/pick_first/pick_first.cc

@@ -23,6 +23,7 @@
 #include <inttypes.h>
 #include <string.h>
 
+#include <cmath>
 #include <memory>
 #include <optional>
 #include <set>
@@ -32,6 +33,7 @@
 #include <vector>
 
 #include "src/core/config/core_configuration.h"
+#include "src/core/config/experiment_env_var.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/debug/trace.h"
@@ -538,8 +540,33 @@ absl::Status PickFirst::UpdateLocked(UpdateArgs args) {
       // Shuffle the list if needed.
       auto config = static_cast<PickFirstConfig*>(args.config.get());
       if (config->shuffle_addresses()) {
-        SharedBitGen g;
-        absl::c_shuffle(endpoints, g);
+        if (PfWeightedShufflingEnabled()) {
+          struct WeightedEndpoint {
+            EndpointAddresses endpoint;
+            double key;
+          };
+          std::vector<WeightedEndpoint> weighted_endpoints;
+          weighted_endpoints.reserve(endpoints.size());
+          SharedBitGen g;
+          for (auto& endpoint : endpoints) {
+            double e = absl::Exponential<double>(g);
+            int weight_arg =
+                endpoint.args().GetInt(GRPC_ARG_ADDRESS_WEIGHT).value_or(1);
+            double weight = weight_arg <= 0 ? 1.0 : weight_arg;
+            double key = (weight == 1.0) ? e : (e / weight);
+            weighted_endpoints.push_back({std::move(endpoint), key});
+          }
+          std::sort(weighted_endpoints.begin(), weighted_endpoints.end(),
+                    [](const WeightedEndpoint& a, const WeightedEndpoint& b) {
+                      return a.key < b.key;
+                    });
+          for (size_t i = 0; i < weighted_endpoints.size(); ++i) {
+            endpoints[i] = std::move(weighted_endpoints[i].endpoint);
+          }
+        } else {
+          SharedBitGen g;
+          absl::c_shuffle(endpoints, g);
+        }
       }
       // Flatten the list so that we have one address per endpoint.
       // While we're iterating, also determine the desired address family
@@ -1159,6 +1186,10 @@ class PickFirstFactory final : public LoadBalancingPolicyFactory {
 
 }  // namespace
 
+bool PfWeightedShufflingEnabled() {
+  return IsExperimentEnvVarEnabled("GRPC_EXPERIMENTAL_PF_WEIGHTED_SHUFFLING");
+}
+
 void RegisterPickFirstLbPolicy(CoreConfiguration::Builder* builder) {
   builder->lb_policy_registry()->RegisterLoadBalancingPolicyFactory(
       std::make_unique<PickFirstFactory>());

data/src/core/load_balancing/pick_first/pick_first.h

@@ -33,4 +33,10 @@
 #define GRPC_ARG_INTERNAL_PICK_FIRST_OMIT_STATUS_MESSAGE_PREFIX \
   GRPC_ARG_NO_SUBCHANNEL_PREFIX "pick_first_omit_status_message_prefix"
 
+namespace grpc_core {
+
+bool PfWeightedShufflingEnabled();
+
+}  // namespace grpc_core
+
 #endif  // GRPC_SRC_CORE_LOAD_BALANCING_PICK_FIRST_PICK_FIRST_H

data/src/core/load_balancing/ring_hash/ring_hash.cc

@@ -34,6 +34,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/address_utils/sockaddr_utils.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/debug/trace.h"
@@ -51,7 +52,6 @@
 #include "src/core/resolver/endpoint_addresses.h"
 #include "src/core/util/crash.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/orphanable.h"
@@ -81,19 +81,12 @@ namespace {
 
 constexpr absl::string_view kRingHash = "ring_hash_experimental";
 
-bool XdsRingHashSetRequestHashKeyEnabled() {
-  auto value = GetEnv("GRPC_EXPERIMENTAL_RING_HASH_SET_REQUEST_HASH_KEY");
-  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;
-}
-
 class RingHashJsonArgs final : public JsonArgs {
  public:
   bool IsEnabled(absl::string_view key) const override {
     if (key == "request_hash_header") {
-      return XdsRingHashSetRequestHashKeyEnabled();
+      return IsExperimentEnvVarEnabled(
+          "GRPC_EXPERIMENTAL_RING_HASH_SET_REQUEST_HASH_KEY");
     }
     return true;
   }

data/src/core/load_balancing/rls/rls.cc

@@ -1680,7 +1680,8 @@ void RlsLb::RlsRequest::StartCallLocked() {
       /*parent_call=*/nullptr, GRPC_PROPAGATE_DEFAULTS, /*cq=*/nullptr,
       lb_policy_->interested_parties(),
       Slice::FromStaticString(kRlsRequestPath), /*authority=*/std::nullopt,
-      deadline_, /*registered_method=*/true);
+      deadline_, /*registered_method=*/true,
+      /*arena_init_function=*/std::nullopt);
   grpc_op ops[6];
   memset(ops, 0, sizeof(ops));
   grpc_op* op = ops;

data/src/core/load_balancing/weighted_round_robin/weighted_round_robin.cc

@@ -36,6 +36,7 @@
 
 #include "src/core/client_channel/client_channel_service_config.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/experiments/experiments.h"
@@ -55,7 +56,6 @@
 #include "src/core/telemetry/stats.h"
 #include "src/core/telemetry/stats_data.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"
@@ -64,7 +64,6 @@
 #include "src/core/util/ref_counted.h"
 #include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/shared_bit_gen.h"
-#include "src/core/util/string.h"
 #include "src/core/util/sync.h"
 #include "src/core/util/time.h"
 #include "src/core/util/validation_errors.h"
@@ -82,11 +81,7 @@
 namespace grpc_core {
 
 bool WrrCustomMetricsEnabled() {
-  auto value = GetEnv("GRPC_EXPERIMENTAL_WRR_CUSTOM_METRICS");
-  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_EXPERIMENTAL_WRR_CUSTOM_METRICS");
 }
 
 namespace {

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