grpc 1.70.1 → 1.71.0

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

@@ -24,6 +24,7 @@
 #include <string.h>
 
 #include <memory>
+#include <optional>
 #include <set>
 #include <string>
 #include <type_traits>
@@ -38,7 +39,6 @@
 #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/config/core_configuration.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/channel/channel_args.h"
@@ -195,7 +195,7 @@ class PickFirst final : public LoadBalancingPolicy {
 
         // TODO(roth): Once we remove pollset_set, we should no longer
         // need to hold a ref to PickFirst.  Instead, we can make this a
-        // raw pointer and put it in an absl::variant with subchannel_data_.
+        // raw pointer and put it in an std::variant with subchannel_data_.
         RefCountedPtr<PickFirst> pick_first_;
 
         RefCountedPtr<SubchannelInterface> subchannel_;
@@ -206,7 +206,7 @@ class PickFirst final : public LoadBalancingPolicy {
       SubchannelData(SubchannelList* subchannel_list, size_t index,
                      RefCountedPtr<SubchannelInterface> subchannel);
 
-      absl::optional<grpc_connectivity_state> connectivity_state() const {
+      std::optional<grpc_connectivity_state> connectivity_state() const {
         return connectivity_state_;
       }
       const absl::Status& connectivity_status() const {
@@ -224,6 +224,7 @@ class PickFirst final : public LoadBalancingPolicy {
       void RequestConnectionWithTimer();
 
       bool seen_transient_failure() const { return seen_transient_failure_; }
+      void set_seen_transient_failure() { seen_transient_failure_ = true; }
 
      private:
       // This method will be invoked once soon after instantiation to report
@@ -239,7 +240,7 @@ class PickFirst final : public LoadBalancingPolicy {
       // Subchannel state.
       OrphanablePtr<SubchannelState> subchannel_state_;
       // Data updated by the watcher.
-      absl::optional<grpc_connectivity_state> connectivity_state_;
+      std::optional<grpc_connectivity_state> connectivity_state_;
       absl::Status connectivity_status_;
       bool seen_transient_failure_ = false;
     };
@@ -312,7 +313,7 @@ class PickFirst final : public LoadBalancingPolicy {
     // initial pass is over, this will be equal to size().
     size_t attempting_index_ = 0;
     // Happy Eyeballs timer handle.
-    absl::optional<grpc_event_engine::experimental::EventEngine::TaskHandle>
+    std::optional<grpc_event_engine::experimental::EventEngine::TaskHandle>
         timer_handle_;
 
     // After the initial Happy Eyeballs pass, the number of failures
@@ -822,13 +823,11 @@ void PickFirst::SubchannelList::SubchannelData::OnConnectivityStateChange(
   // not call us in the first place.
   CHECK_NE(new_state, GRPC_CHANNEL_READY);
   // Update state.
-  absl::optional<grpc_connectivity_state> old_state = connectivity_state_;
+  std::optional<grpc_connectivity_state> old_state = connectivity_state_;
   connectivity_state_ = new_state;
   connectivity_status_ = std::move(status);
   // Make sure we note when a subchannel has seen TRANSIENT_FAILURE.
-  bool prev_seen_transient_failure = seen_transient_failure_;
   if (new_state == GRPC_CHANNEL_TRANSIENT_FAILURE) {
-    seen_transient_failure_ = true;
     subchannel_list_->last_failure_ = connectivity_status_;
   }
   // If this is the initial connectivity state update for this subchannel,
@@ -873,6 +872,8 @@ void PickFirst::SubchannelList::SubchannelData::OnConnectivityStateChange(
   // Otherwise, process connectivity state change.
   switch (*connectivity_state_) {
     case GRPC_CHANNEL_TRANSIENT_FAILURE: {
+      bool prev_seen_transient_failure =
+          std::exchange(seen_transient_failure_, true);
       // If this is the first failure we've seen on this subchannel,
       // then we're still in the Happy Eyeballs pass.
       if (!prev_seen_transient_failure && seen_transient_failure_) {
@@ -957,7 +958,6 @@ void PickFirst::SubchannelList::SubchannelData::RequestConnectionWithTimer() {
             p->connection_attempt_delay_,
             [subchannel_list =
                  subchannel_list_->Ref(DEBUG_LOCATION, "timer")]() mutable {
-              ApplicationCallbackExecCtx application_exec_ctx;
               ExecCtx exec_ctx;
               auto* sl = subchannel_list.get();
               sl->policy_->work_serializer()->Run(
@@ -973,8 +973,7 @@ void PickFirst::SubchannelList::SubchannelData::RequestConnectionWithTimer() {
                     if (subchannel_list->policy_->selected_ != nullptr) return;
                     ++subchannel_list->attempting_index_;
                     subchannel_list->StartConnectingNextSubchannel();
-                  },
-                  DEBUG_LOCATION);
+                  });
             });
   }
 }
@@ -1068,6 +1067,7 @@ void PickFirst::SubchannelList::StartConnectingNextSubchannel() {
       sc->RequestConnectionWithTimer();
       return;
     }
+    sc->set_seen_transient_failure();
   }
   // If we didn't find a subchannel to request a connection on, check to
   // see if the Happy Eyeballs pass is complete.
@@ -1128,7 +1128,7 @@ class OldPickFirst final : public LoadBalancingPolicy {
                      RefCountedPtr<SubchannelInterface> subchannel);
 
       SubchannelInterface* subchannel() const { return subchannel_.get(); }
-      absl::optional<grpc_connectivity_state> connectivity_state() const {
+      std::optional<grpc_connectivity_state> connectivity_state() const {
         return connectivity_state_;
       }
       const absl::Status& connectivity_status() const {
@@ -1151,6 +1151,7 @@ class OldPickFirst final : public LoadBalancingPolicy {
       void ShutdownLocked();
 
       bool seen_transient_failure() const { return seen_transient_failure_; }
+      void set_seen_transient_failure() { seen_transient_failure_ = true; }
 
      private:
       // Watcher for subchannel connectivity state.
@@ -1198,7 +1199,7 @@ class OldPickFirst final : public LoadBalancingPolicy {
       SubchannelInterface::ConnectivityStateWatcherInterface* pending_watcher_ =
           nullptr;
       // Data updated by the watcher.
-      absl::optional<grpc_connectivity_state> connectivity_state_;
+      std::optional<grpc_connectivity_state> connectivity_state_;
       absl::Status connectivity_status_;
       bool seen_transient_failure_ = false;
     };
@@ -1271,7 +1272,7 @@ class OldPickFirst final : public LoadBalancingPolicy {
     // initial pass is over, this will be equal to size().
     size_t attempting_index_ = 0;
     // Happy Eyeballs timer handle.
-    absl::optional<grpc_event_engine::experimental::EventEngine::TaskHandle>
+    std::optional<grpc_event_engine::experimental::EventEngine::TaskHandle>
         timer_handle_;
 
     // After the initial Happy Eyeballs pass, the number of failures
@@ -1647,7 +1648,7 @@ void OldPickFirst::SubchannelList::SubchannelData::OnConnectivityStateChange(
   CHECK(subchannel_list_ == p->subchannel_list_.get() ||
         subchannel_list_ == p->latest_pending_subchannel_list_.get());
   CHECK(new_state != GRPC_CHANNEL_SHUTDOWN);
-  absl::optional<grpc_connectivity_state> old_state = connectivity_state_;
+  std::optional<grpc_connectivity_state> old_state = connectivity_state_;
   connectivity_state_ = new_state;
   connectivity_status_ = std::move(status);
   // Handle updates for the currently selected subchannel.
@@ -1721,10 +1722,8 @@ void OldPickFirst::SubchannelList::SubchannelData::OnConnectivityStateChange(
     ProcessUnselectedReadyLocked();
     return;
   }
-  // Make sure we note when a subchannel has seen TRANSIENT_FAILURE.
-  bool prev_seen_transient_failure = seen_transient_failure_;
+  // Record status for TRANSIENT_FAILURE state.
   if (new_state == GRPC_CHANNEL_TRANSIENT_FAILURE) {
-    seen_transient_failure_ = true;
     subchannel_list_->last_failure_ = connectivity_status_;
   }
   // If this is the initial connectivity state update for this subchannel,
@@ -1753,6 +1752,8 @@ void OldPickFirst::SubchannelList::SubchannelData::OnConnectivityStateChange(
   // Otherwise, process connectivity state change.
   switch (*connectivity_state_) {
     case GRPC_CHANNEL_TRANSIENT_FAILURE: {
+      bool prev_seen_transient_failure =
+          std::exchange(seen_transient_failure_, true);
       // If this is the first failure we've seen on this subchannel,
       // then we're still in the Happy Eyeballs pass.
       if (!prev_seen_transient_failure && seen_transient_failure_) {
@@ -1838,7 +1839,6 @@ void OldPickFirst::SubchannelList::SubchannelData::
             p->connection_attempt_delay_,
             [subchannel_list =
                  subchannel_list_->Ref(DEBUG_LOCATION, "timer")]() mutable {
-              ApplicationCallbackExecCtx application_exec_ctx;
               ExecCtx exec_ctx;
               auto* sl = subchannel_list.get();
               sl->policy_->work_serializer()->Run(
@@ -1854,8 +1854,7 @@ void OldPickFirst::SubchannelList::SubchannelData::
                     if (subchannel_list->policy_->selected_ != nullptr) return;
                     ++subchannel_list->attempting_index_;
                     subchannel_list->StartConnectingNextSubchannel();
-                  },
-                  DEBUG_LOCATION);
+                  });
             });
   }
 }
@@ -2006,6 +2005,7 @@ void OldPickFirst::SubchannelList::StartConnectingNextSubchannel() {
       sc->RequestConnectionWithTimer();
       return;
     }
+    sc->set_seen_transient_failure();
   }
   // If we didn't find a subchannel to request a connection on, check to
   // see if the Happy Eyeballs pass is complete.

data/src/core/load_balancing/priority/priority.cc

@@ -23,6 +23,7 @@
 #include <algorithm>
 #include <map>
 #include <memory>
+#include <optional>
 #include <set>
 #include <string>
 #include <type_traits>
@@ -36,7 +37,6 @@
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_join.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 #include "src/core/config/core_configuration.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/debug/trace.h"
@@ -190,7 +190,7 @@ class PriorityLb final : public LoadBalancingPolicy {
       void OnTimerLocked();
 
       RefCountedPtr<ChildPriority> child_priority_;
-      absl::optional<EventEngine::TaskHandle> timer_handle_;
+      std::optional<EventEngine::TaskHandle> timer_handle_;
     };
 
     class FailoverTimer final : public InternallyRefCounted<FailoverTimer> {
@@ -203,7 +203,7 @@ class PriorityLb final : public LoadBalancingPolicy {
       void OnTimerLocked();
 
       RefCountedPtr<ChildPriority> child_priority_;
-      absl::optional<EventEngine::TaskHandle> timer_handle_;
+      std::optional<EventEngine::TaskHandle> timer_handle_;
     };
 
     // Methods for dealing with the child policy.
@@ -318,7 +318,7 @@ void PriorityLb::ExitIdleLocked() {
 }
 
 void PriorityLb::ResetBackoffLocked() {
-  for (const auto& p : children_) p.second->ResetBackoffLocked();
+  for (const auto& [_, child] : children_) child->ResetBackoffLocked();
 }
 
 absl::Status PriorityLb::UpdateLocked(UpdateArgs args) {
@@ -334,9 +334,7 @@ absl::Status PriorityLb::UpdateLocked(UpdateArgs args) {
   // Check all existing children against the new config.
   update_in_progress_ = true;
   std::vector<std::string> errors;
-  for (const auto& p : children_) {
-    const std::string& child_name = p.first;
-    auto& child = p.second;
+  for (const auto& [child_name, child] : children_) {
     auto config_it = config_->children().find(child_name);
     if (config_it == config_->children().end()) {
       // Existing child not found in new config.  Deactivate it.
@@ -505,12 +503,10 @@ PriorityLb::ChildPriority::DeactivationTimer::DeactivationTimer(
           ->GetEventEngine()
           ->RunAfter(kChildRetentionInterval, [self = Ref(DEBUG_LOCATION,
                                                           "Timer")]() mutable {
-            ApplicationCallbackExecCtx callback_exec_ctx;
             ExecCtx exec_ctx;
             auto self_ptr = self.get();
             self_ptr->child_priority_->priority_policy_->work_serializer()->Run(
-                [self = std::move(self)]() { self->OnTimerLocked(); },
-                DEBUG_LOCATION);
+                [self = std::move(self)]() { self->OnTimerLocked(); });
           });
 }
 
@@ -558,12 +554,11 @@ PriorityLb::ChildPriority::FailoverTimer::FailoverTimer(
           ->RunAfter(
               child_priority_->priority_policy_->child_failover_timeout_,
               [self = Ref(DEBUG_LOCATION, "Timer")]() mutable {
-                ApplicationCallbackExecCtx callback_exec_ctx;
                 ExecCtx exec_ctx;
                 auto self_ptr = self.get();
                 self_ptr->child_priority_->priority_policy_->work_serializer()
-                    ->Run([self = std::move(self)]() { self->OnTimerLocked(); },
-                          DEBUG_LOCATION);
+                    ->Run(
+                        [self = std::move(self)]() { self->OnTimerLocked(); });
               });
 }
 

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>
@@ -40,7 +41,6 @@
 #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"
@@ -249,9 +249,9 @@ class RingHash final : public LoadBalancingPolicy {
           endpoints_(ring_hash_->endpoints_.size()),
           resolution_note_(ring_hash_->resolution_note_),
           request_hash_header_(ring_hash_->request_hash_header_) {
-      for (const auto& p : ring_hash_->endpoint_map_) {
-        endpoints_[p.second->index()] = p.second->GetInfoForPicker();
-        if (endpoints_[p.second->index()].state == GRPC_CHANNEL_CONNECTING) {
+      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;
         }
       }
@@ -276,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_;
@@ -304,13 +302,10 @@ 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_;
@@ -400,7 +395,7 @@ RingHash::PickResult RingHash::Picker::Pick(PickArgs args) {
           new EndpointConnectionAttempter(
               ring_hash_.Ref(DEBUG_LOCATION, "EndpointConnectionAttempter"),
               endpoint_info.endpoint);
-          ABSL_FALLTHROUGH_INTENDED;
+          [[fallthrough]];
         case GRPC_CHANNEL_CONNECTING:
           return PickResult::Queue();
         default:
@@ -663,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);
 }
 
 //
@@ -694,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();
   }
 }
 
@@ -708,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 =
@@ -778,8 +769,7 @@ absl::Status RingHash::UpdateLocked(UpdateArgs args) {
     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, "; "), "]"));
@@ -787,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;
@@ -822,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) {
@@ -866,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,
@@ -894,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();
   }
 }