grpc 1.69.0 → 1.71.0

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

@@ -27,6 +27,7 @@
 #include <cmath>
 #include <map>
 #include <memory>
+#include <optional>
 #include <string>
 #include <utility>
 #include <vector>
@@ -35,11 +36,11 @@
 #include "absl/container/inlined_vector.h"
 #include "absl/log/check.h"
 #include "absl/log/log.h"
+#include "absl/random/random.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 #include "src/core/client_channel/client_channel_internal.h"
 #include "src/core/config/core_configuration.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
@@ -59,10 +60,12 @@
 #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/json/json.h"
 #include "src/core/util/orphanable.h"
 #include "src/core/util/ref_counted.h"
 #include "src/core/util/ref_counted_ptr.h"
+#include "src/core/util/ref_counted_string.h"
 #include "src/core/util/unique_type_name.h"
 #include "src/core/util/work_serializer.h"
 #include "src/core/util/xxhash_inline.h"
@@ -74,53 +77,79 @@ UniqueTypeName RequestHashAttribute::TypeName() {
   return kFactory.Create();
 }
 
-// Helper Parser method
+namespace {
+
+constexpr absl::string_view kRingHash = "ring_hash_experimental";
 
-const JsonLoaderInterface* RingHashConfig::JsonLoader(const JsonArgs&) {
-  static const auto* loader =
-      JsonObjectLoader<RingHashConfig>()
-          .OptionalField("minRingSize", &RingHashConfig::min_ring_size)
-          .OptionalField("maxRingSize", &RingHashConfig::max_ring_size)
-          .Finish();
-  return loader;
+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;
 }
 
-void RingHashConfig::JsonPostLoad(const Json&, const JsonArgs&,
-                                  ValidationErrors* errors) {
-  {
-    ValidationErrors::ScopedField field(errors, ".minRingSize");
-    if (!errors->FieldHasErrors() &&
-        (min_ring_size == 0 || min_ring_size > 8388608)) {
-      errors->AddError("must be in the range [1, 8388608]");
-    }
-  }
-  {
-    ValidationErrors::ScopedField field(errors, ".maxRingSize");
-    if (!errors->FieldHasErrors() &&
-        (max_ring_size == 0 || max_ring_size > 8388608)) {
-      errors->AddError("must be in the range [1, 8388608]");
+class RingHashJsonArgs final : public JsonArgs {
+ public:
+  bool IsEnabled(absl::string_view key) const override {
+    if (key == "request_hash_header") {
+      return XdsRingHashSetRequestHashKeyEnabled();
     }
+    return true;
   }
-  if (min_ring_size > max_ring_size) {
-    errors->AddError("max_ring_size cannot be smaller than min_ring_size");
-  }
-}
-
-namespace {
-
-constexpr absl::string_view kRingHash = "ring_hash_experimental";
+};
 
 class RingHashLbConfig final : public LoadBalancingPolicy::Config {
  public:
-  RingHashLbConfig(size_t min_ring_size, size_t max_ring_size)
-      : min_ring_size_(min_ring_size), max_ring_size_(max_ring_size) {}
+  RingHashLbConfig() = default;
+
+  RingHashLbConfig(const RingHashLbConfig&) = delete;
+  RingHashLbConfig& operator=(const RingHashLbConfig&) = delete;
+
+  RingHashLbConfig(RingHashLbConfig&& other) = delete;
+  RingHashLbConfig& operator=(RingHashLbConfig&& other) = delete;
+
   absl::string_view name() const override { return kRingHash; }
   size_t min_ring_size() const { return min_ring_size_; }
   size_t max_ring_size() const { return max_ring_size_; }
+  absl::string_view request_hash_header() const { return request_hash_header_; }
+
+  static const JsonLoaderInterface* JsonLoader(const JsonArgs&) {
+    static const auto* loader =
+        JsonObjectLoader<RingHashLbConfig>()
+            .OptionalField("minRingSize", &RingHashLbConfig::min_ring_size_)
+            .OptionalField("maxRingSize", &RingHashLbConfig::max_ring_size_)
+            .OptionalField("requestHashHeader",
+                           &RingHashLbConfig::request_hash_header_,
+                           "request_hash_header")
+            .Finish();
+    return loader;
+  }
+
+  void JsonPostLoad(const Json&, const JsonArgs&, ValidationErrors* errors) {
+    {
+      ValidationErrors::ScopedField field(errors, ".minRingSize");
+      if (!errors->FieldHasErrors() &&
+          (min_ring_size_ == 0 || min_ring_size_ > 8388608)) {
+        errors->AddError("must be in the range [1, 8388608]");
+      }
+    }
+    {
+      ValidationErrors::ScopedField field(errors, ".maxRingSize");
+      if (!errors->FieldHasErrors() &&
+          (max_ring_size_ == 0 || max_ring_size_ > 8388608)) {
+        errors->AddError("must be in the range [1, 8388608]");
+      }
+    }
+    if (min_ring_size_ > max_ring_size_) {
+      errors->AddError("maxRingSize cannot be smaller than minRingSize");
+    }
+  }
 
  private:
-  size_t min_ring_size_;
-  size_t max_ring_size_;
+  uint64_t min_ring_size_ = 1024;
+  uint64_t max_ring_size_ = 4096;
+  std::string request_hash_header_;
 };
 
 //
@@ -217,9 +246,14 @@ class RingHash final : public LoadBalancingPolicy {
     explicit Picker(RefCountedPtr<RingHash> ring_hash)
         : ring_hash_(std::move(ring_hash)),
           ring_(ring_hash_->ring_),
-          endpoints_(ring_hash_->endpoints_.size()) {
-      for (const auto& p : ring_hash_->endpoint_map_) {
-        endpoints_[p.second->index()] = p.second->GetInfoForPicker();
+          endpoints_(ring_hash_->endpoints_.size()),
+          resolution_note_(ring_hash_->resolution_note_),
+          request_hash_header_(ring_hash_->request_hash_header_) {
+      for (const auto& [_, endpoint] : ring_hash_->endpoint_map_) {
+        endpoints_[endpoint->index()] = endpoint->GetInfoForPicker();
+        if (endpoints_[endpoint->index()].state == GRPC_CHANNEL_CONNECTING) {
+          has_endpoint_in_connecting_state_ = true;
+        }
       }
     }
 
@@ -242,14 +276,12 @@ class RingHash final : public LoadBalancingPolicy {
      private:
       static void RunInExecCtx(void* arg, grpc_error_handle /*error*/) {
         auto* self = static_cast<EndpointConnectionAttempter*>(arg);
-        self->ring_hash_->work_serializer()->Run(
-            [self]() {
-              if (!self->ring_hash_->shutdown_) {
-                self->endpoint_->RequestConnectionLocked();
-              }
-              delete self;
-            },
-            DEBUG_LOCATION);
+        self->ring_hash_->work_serializer()->Run([self]() {
+          if (!self->ring_hash_->shutdown_) {
+            self->endpoint_->RequestConnectionLocked();
+          }
+          delete self;
+        });
       }
 
       RefCountedPtr<RingHash> ring_hash_;
@@ -260,6 +292,9 @@ class RingHash final : public LoadBalancingPolicy {
     RefCountedPtr<RingHash> ring_hash_;
     RefCountedPtr<Ring> ring_;
     std::vector<RingHashEndpoint::EndpointInfo> endpoints_;
+    bool has_endpoint_in_connecting_state_ = false;
+    std::string resolution_note_;
+    RefCountedStringValue request_hash_header_;
   };
 
   ~RingHash() override;
@@ -267,20 +302,19 @@ class RingHash final : public LoadBalancingPolicy {
   void ShutdownLocked() override;
 
   // Updates the aggregate policy's connectivity state based on the
-  // endpoint list's state counters, creating a new picker.
-  // entered_transient_failure is true if the endpoint has just
-  // entered TRANSIENT_FAILURE state.
+  // number of endpoints in each state, creating a new picker.
   // If the call to this method is triggered by an endpoint entering
   // TRANSIENT_FAILURE, then status is the status reported by the endpoint.
-  void UpdateAggregatedConnectivityStateLocked(bool entered_transient_failure,
-                                               absl::Status status);
+  void UpdateAggregatedConnectivityStateLocked(absl::Status status);
 
   // Current endpoint list, channel args, and ring.
   EndpointAddressesList endpoints_;
   ChannelArgs args_;
+  RefCountedStringValue request_hash_header_;
   RefCountedPtr<Ring> ring_;
 
   std::map<EndpointAddressSet, OrphanablePtr<RingHashEndpoint>> endpoint_map_;
+  std::string resolution_note_;
 
   // TODO(roth): If we ever change the helper UpdateState() API to not
   // need the status reported for TRANSIENT_FAILURE state (because
@@ -297,17 +331,34 @@ class RingHash final : public LoadBalancingPolicy {
 //
 
 RingHash::PickResult RingHash::Picker::Pick(PickArgs args) {
-  auto* call_state = static_cast<ClientChannelLbCallState*>(args.call_state);
-  auto* hash_attribute = call_state->GetCallAttribute<RequestHashAttribute>();
-  if (hash_attribute == nullptr) {
-    return PickResult::Fail(absl::InternalError("hash attribute not present"));
+  // Determine request hash.
+  bool using_random_hash = false;
+  uint64_t request_hash;
+  if (request_hash_header_.as_string_view().empty()) {
+    // Being used in xDS.  Request hash is passed in via an attribute.
+    auto* call_state = static_cast<ClientChannelLbCallState*>(args.call_state);
+    auto* hash_attribute = call_state->GetCallAttribute<RequestHashAttribute>();
+    if (hash_attribute == nullptr) {
+      return PickResult::Fail(
+          absl::InternalError("hash attribute not present"));
+    }
+    request_hash = hash_attribute->request_hash();
+  } else {
+    std::string buffer;
+    auto header_value = args.initial_metadata->Lookup(
+        request_hash_header_.as_string_view(), &buffer);
+    if (header_value.has_value()) {
+      request_hash = XXH64(header_value->data(), header_value->size(), 0);
+    } else {
+      request_hash = absl::Uniform<uint64_t>(absl::BitGen());
+      using_random_hash = true;
+    }
   }
-  uint64_t request_hash = hash_attribute->request_hash();
-  const auto& ring = ring_->ring();
   // Find the index in the ring to use for this RPC.
   // Ported from https://github.com/RJ/ketama/blob/master/libketama/ketama.c
   // (ketama_get_server) NOTE: The algorithm depends on using signed integers
   // for lowp, highp, and index. Do not change them!
+  const auto& ring = ring_->ring();
   int64_t lowp = 0;
   int64_t highp = ring.size();
   int64_t index = 0;
@@ -333,26 +384,50 @@ RingHash::PickResult RingHash::Picker::Pick(PickArgs args) {
     }
   }
   // Find the first endpoint we can use from the selected index.
-  for (size_t i = 0; i < ring.size(); ++i) {
-    const auto& entry = ring[(index + i) % ring.size()];
-    const auto& endpoint_info = endpoints_[entry.endpoint_index];
-    switch (endpoint_info.state) {
-      case GRPC_CHANNEL_READY:
+  if (!using_random_hash) {
+    for (size_t i = 0; i < ring.size(); ++i) {
+      const auto& entry = ring[(index + i) % ring.size()];
+      const auto& endpoint_info = endpoints_[entry.endpoint_index];
+      switch (endpoint_info.state) {
+        case GRPC_CHANNEL_READY:
+          return endpoint_info.picker->Pick(args);
+        case GRPC_CHANNEL_IDLE:
+          new EndpointConnectionAttempter(
+              ring_hash_.Ref(DEBUG_LOCATION, "EndpointConnectionAttempter"),
+              endpoint_info.endpoint);
+          [[fallthrough]];
+        case GRPC_CHANNEL_CONNECTING:
+          return PickResult::Queue();
+        default:
+          break;
+      }
+    }
+  } else {
+    // Using a random hash.  We will use the first READY endpoint we
+    // find, triggering at most one endpoint to attempt connecting.
+    bool requested_connection = has_endpoint_in_connecting_state_;
+    for (size_t i = 0; i < ring.size(); ++i) {
+      const auto& entry = ring[(index + i) % ring.size()];
+      const auto& endpoint_info = endpoints_[entry.endpoint_index];
+      if (endpoint_info.state == GRPC_CHANNEL_READY) {
         return endpoint_info.picker->Pick(args);
-      case GRPC_CHANNEL_IDLE:
+      }
+      if (!requested_connection && endpoint_info.state == GRPC_CHANNEL_IDLE) {
         new EndpointConnectionAttempter(
             ring_hash_.Ref(DEBUG_LOCATION, "EndpointConnectionAttempter"),
             endpoint_info.endpoint);
-        ABSL_FALLTHROUGH_INTENDED;
-      case GRPC_CHANNEL_CONNECTING:
-        return PickResult::Queue();
-      default:
-        break;
+        requested_connection = true;
+      }
     }
+    if (requested_connection) return PickResult::Queue();
   }
-  return PickResult::Fail(absl::UnavailableError(absl::StrCat(
+  std::string message = absl::StrCat(
       "ring hash cannot find a connected endpoint; first failure: ",
-      endpoints_[ring[index].endpoint_index].status.message())));
+      endpoints_[ring[index].endpoint_index].status.message());
+  if (!resolution_note_.empty()) {
+    absl::StrAppend(&message, " (", resolution_note_, ")");
+  }
+  return PickResult::Fail(absl::UnavailableError(message));
 }
 
 //
@@ -362,7 +437,7 @@ RingHash::PickResult RingHash::Picker::Pick(PickArgs args) {
 RingHash::Ring::Ring(RingHash* ring_hash, RingHashLbConfig* config) {
   // Store the weights while finding the sum.
   struct EndpointWeight {
-    std::string address;  // Key by endpoint's first address.
+    std::string hash_key;  // By default, endpoint's first address.
     // Default weight is 1 for the cases where a weight is not provided,
     // each occurrence of the address will be counted a weight value of 1.
     uint32_t weight = 1;
@@ -374,8 +449,14 @@ RingHash::Ring::Ring(RingHash* ring_hash, RingHashLbConfig* config) {
   endpoint_weights.reserve(endpoints.size());
   for (const auto& endpoint : endpoints) {
     EndpointWeight endpoint_weight;
-    endpoint_weight.address =
-        grpc_sockaddr_to_string(&endpoint.addresses().front(), false).value();
+    auto hash_key =
+        endpoint.args().GetString(GRPC_ARG_RING_HASH_ENDPOINT_HASH_KEY);
+    if (hash_key.has_value()) {
+      endpoint_weight.hash_key = std::string(*hash_key);
+    } else {
+      endpoint_weight.hash_key =
+          grpc_sockaddr_to_string(&endpoint.addresses().front(), false).value();
+    }
     // Weight should never be zero, but ignore it just in case, since
     // that value would screw up the ring-building algorithm.
     auto weight_arg = endpoint.args().GetInt(GRPC_ARG_ADDRESS_WEIGHT);
@@ -425,8 +506,8 @@ RingHash::Ring::Ring(RingHash* ring_hash, RingHashLbConfig* config) {
   uint64_t min_hashes_per_host = ring_size;
   uint64_t max_hashes_per_host = 0;
   for (size_t i = 0; i < endpoints.size(); ++i) {
-    const std::string& address_string = endpoint_weights[i].address;
-    hash_key_buffer.assign(address_string.begin(), address_string.end());
+    const std::string& hash_key = endpoint_weights[i].hash_key;
+    hash_key_buffer.assign(hash_key.begin(), hash_key.end());
     hash_key_buffer.emplace_back('_');
     auto offset_start = hash_key_buffer.end();
     target_hashes += scale * endpoint_weights[i].normalized_weight;
@@ -577,15 +658,11 @@ void RingHash::RingHashEndpoint::OnStateUpdate(
       << ")";
   if (child_policy_ == nullptr) return;  // Already orphaned.
   // Update state.
-  const bool entered_transient_failure =
-      connectivity_state_ != GRPC_CHANNEL_TRANSIENT_FAILURE &&
-      new_state == GRPC_CHANNEL_TRANSIENT_FAILURE;
   connectivity_state_ = new_state;
   status_ = status;
   picker_ = std::move(picker);
   // Update the aggregated connectivity state.
-  ring_hash_->UpdateAggregatedConnectivityStateLocked(entered_transient_failure,
-                                                      status);
+  ring_hash_->UpdateAggregatedConnectivityStateLocked(status);
 }
 
 //
@@ -608,8 +685,8 @@ void RingHash::ShutdownLocked() {
 }
 
 void RingHash::ResetBackoffLocked() {
-  for (const auto& p : endpoint_map_) {
-    p.second->ResetBackoffLocked();
+  for (const auto& [_, endpoint] : endpoint_map_) {
+    endpoint->ResetBackoffLocked();
   }
 }
 
@@ -622,10 +699,10 @@ absl::Status RingHash::UpdateLocked(UpdateArgs args) {
     std::map<EndpointAddressSet, size_t> endpoint_indices;
     (*args.addresses)->ForEach([&](const EndpointAddresses& endpoint) {
       const EndpointAddressSet key(endpoint.addresses());
-      auto p = endpoint_indices.emplace(key, endpoints_.size());
-      if (!p.second) {
+      auto [it, inserted] = endpoint_indices.emplace(key, endpoints_.size());
+      if (!inserted) {
         // Duplicate endpoint.  Combine weights and skip the dup.
-        EndpointAddresses& prev_endpoint = endpoints_[p.first->second];
+        EndpointAddresses& prev_endpoint = endpoints_[it->second];
         int weight_arg =
             endpoint.args().GetInt(GRPC_ARG_ADDRESS_WEIGHT).value_or(1);
         int prev_weight_arg =
@@ -652,9 +729,11 @@ absl::Status RingHash::UpdateLocked(UpdateArgs args) {
   }
   // Save channel args.
   args_ = std::move(args.args);
+  // Save config.
+  auto* config = DownCast<RingHashLbConfig*>(args.config.get());
+  request_hash_header_ = RefCountedStringValue(config->request_hash_header());
   // Build new ring.
-  ring_ = MakeRefCounted<Ring>(
-      this, static_cast<RingHashLbConfig*>(args.config.get()));
+  ring_ = MakeRefCounted<Ring>(this, config);
   // Update endpoint map.
   std::map<EndpointAddressSet, OrphanablePtr<RingHashEndpoint>> endpoint_map;
   std::vector<std::string> errors;
@@ -676,20 +755,21 @@ absl::Status RingHash::UpdateLocked(UpdateArgs args) {
     }
   }
   endpoint_map_ = std::move(endpoint_map);
+  // Update resolution note.
+  resolution_note_ = std::move(args.resolution_note);
   // If the address list is empty, report TRANSIENT_FAILURE.
   if (endpoints_.empty()) {
-    absl::Status status =
-        args.addresses.ok() ? absl::UnavailableError(absl::StrCat(
-                                  "empty address list: ", args.resolution_note))
-                            : args.addresses.status();
+    absl::Status status = args.addresses.ok()
+                              ? absl::UnavailableError(absl::StrCat(
+                                    "empty address list: ", resolution_note_))
+                              : args.addresses.status();
     channel_control_helper()->UpdateState(
         GRPC_CHANNEL_TRANSIENT_FAILURE, status,
         MakeRefCounted<TransientFailurePicker>(status));
     return status;
   }
   // Return a new picker.
-  UpdateAggregatedConnectivityStateLocked(/*entered_transient_failure=*/false,
-                                          absl::OkStatus());
+  UpdateAggregatedConnectivityStateLocked(absl::OkStatus());
   if (!errors.empty()) {
     return absl::UnavailableError(absl::StrCat(
         "errors from children: [", absl::StrJoin(errors, "; "), "]"));
@@ -697,20 +777,21 @@ absl::Status RingHash::UpdateLocked(UpdateArgs args) {
   return absl::OkStatus();
 }
 
-void RingHash::UpdateAggregatedConnectivityStateLocked(
-    bool entered_transient_failure, absl::Status status) {
+void RingHash::UpdateAggregatedConnectivityStateLocked(absl::Status status) {
   // Count the number of endpoints in each state.
   size_t num_idle = 0;
   size_t num_connecting = 0;
   size_t num_ready = 0;
   size_t num_transient_failure = 0;
-  for (const auto& p : endpoint_map_) {
-    switch (p.second->connectivity_state()) {
+  RingHashEndpoint* idle_endpoint = nullptr;
+  for (const auto& [_, endpoint] : endpoint_map_) {
+    switch (endpoint->connectivity_state()) {
       case GRPC_CHANNEL_READY:
         ++num_ready;
         break;
       case GRPC_CHANNEL_IDLE:
         ++num_idle;
+        if (idle_endpoint == nullptr) idle_endpoint = endpoint.get();
         break;
       case GRPC_CHANNEL_CONNECTING:
         ++num_connecting;
@@ -732,33 +813,26 @@ void RingHash::UpdateAggregatedConnectivityStateLocked(
   //    more than one endpoint, report CONNECTING.
   // 5. If there is at least one endpoint in IDLE state, report IDLE.
   // 6. Otherwise, report TRANSIENT_FAILURE.
-  //
-  // We set start_connection_attempt to true if we match rules 2, 4, or 6.
   grpc_connectivity_state state;
-  bool start_connection_attempt = false;
   if (num_ready > 0) {
     state = GRPC_CHANNEL_READY;
   } else if (num_transient_failure >= 2) {
     state = GRPC_CHANNEL_TRANSIENT_FAILURE;
-    start_connection_attempt = true;
   } else if (num_connecting > 0) {
     state = GRPC_CHANNEL_CONNECTING;
   } else if (num_transient_failure == 1 && endpoints_.size() > 1) {
     state = GRPC_CHANNEL_CONNECTING;
-    start_connection_attempt = true;
   } else if (num_idle > 0) {
     state = GRPC_CHANNEL_IDLE;
   } else {
     state = GRPC_CHANNEL_TRANSIENT_FAILURE;
-    start_connection_attempt = true;
   }
   GRPC_TRACE_LOG(ring_hash_lb, INFO)
       << "[RH " << this << "] setting connectivity state to "
       << ConnectivityStateName(state) << " (num_idle=" << num_idle
       << ", num_connecting=" << num_connecting << ", num_ready=" << num_ready
       << ", num_transient_failure=" << num_transient_failure
-      << ", size=" << endpoints_.size()
-      << ") -- start_connection_attempt=" << start_connection_attempt;
+      << ", size=" << endpoints_.size() << ")";
   // In TRANSIENT_FAILURE, report the last reported failure.
   // Otherwise, report OK.
   if (state == GRPC_CHANNEL_TRANSIENT_FAILURE) {
@@ -776,24 +850,25 @@ void RingHash::UpdateAggregatedConnectivityStateLocked(
       state, status,
       MakeRefCounted<Picker>(
           RefAsSubclass<RingHash>(DEBUG_LOCATION, "RingHashPicker")));
-  // While the ring_hash policy is reporting TRANSIENT_FAILURE, it will
-  // not be getting any pick requests from the priority policy.
-  // However, because the ring_hash policy does not attempt to
-  // reconnect to endpoints unless it is getting pick requests,
-  // it will need special handling to ensure that it will eventually
-  // recover from TRANSIENT_FAILURE state once the problem is resolved.
-  // Specifically, it will make sure that it is attempting to connect to
-  // at least one endpoint at any given time.  But we don't want to just
-  // try to connect to only one endpoint, because if that particular
-  // endpoint happens to be down but the rest are reachable, we would
-  // incorrectly fail to recover.
+  // The ring_hash policy normally triggers endpoint connection attempts
+  // from the picker.  However, if it is being used as a child of the
+  // priority policy, it will not be getting any picks once it reports
+  // TRANSIENT_FAILURE, and in some cases even when it reports CONNECTING,
+  // due to the failover timer in the priority policy.  Because it reports
+  // TRANSIENT_FAILURE when only two endpoints are failing (aggregation
+  // rule 2 above) and CONNECTING when only one endpoint is reporting
+  // TRANSIENT_FAILURE (aggregation rule 4 above), this means that the
+  // priority policy could fail over to the next priority when the
+  // ring_hash policy is only attempting a small number of endpoints.
+  // This would effectively cause us to assume that all of the ring_hash
+  // endpoints are unreachable when in fact only a small number of them
+  // are, and we would never try any of the others, thus never
+  // recovering from that incorrect assumption.
   //
-  // So, to handle this, whenever an endpoint initially enters
-  // TRANSIENT_FAILURE state (i.e., its initial connection attempt has
-  // failed), if there are no endpoints currently in CONNECTING state
-  // (i.e., they are still trying their initial connection attempt),
-  // then we will trigger a connection attempt for the first endpoint
-  // that is currently in state IDLE, if any.
+  // To work around this, when the aggregated connectivity state is
+  // either TRANSIENT_FAILURE or CONNECTING, if we do not have at least
+  // one CONNECTING endpoint but we have at least one IDLE endpoint,
+  // then we trigger a connection attempt on one of the IDLE endpoints.
   //
   // Note that once an endpoint enters TRANSIENT_FAILURE state, it will
   // stay in that state and automatically retry after appropriate backoff,
@@ -804,37 +879,16 @@ void RingHash::UpdateAggregatedConnectivityStateLocked(
   // LB policy and we keep getting picks, so it's not really a new
   // problem.  If/when it becomes an issue, we can figure out how to
   // address it.
-  //
-  // Note that we do the same thing when the policy is in state
-  // CONNECTING, just to ensure that we don't remain in CONNECTING state
-  // indefinitely if there are no new picks coming in.
-  if (start_connection_attempt && entered_transient_failure) {
-    size_t first_idle_index = endpoints_.size();
-    for (size_t i = 0; i < endpoints_.size(); ++i) {
-      auto it =
-          endpoint_map_.find(EndpointAddressSet(endpoints_[i].addresses()));
-      CHECK(it != endpoint_map_.end());
-      if (it->second->connectivity_state() == GRPC_CHANNEL_CONNECTING) {
-        first_idle_index = endpoints_.size();
-        break;
-      }
-      if (first_idle_index == endpoints_.size() &&
-          it->second->connectivity_state() == GRPC_CHANNEL_IDLE) {
-        first_idle_index = i;
-      }
-    }
-    if (first_idle_index != endpoints_.size()) {
-      auto it = endpoint_map_.find(
-          EndpointAddressSet(endpoints_[first_idle_index].addresses()));
-      CHECK(it != endpoint_map_.end());
-      GRPC_TRACE_LOG(ring_hash_lb, INFO)
-          << "[RH " << this
-          << "] triggering internal connection attempt for endpoint "
-          << it->second.get() << " (" << endpoints_[first_idle_index].ToString()
-          << ") (index " << first_idle_index << " of " << endpoints_.size()
-          << ")";
-      it->second->RequestConnectionLocked();
-    }
+  if ((state == GRPC_CHANNEL_CONNECTING ||
+       state == GRPC_CHANNEL_TRANSIENT_FAILURE) &&
+      num_connecting == 0 && idle_endpoint != nullptr) {
+    GRPC_TRACE_LOG(ring_hash_lb, INFO)
+        << "[RH " << this
+        << "] triggering internal connection attempt for endpoint "
+        << idle_endpoint << " ("
+        << endpoints_[idle_endpoint->index()].ToString() << ") (index "
+        << idle_endpoint->index() << " of " << endpoints_.size() << ")";
+    idle_endpoint->RequestConnectionLocked();
   }
 }
 
@@ -853,11 +907,9 @@ class RingHashFactory final : public LoadBalancingPolicyFactory {
 
   absl::StatusOr<RefCountedPtr<LoadBalancingPolicy::Config>>
   ParseLoadBalancingConfig(const Json& json) const override {
-    auto config = LoadFromJson<RingHashConfig>(
-        json, JsonArgs(), "errors validating ring_hash LB policy config");
-    if (!config.ok()) return config.status();
-    return MakeRefCounted<RingHashLbConfig>(config->min_ring_size,
-                                            config->max_ring_size);
+    return LoadFromJson<RefCountedPtr<RingHashLbConfig>>(
+        json, RingHashJsonArgs(),
+        "errors validating ring_hash LB policy config");
   }
 };
 

data/src/core/load_balancing/ring_hash/ring_hash.h

@@ -27,6 +27,10 @@
 #include "src/core/util/unique_type_name.h"
 #include "src/core/util/validation_errors.h"
 
+// Optional endpoint attribute specifying the hash key.
+#define GRPC_ARG_RING_HASH_ENDPOINT_HASH_KEY \
+  GRPC_ARG_NO_SUBCHANNEL_PREFIX "hash_key"
+
 namespace grpc_core {
 
 class RequestHashAttribute final
@@ -45,17 +49,6 @@ class RequestHashAttribute final
   uint64_t request_hash_;
 };
 
-// Helper Parsing method to parse ring hash policy configs; for example, ring
-// hash size validity.
-struct RingHashConfig {
-  uint64_t min_ring_size = 1024;
-  uint64_t max_ring_size = 4096;
-
-  static const JsonLoaderInterface* JsonLoader(const JsonArgs&);
-  void JsonPostLoad(const Json& json, const JsonArgs&,
-                    ValidationErrors* errors);
-};
-
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_LOAD_BALANCING_RING_HASH_RING_HASH_H