grpc 1.56.0 → 1.61.0

data/src/core/ext/filters/client_channel/lb_policy/ring_hash/ring_hash.cc

@@ -23,6 +23,7 @@
 
 #include <algorithm>
 #include <cmath>
+#include <map>
 #include <memory>
 #include <string>
 #include <utility>
@@ -32,38 +33,40 @@
 #include "absl/container/inlined_vector.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
-#include "absl/strings/numbers.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 
-#define XXH_INLINE_ALL
-#include "xxhash.h"
-
-#include <grpc/grpc.h>
+#include <grpc/impl/channel_arg_names.h>
 #include <grpc/impl/connectivity_state.h>
+#include <grpc/support/json.h>
 #include <grpc/support/log.h>
 
 #include "src/core/ext/filters/client_channel/client_channel_internal.h"
-#include "src/core/ext/filters/client_channel/lb_policy/subchannel_list.h"
+#include "src/core/ext/filters/client_channel/lb_policy/pick_first/pick_first.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/debug/trace.h"
+#include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/unique_type_name.h"
 #include "src/core/lib/gprpp/work_serializer.h"
+#include "src/core/lib/gprpp/xxhash_inline.h"
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
+#include "src/core/lib/iomgr/pollset_set.h"
+#include "src/core/lib/iomgr/resolved_address.h"
 #include "src/core/lib/json/json.h"
+#include "src/core/lib/load_balancing/delegating_helper.h"
 #include "src/core/lib/load_balancing/lb_policy.h"
 #include "src/core/lib/load_balancing/lb_policy_factory.h"
-#include "src/core/lib/load_balancing/subchannel_interface.h"
-#include "src/core/lib/resolver/server_address.h"
+#include "src/core/lib/load_balancing/lb_policy_registry.h"
+#include "src/core/lib/resolver/endpoint_addresses.h"
 #include "src/core/lib/transport/connectivity_state.h"
 
 namespace grpc_core {
@@ -140,201 +143,155 @@ class RingHash : public LoadBalancingPolicy {
   void ResetBackoffLocked() override;
 
  private:
-  // Forward declaration.
-  class RingHashSubchannelList;
-
-  // Data for a particular subchannel in a subchannel list.
-  // This subclass adds the following functionality:
-  // - Tracks the previous connectivity state of the subchannel, so that
-  //   we know how many subchannels are in each state.
-  class RingHashSubchannelData
-      : public SubchannelData<RingHashSubchannelList, RingHashSubchannelData> {
+  // A ring computed based on a config and address list.
+  class Ring : public RefCounted<Ring> {
    public:
-    RingHashSubchannelData(
-        SubchannelList<RingHashSubchannelList, RingHashSubchannelData>*
-            subchannel_list,
-        const ServerAddress& address,
-        RefCountedPtr<SubchannelInterface> subchannel)
-        : SubchannelData(subchannel_list, address, std::move(subchannel)),
-          address_(address) {}
-
-    const ServerAddress& address() const { return address_; }
-
-    grpc_connectivity_state logical_connectivity_state() const {
-      return logical_connectivity_state_;
-    }
-    const absl::Status& logical_connectivity_status() const {
-      return logical_connectivity_status_;
-    }
+    struct RingEntry {
+      uint64_t hash;
+      size_t endpoint_index;  // Index into RingHash::endpoints_.
+    };
+
+    Ring(RingHash* ring_hash, RingHashLbConfig* config);
+
+    const std::vector<RingEntry>& ring() const { return ring_; }
 
    private:
-    // Performs connectivity state updates that need to be done only
-    // after we have started watching.
-    void ProcessConnectivityChangeLocked(
-        absl::optional<grpc_connectivity_state> old_state,
-        grpc_connectivity_state new_state) override;
-
-    ServerAddress address_;
-
-    // Last logical connectivity state seen.
-    // Note that this may differ from the state actually reported by the
-    // subchannel in some cases; for example, once this is set to
-    // TRANSIENT_FAILURE, we do not change it again until we get READY,
-    // so we skip any interim stops in CONNECTING.
-    grpc_connectivity_state logical_connectivity_state_ = GRPC_CHANNEL_IDLE;
-    absl::Status logical_connectivity_status_;
+    std::vector<RingEntry> ring_;
   };
 
-  // A list of subchannels and the ring containing those subchannels.
-  class RingHashSubchannelList
-      : public SubchannelList<RingHashSubchannelList, RingHashSubchannelData> {
+  // State for a particular endpoint.  Delegates to a pick_first child policy.
+  class RingHashEndpoint : public InternallyRefCounted<RingHashEndpoint> {
    public:
-    class Ring : public RefCounted<Ring> {
-     public:
-      struct RingEntry {
-        uint64_t hash;
-        size_t subchannel_index;
-      };
+    // index is the index into RingHash::endpoints_ of this endpoint.
+    RingHashEndpoint(RefCountedPtr<RingHash> ring_hash, size_t index)
+        : ring_hash_(std::move(ring_hash)), index_(index) {}
 
-      Ring(RingHashLbConfig* config, RingHashSubchannelList* subchannel_list,
-           const ChannelArgs& args);
+    void Orphan() override;
 
-      const std::vector<RingEntry>& ring() const { return ring_; }
+    size_t index() const { return index_; }
 
-     private:
-      std::vector<RingEntry> ring_;
-    };
+    void UpdateLocked(size_t index);
 
-    RingHashSubchannelList(RingHash* policy, ServerAddressList addresses,
-                           const ChannelArgs& args);
+    grpc_connectivity_state connectivity_state() const {
+      return connectivity_state_;
+    }
 
-    ~RingHashSubchannelList() override {
-      RingHash* p = static_cast<RingHash*>(policy());
-      p->Unref(DEBUG_LOCATION, "subchannel_list");
+    // Returns info about the endpoint to be stored in the picker.
+    struct EndpointInfo {
+      RefCountedPtr<RingHashEndpoint> endpoint;
+      RefCountedPtr<SubchannelPicker> picker;
+      grpc_connectivity_state state;
+      absl::Status status;
+    };
+    EndpointInfo GetInfoForPicker() {
+      return {Ref(), picker_, connectivity_state_, status_};
     }
 
-    RefCountedPtr<Ring> ring() { return ring_; }
-
-    // Updates the counters of subchannels in each state when a
-    // subchannel transitions from old_state to new_state.
-    void UpdateStateCountersLocked(grpc_connectivity_state old_state,
-                                   grpc_connectivity_state new_state);
-
-    // Updates the RH policy's connectivity state based on the
-    // subchannel list's state counters, creating new picker and new ring.
-    // The index parameter indicates the index into the list of the subchannel
-    // whose status report triggered the call to
-    // UpdateRingHashConnectivityStateLocked().
-    // connection_attempt_complete is true if the subchannel just
-    // finished a connection attempt.
-    void UpdateRingHashConnectivityStateLocked(size_t index,
-                                               bool connection_attempt_complete,
-                                               absl::Status status);
+    void ResetBackoffLocked();
+
+    // If the child policy does not yet exist, creates it; otherwise,
+    // asks the child to exit IDLE.
+    void RequestConnectionLocked();
 
    private:
-    std::shared_ptr<WorkSerializer> work_serializer() const override {
-      return static_cast<RingHash*>(policy())->work_serializer();
-    }
+    class Helper;
 
-    size_t num_idle_;
-    size_t num_ready_ = 0;
-    size_t num_connecting_ = 0;
-    size_t num_transient_failure_ = 0;
+    void CreateChildPolicy();
+    void UpdateChildPolicyLocked();
 
-    RefCountedPtr<Ring> ring_;
+    // Called when the child policy reports a connectivity state update.
+    void OnStateUpdate(grpc_connectivity_state new_state,
+                       const absl::Status& status,
+                       RefCountedPtr<SubchannelPicker> picker);
+
+    // Ref to our parent.
+    RefCountedPtr<RingHash> ring_hash_;
+    size_t index_;  // Index into RingHash::endpoints_ of this endpoint.
 
-    // The index of the subchannel currently doing an internally
-    // triggered connection attempt, if any.
-    absl::optional<size_t> internally_triggered_connection_index_;
+    // The pick_first child policy.
+    OrphanablePtr<LoadBalancingPolicy> child_policy_;
 
-    // TODO(roth): If we ever change the helper UpdateState() API to not
-    // need the status reported for TRANSIENT_FAILURE state (because
-    // it's not currently actually used for anything outside of the picker),
-    // then we will no longer need this data member.
-    absl::Status last_failure_;
+    grpc_connectivity_state connectivity_state_ = GRPC_CHANNEL_IDLE;
+    absl::Status status_;
+    RefCountedPtr<SubchannelPicker> picker_;
   };
 
   class Picker : public SubchannelPicker {
    public:
-    Picker(RefCountedPtr<RingHash> ring_hash_lb,
-           RingHashSubchannelList* subchannel_list)
-        : ring_hash_lb_(std::move(ring_hash_lb)),
-          ring_(subchannel_list->ring()) {
-      subchannels_.reserve(subchannel_list->num_subchannels());
-      for (size_t i = 0; i < subchannel_list->num_subchannels(); ++i) {
-        RingHashSubchannelData* subchannel_data =
-            subchannel_list->subchannel(i);
-        subchannels_.emplace_back(
-            SubchannelInfo{subchannel_data->subchannel()->Ref(),
-                           subchannel_data->logical_connectivity_state(),
-                           subchannel_data->logical_connectivity_status()});
+    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();
       }
     }
 
     PickResult Pick(PickArgs args) override;
 
    private:
-    // A fire-and-forget class that schedules subchannel connection attempts
+    // A fire-and-forget class that schedules endpoint connection attempts
     // on the control plane WorkSerializer.
-    class SubchannelConnectionAttempter : public Orphanable {
+    class EndpointConnectionAttempter {
      public:
-      explicit SubchannelConnectionAttempter(
-          RefCountedPtr<RingHash> ring_hash_lb)
-          : ring_hash_lb_(std::move(ring_hash_lb)) {
-        GRPC_CLOSURE_INIT(&closure_, RunInExecCtx, this, nullptr);
-      }
-
-      void Orphan() override {
+      EndpointConnectionAttempter(RefCountedPtr<RingHash> ring_hash,
+                                  RefCountedPtr<RingHashEndpoint> endpoint)
+          : ring_hash_(std::move(ring_hash)), endpoint_(std::move(endpoint)) {
         // Hop into ExecCtx, so that we're not holding the data plane mutex
         // while we run control-plane code.
+        GRPC_CLOSURE_INIT(&closure_, RunInExecCtx, this, nullptr);
         ExecCtx::Run(DEBUG_LOCATION, &closure_, absl::OkStatus());
       }
 
-      void AddSubchannel(RefCountedPtr<SubchannelInterface> subchannel) {
-        subchannels_.push_back(std::move(subchannel));
-      }
-
      private:
       static void RunInExecCtx(void* arg, grpc_error_handle /*error*/) {
-        auto* self = static_cast<SubchannelConnectionAttempter*>(arg);
-        self->ring_hash_lb_->work_serializer()->Run(
+        auto* self = static_cast<EndpointConnectionAttempter*>(arg);
+        self->ring_hash_->work_serializer()->Run(
             [self]() {
-              if (!self->ring_hash_lb_->shutdown_) {
-                for (auto& subchannel : self->subchannels_) {
-                  subchannel->RequestConnection();
-                }
+              if (!self->ring_hash_->shutdown_) {
+                self->endpoint_->RequestConnectionLocked();
               }
               delete self;
             },
             DEBUG_LOCATION);
       }
 
-      RefCountedPtr<RingHash> ring_hash_lb_;
+      RefCountedPtr<RingHash> ring_hash_;
+      RefCountedPtr<RingHashEndpoint> endpoint_;
       grpc_closure closure_;
-      std::vector<RefCountedPtr<SubchannelInterface>> subchannels_;
-    };
-
-    struct SubchannelInfo {
-      RefCountedPtr<SubchannelInterface> subchannel;
-      grpc_connectivity_state state;
-      absl::Status status;
     };
 
-    RefCountedPtr<RingHash> ring_hash_lb_;
-    RefCountedPtr<RingHashSubchannelList::Ring> ring_;
-    std::vector<SubchannelInfo> subchannels_;
+    RefCountedPtr<RingHash> ring_hash_;
+    RefCountedPtr<Ring> ring_;
+    std::vector<RingHashEndpoint::EndpointInfo> endpoints_;
   };
 
   ~RingHash() override;
 
   void ShutdownLocked() override;
 
-  // Current config from resolver.
-  RefCountedPtr<RingHashLbConfig> config_;
+  // 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.
+  // 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);
+
+  // Current endpoint list, channel args, and ring.
+  EndpointAddressesList endpoints_;
+  ChannelArgs args_;
+  RefCountedPtr<Ring> ring_;
+
+  std::map<EndpointAddressSet, OrphanablePtr<RingHashEndpoint>> endpoint_map_;
+
+  // TODO(roth): If we ever change the helper UpdateState() API to not
+  // need the status reported for TRANSIENT_FAILURE state (because
+  // it's not currently actually used for anything outside of the picker),
+  // then we will no longer need this data member.
+  absl::Status last_failure_;
 
-  // list of subchannels.
-  RefCountedPtr<RingHashSubchannelList> subchannel_list_;
-  RefCountedPtr<RingHashSubchannelList> latest_pending_subchannel_list_;
   // indicating if we are shutting down.
   bool shutdown_ = false;
 };
@@ -347,152 +304,102 @@ RingHash::PickResult RingHash::Picker::Pick(PickArgs args) {
   auto* call_state = static_cast<ClientChannelLbCallState*>(args.call_state);
   auto* hash_attribute = static_cast<RequestHashAttribute*>(
       call_state->GetCallAttribute(RequestHashAttribute::TypeName()));
-  absl::string_view hash;
-  if (hash_attribute != nullptr) {
-    hash = hash_attribute->request_hash();
-  }
-  uint64_t h;
-  if (!absl::SimpleAtoi(hash, &h)) {
-    return PickResult::Fail(
-        absl::InternalError("ring hash value is not a number"));
+  if (hash_attribute == nullptr) {
+    return PickResult::Fail(absl::InternalError("hash attribute not present"));
   }
+  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 first_index. Do not change them!
+  // for lowp, highp, and index. Do not change them!
   int64_t lowp = 0;
   int64_t highp = ring.size();
-  int64_t first_index = 0;
+  int64_t index = 0;
   while (true) {
-    first_index = (lowp + highp) / 2;
-    if (first_index == static_cast<int64_t>(ring.size())) {
-      first_index = 0;
+    index = (lowp + highp) / 2;
+    if (index == static_cast<int64_t>(ring.size())) {
+      index = 0;
       break;
     }
-    uint64_t midval = ring[first_index].hash;
-    uint64_t midval1 = first_index == 0 ? 0 : ring[first_index - 1].hash;
-    if (h <= midval && h > midval1) {
+    uint64_t midval = ring[index].hash;
+    uint64_t midval1 = index == 0 ? 0 : ring[index - 1].hash;
+    if (request_hash <= midval && request_hash > midval1) {
       break;
     }
-    if (midval < h) {
-      lowp = first_index + 1;
+    if (midval < request_hash) {
+      lowp = index + 1;
     } else {
-      highp = first_index - 1;
+      highp = index - 1;
     }
     if (lowp > highp) {
-      first_index = 0;
+      index = 0;
       break;
     }
   }
-  OrphanablePtr<SubchannelConnectionAttempter> subchannel_connection_attempter;
-  auto ScheduleSubchannelConnectionAttempt =
-      [&](RefCountedPtr<SubchannelInterface> subchannel) {
-        if (subchannel_connection_attempter == nullptr) {
-          subchannel_connection_attempter =
-              MakeOrphanable<SubchannelConnectionAttempter>(ring_hash_lb_->Ref(
-                  DEBUG_LOCATION, "SubchannelConnectionAttempter"));
-        }
-        subchannel_connection_attempter->AddSubchannel(std::move(subchannel));
-      };
-  SubchannelInfo& first_subchannel =
-      subchannels_[ring[first_index].subchannel_index];
-  switch (first_subchannel.state) {
-    case GRPC_CHANNEL_READY:
-      return PickResult::Complete(first_subchannel.subchannel);
-    case GRPC_CHANNEL_IDLE:
-      ScheduleSubchannelConnectionAttempt(first_subchannel.subchannel);
-      ABSL_FALLTHROUGH_INTENDED;
-    case GRPC_CHANNEL_CONNECTING:
-      return PickResult::Queue();
-    default:  // GRPC_CHANNEL_TRANSIENT_FAILURE
-      break;
-  }
-  ScheduleSubchannelConnectionAttempt(first_subchannel.subchannel);
-  // Loop through remaining subchannels to find one in READY.
-  // On the way, we make sure the right set of connection attempts
-  // will happen.
-  bool found_second_subchannel = false;
-  bool found_first_non_failed = false;
-  for (size_t i = 1; i < ring.size(); ++i) {
-    const auto& entry = ring[(first_index + i) % ring.size()];
-    if (entry.subchannel_index == ring[first_index].subchannel_index) {
-      continue;
-    }
-    SubchannelInfo& subchannel_info = subchannels_[entry.subchannel_index];
-    if (subchannel_info.state == GRPC_CHANNEL_READY) {
-      return PickResult::Complete(subchannel_info.subchannel);
-    }
-    if (!found_second_subchannel) {
-      switch (subchannel_info.state) {
-        case GRPC_CHANNEL_IDLE:
-          ScheduleSubchannelConnectionAttempt(subchannel_info.subchannel);
-          ABSL_FALLTHROUGH_INTENDED;
-        case GRPC_CHANNEL_CONNECTING:
-          return PickResult::Queue();
-        default:
-          break;
-      }
-      found_second_subchannel = true;
-    }
-    if (!found_first_non_failed) {
-      if (subchannel_info.state == GRPC_CHANNEL_TRANSIENT_FAILURE) {
-        ScheduleSubchannelConnectionAttempt(subchannel_info.subchannel);
-      } else {
-        if (subchannel_info.state == GRPC_CHANNEL_IDLE) {
-          ScheduleSubchannelConnectionAttempt(subchannel_info.subchannel);
-        }
-        found_first_non_failed = true;
-      }
+  // 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:
+        return endpoint_info.picker->Pick(args);
+      case 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;
     }
   }
   return PickResult::Fail(absl::UnavailableError(absl::StrCat(
-      "ring hash cannot find a connected subchannel; first failure: ",
-      first_subchannel.status.ToString())));
+      "ring hash cannot find a connected endpoint; first failure: ",
+      endpoints_[ring[index].endpoint_index].status.message())));
 }
 
 //
-// RingHash::RingHashSubchannelList::Ring
+// RingHash::Ring
 //
 
-RingHash::RingHashSubchannelList::Ring::Ring(
-    RingHashLbConfig* config, RingHashSubchannelList* subchannel_list,
-    const ChannelArgs& args) {
+RingHash::Ring::Ring(RingHash* ring_hash, RingHashLbConfig* config) {
   // Store the weights while finding the sum.
-  struct AddressWeight {
-    std::string address;
+  struct EndpointWeight {
+    std::string address;  // Key by 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;
     double normalized_weight;
   };
-  std::vector<AddressWeight> address_weights;
+  std::vector<EndpointWeight> endpoint_weights;
   size_t sum = 0;
-  address_weights.reserve(subchannel_list->num_subchannels());
-  for (size_t i = 0; i < subchannel_list->num_subchannels(); ++i) {
-    RingHashSubchannelData* sd = subchannel_list->subchannel(i);
-    const ServerAddressWeightAttribute* weight_attribute = static_cast<
-        const ServerAddressWeightAttribute*>(sd->address().GetAttribute(
-        ServerAddressWeightAttribute::kServerAddressWeightAttributeKey));
-    AddressWeight address_weight;
-    address_weight.address =
-        grpc_sockaddr_to_string(&sd->address().address(), false).value();
+  const EndpointAddressesList& endpoints = ring_hash->endpoints_;
+  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();
     // Weight should never be zero, but ignore it just in case, since
     // that value would screw up the ring-building algorithm.
-    if (weight_attribute != nullptr && weight_attribute->weight() > 0) {
-      address_weight.weight = weight_attribute->weight();
+    auto weight_arg = endpoint.args().GetInt(GRPC_ARG_ADDRESS_WEIGHT);
+    if (weight_arg.value_or(0) > 0) {
+      endpoint_weight.weight = *weight_arg;
     }
-    sum += address_weight.weight;
-    address_weights.push_back(std::move(address_weight));
+    sum += endpoint_weight.weight;
+    endpoint_weights.push_back(std::move(endpoint_weight));
   }
   // Calculating normalized weights and find min and max.
   double min_normalized_weight = 1.0;
   double max_normalized_weight = 0.0;
-  for (auto& address : address_weights) {
-    address.normalized_weight = static_cast<double>(address.weight) / sum;
+  for (auto& endpoint_weight : endpoint_weights) {
+    endpoint_weight.normalized_weight =
+        static_cast<double>(endpoint_weight.weight) / sum;
     min_normalized_weight =
-        std::min(address.normalized_weight, min_normalized_weight);
+        std::min(endpoint_weight.normalized_weight, min_normalized_weight);
     max_normalized_weight =
-        std::max(address.normalized_weight, max_normalized_weight);
+        std::max(endpoint_weight.normalized_weight, max_normalized_weight);
   }
   // Scale up the number of hashes per host such that the least-weighted host
   // gets a whole number of hashes on the ring. Other hosts might not end up
@@ -501,8 +408,9 @@ RingHash::RingHashSubchannelList::Ring::Ring(
   // weights aren't provided, all hosts should get an equal number of hashes. In
   // the case where this number exceeds the max_ring_size, it's scaled back down
   // to fit.
-  const size_t ring_size_cap = args.GetInt(GRPC_ARG_RING_HASH_LB_RING_SIZE_CAP)
-                                   .value_or(kRingSizeCapDefault);
+  const size_t ring_size_cap =
+      ring_hash->args_.GetInt(GRPC_ARG_RING_HASH_LB_RING_SIZE_CAP)
+          .value_or(kRingSizeCapDefault);
   const size_t min_ring_size = std::min(config->min_ring_size(), ring_size_cap);
   const size_t max_ring_size = std::min(config->max_ring_size(), ring_size_cap);
   const double scale = std::min(
@@ -521,12 +429,12 @@ RingHash::RingHashSubchannelList::Ring::Ring(
   double target_hashes = 0.0;
   uint64_t min_hashes_per_host = ring_size;
   uint64_t max_hashes_per_host = 0;
-  for (size_t i = 0; i < subchannel_list->num_subchannels(); ++i) {
-    const std::string& address_string = address_weights[i].address;
+  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());
     hash_key_buffer.emplace_back('_');
     auto offset_start = hash_key_buffer.end();
-    target_hashes += scale * address_weights[i].normalized_weight;
+    target_hashes += scale * endpoint_weights[i].normalized_weight;
     size_t count = 0;
     while (current_hashes < target_hashes) {
       const std::string count_str = absl::StrCat(count);
@@ -551,210 +459,134 @@ RingHash::RingHashSubchannelList::Ring::Ring(
 }
 
 //
-// RingHash::RingHashSubchannelList
+// RingHash::RingHashEndpoint::Helper
 //
 
-RingHash::RingHashSubchannelList::RingHashSubchannelList(
-    RingHash* policy, ServerAddressList addresses, const ChannelArgs& args)
-    : SubchannelList(policy,
-                     (GRPC_TRACE_FLAG_ENABLED(grpc_lb_ring_hash_trace)
-                          ? "RingHashSubchannelList"
-                          : nullptr),
-                     std::move(addresses), policy->channel_control_helper(),
-                     args),
-      num_idle_(num_subchannels()) {
-  // Need to maintain a ref to the LB policy as long as we maintain
-  // any references to subchannels, since the subchannels'
-  // pollset_sets will include the LB policy's pollset_set.
-  policy->Ref(DEBUG_LOCATION, "subchannel_list").release();
-  // Construct the ring.
-  ring_ = MakeRefCounted<Ring>(policy->config_.get(), this, args);
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_ring_hash_trace)) {
-    gpr_log(GPR_INFO,
-            "[RH %p] created subchannel list %p with %" PRIuPTR " ring entries",
-            policy, this, ring_->ring().size());
+class RingHash::RingHashEndpoint::Helper
+    : public LoadBalancingPolicy::DelegatingChannelControlHelper {
+ public:
+  explicit Helper(RefCountedPtr<RingHashEndpoint> endpoint)
+      : endpoint_(std::move(endpoint)) {}
+
+  ~Helper() override { endpoint_.reset(DEBUG_LOCATION, "Helper"); }
+
+  void UpdateState(
+      grpc_connectivity_state state, const absl::Status& status,
+      RefCountedPtr<LoadBalancingPolicy::SubchannelPicker> picker) override {
+    endpoint_->OnStateUpdate(state, status, std::move(picker));
   }
-}
 
-void RingHash::RingHashSubchannelList::UpdateStateCountersLocked(
-    grpc_connectivity_state old_state, grpc_connectivity_state new_state) {
-  if (old_state == GRPC_CHANNEL_IDLE) {
-    GPR_ASSERT(num_idle_ > 0);
-    --num_idle_;
-  } else if (old_state == GRPC_CHANNEL_READY) {
-    GPR_ASSERT(num_ready_ > 0);
-    --num_ready_;
-  } else if (old_state == GRPC_CHANNEL_CONNECTING) {
-    GPR_ASSERT(num_connecting_ > 0);
-    --num_connecting_;
-  } else if (old_state == GRPC_CHANNEL_TRANSIENT_FAILURE) {
-    GPR_ASSERT(num_transient_failure_ > 0);
-    --num_transient_failure_;
+ private:
+  LoadBalancingPolicy::ChannelControlHelper* parent_helper() const override {
+    return endpoint_->ring_hash_->channel_control_helper();
   }
-  GPR_ASSERT(new_state != GRPC_CHANNEL_SHUTDOWN);
-  if (new_state == GRPC_CHANNEL_IDLE) {
-    ++num_idle_;
-  } else if (new_state == GRPC_CHANNEL_READY) {
-    ++num_ready_;
-  } else if (new_state == GRPC_CHANNEL_CONNECTING) {
-    ++num_connecting_;
-  } else if (new_state == GRPC_CHANNEL_TRANSIENT_FAILURE) {
-    ++num_transient_failure_;
+
+  RefCountedPtr<RingHashEndpoint> endpoint_;
+};
+
+//
+// RingHash::RingHashEndpoint
+//
+
+void RingHash::RingHashEndpoint::Orphan() {
+  if (child_policy_ != nullptr) {
+    // Remove pollset_set linkage.
+    grpc_pollset_set_del_pollset_set(child_policy_->interested_parties(),
+                                     ring_hash_->interested_parties());
+    child_policy_.reset();
+    picker_.reset();
   }
+  Unref();
 }
 
-void RingHash::RingHashSubchannelList::UpdateRingHashConnectivityStateLocked(
-    size_t index, bool connection_attempt_complete, absl::Status status) {
-  RingHash* p = static_cast<RingHash*>(policy());
-  // If this is latest_pending_subchannel_list_, then swap it into
-  // subchannel_list_ as soon as we get the initial connectivity state
-  // report for every subchannel in the list.
-  if (p->latest_pending_subchannel_list_.get() == this &&
-      AllSubchannelsSeenInitialState()) {
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_ring_hash_trace)) {
-      gpr_log(GPR_INFO, "[RH %p] replacing subchannel list %p with %p", p,
-              p->subchannel_list_.get(), this);
-    }
-    p->subchannel_list_ = std::move(p->latest_pending_subchannel_list_);
-  }
-  // Only set connectivity state if this is the current subchannel list.
-  if (p->subchannel_list_.get() != this) return;
-  // The overall aggregation rules here are:
-  // 1. If there is at least one subchannel in READY state, report READY.
-  // 2. If there are 2 or more subchannels in TRANSIENT_FAILURE state, report
-  //    TRANSIENT_FAILURE.
-  // 3. If there is at least one subchannel in CONNECTING state, report
-  //    CONNECTING.
-  // 4. If there is one subchannel in TRANSIENT_FAILURE state and there is
-  //    more than one subchannel, report CONNECTING.
-  // 5. If there is at least one subchannel in IDLE state, report IDLE.
-  // 6. Otherwise, report TRANSIENT_FAILURE.
-  //
-  // We set start_connection_attempt to true if we match rules 2, 3, 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 && num_subchannels() > 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;
-  }
-  // In TRANSIENT_FAILURE, report the last reported failure.
-  // Otherwise, report OK.
-  if (state == GRPC_CHANNEL_TRANSIENT_FAILURE) {
-    if (!status.ok()) {
-      last_failure_ = absl::UnavailableError(absl::StrCat(
-          "no reachable subchannels; last error: ", status.ToString()));
-    }
-    status = last_failure_;
+void RingHash::RingHashEndpoint::UpdateLocked(size_t index) {
+  index_ = index;
+  if (child_policy_ != nullptr) UpdateChildPolicyLocked();
+}
+
+void RingHash::RingHashEndpoint::ResetBackoffLocked() {
+  if (child_policy_ != nullptr) child_policy_->ResetBackoffLocked();
+}
+
+void RingHash::RingHashEndpoint::RequestConnectionLocked() {
+  if (child_policy_ == nullptr) {
+    CreateChildPolicy();
   } else {
-    status = absl::OkStatus();
+    child_policy_->ExitIdleLocked();
   }
-  // Generate new picker and return it to the channel.
-  // Note that we use our own picker regardless of connectivity state.
-  p->channel_control_helper()->UpdateState(
-      state, status,
-      MakeRefCounted<Picker>(p->Ref(DEBUG_LOCATION, "RingHashPicker"), this));
-  // 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 subchannels 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 subchannel at any given time.  After a given subchannel
-  // fails a connection attempt, it will move on to the next subchannel
-  // in the ring.  It will keep doing this until one of the subchannels
-  // successfully connects, at which point it will report READY and stop
-  // proactively trying to connect.  The policy will remain in
-  // TRANSIENT_FAILURE until at least one subchannel becomes connected,
-  // even if subchannels are in state CONNECTING during that time.
-  //
-  // 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 (internally_triggered_connection_index_.has_value() &&
-      *internally_triggered_connection_index_ == index &&
-      connection_attempt_complete) {
-    internally_triggered_connection_index_.reset();
-  }
-  if (start_connection_attempt &&
-      !internally_triggered_connection_index_.has_value()) {
-    size_t next_index = (index + 1) % num_subchannels();
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_ring_hash_trace)) {
-      gpr_log(GPR_INFO,
-              "[RH %p] triggering internal connection attempt for subchannel "
-              "%p, subchannel_list %p (index %" PRIuPTR " of %" PRIuPTR ")",
-              p, subchannel(next_index)->subchannel(), this, next_index,
-              num_subchannels());
-    }
-    internally_triggered_connection_index_ = next_index;
-    subchannel(next_index)->subchannel()->RequestConnection();
+}
+
+void RingHash::RingHashEndpoint::CreateChildPolicy() {
+  GPR_ASSERT(child_policy_ == nullptr);
+  LoadBalancingPolicy::Args lb_policy_args;
+  lb_policy_args.work_serializer = ring_hash_->work_serializer();
+  lb_policy_args.args =
+      ring_hash_->args_
+          .Set(GRPC_ARG_INTERNAL_PICK_FIRST_ENABLE_HEALTH_CHECKING, true)
+          .Set(GRPC_ARG_INTERNAL_PICK_FIRST_OMIT_STATUS_MESSAGE_PREFIX, true);
+  lb_policy_args.channel_control_helper =
+      std::make_unique<Helper>(Ref(DEBUG_LOCATION, "Helper"));
+  child_policy_ =
+      CoreConfiguration::Get().lb_policy_registry().CreateLoadBalancingPolicy(
+          "pick_first", std::move(lb_policy_args));
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_ring_hash_trace)) {
+    const EndpointAddresses& endpoint = ring_hash_->endpoints_[index_];
+    gpr_log(GPR_INFO,
+            "[RH %p] endpoint %p (index %" PRIuPTR " of %" PRIuPTR
+            ", %s): created child policy %p",
+            ring_hash_.get(), this, index_, ring_hash_->endpoints_.size(),
+            endpoint.ToString().c_str(), child_policy_.get());
   }
+  // Add our interested_parties pollset_set to that of the newly created
+  // child policy. This will make the child policy progress upon activity on
+  // this policy, which in turn is tied to the application's call.
+  grpc_pollset_set_add_pollset_set(child_policy_->interested_parties(),
+                                   ring_hash_->interested_parties());
+  UpdateChildPolicyLocked();
 }
 
-//
-// RingHash::RingHashSubchannelData
-//
+void RingHash::RingHashEndpoint::UpdateChildPolicyLocked() {
+  // Construct pick_first config.
+  auto config =
+      CoreConfiguration::Get().lb_policy_registry().ParseLoadBalancingConfig(
+          Json::FromArray(
+              {Json::FromObject({{"pick_first", Json::FromObject({})}})}));
+  GPR_ASSERT(config.ok());
+  // Update child policy.
+  LoadBalancingPolicy::UpdateArgs update_args;
+  update_args.addresses =
+      std::make_shared<SingleEndpointIterator>(ring_hash_->endpoints_[index_]);
+  update_args.args = ring_hash_->args_;
+  update_args.config = std::move(*config);
+  // TODO(roth): If the child reports a non-OK status with the update,
+  // we need to propagate that back to the resolver somehow.
+  (void)child_policy_->UpdateLocked(std::move(update_args));
+}
 
-void RingHash::RingHashSubchannelData::ProcessConnectivityChangeLocked(
-    absl::optional<grpc_connectivity_state> old_state,
-    grpc_connectivity_state new_state) {
-  RingHash* p = static_cast<RingHash*>(subchannel_list()->policy());
+void RingHash::RingHashEndpoint::OnStateUpdate(
+    grpc_connectivity_state new_state, const absl::Status& status,
+    RefCountedPtr<SubchannelPicker> picker) {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_ring_hash_trace)) {
     gpr_log(
         GPR_INFO,
-        "[RH %p] connectivity changed for subchannel %p, subchannel_list %p "
-        "(index %" PRIuPTR " of %" PRIuPTR "): prev_state=%s new_state=%s",
-        p, subchannel(), subchannel_list(), Index(),
-        subchannel_list()->num_subchannels(),
-        ConnectivityStateName(logical_connectivity_state_),
-        ConnectivityStateName(new_state));
-  }
-  GPR_ASSERT(subchannel() != nullptr);
-  // If this is not the initial state notification and the new state is
-  // TRANSIENT_FAILURE or IDLE, re-resolve.
-  // Note that we don't want to do this on the initial state notification,
-  // because that would result in an endless loop of re-resolution.
-  if (old_state.has_value() && (new_state == GRPC_CHANNEL_TRANSIENT_FAILURE ||
-                                new_state == GRPC_CHANNEL_IDLE)) {
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_ring_hash_trace)) {
-      gpr_log(GPR_INFO,
-              "[RH %p] Subchannel %p reported %s; requesting re-resolution", p,
-              subchannel(), ConnectivityStateName(new_state));
-    }
-    p->channel_control_helper()->RequestReresolution();
-  }
-  const bool connection_attempt_complete = new_state != GRPC_CHANNEL_CONNECTING;
-  // Decide what state to report for the purposes of aggregation and
-  // picker behavior.
-  // If the last recorded state was TRANSIENT_FAILURE, ignore the change
-  // unless the new state is READY (or TF again, in which case we need
-  // to update the status).
-  if (logical_connectivity_state_ != GRPC_CHANNEL_TRANSIENT_FAILURE ||
-      new_state == GRPC_CHANNEL_READY ||
-      new_state == GRPC_CHANNEL_TRANSIENT_FAILURE) {
-    // Update state counters used for aggregation.
-    subchannel_list()->UpdateStateCountersLocked(logical_connectivity_state_,
-                                                 new_state);
-    // Update logical state.
-    logical_connectivity_state_ = new_state;
-    logical_connectivity_status_ = connectivity_status();
+        "[RH %p] connectivity changed for endpoint %p (%s, child_policy=%p): "
+        "prev_state=%s new_state=%s (%s)",
+        ring_hash_.get(), this,
+        ring_hash_->endpoints_[index_].ToString().c_str(), child_policy_.get(),
+        ConnectivityStateName(connectivity_state_),
+        ConnectivityStateName(new_state), status.ToString().c_str());
   }
-  // Update the RH policy's connectivity state, creating new picker and new
-  // ring.
-  subchannel_list()->UpdateRingHashConnectivityStateLocked(
-      Index(), connection_attempt_complete, logical_connectivity_status_);
+  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);
 }
 
 //
@@ -771,8 +603,6 @@ RingHash::~RingHash() {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_ring_hash_trace)) {
     gpr_log(GPR_INFO, "[RH %p] Destroying Ring Hash policy", this);
   }
-  GPR_ASSERT(subchannel_list_ == nullptr);
-  GPR_ASSERT(latest_pending_subchannel_list_ == nullptr);
 }
 
 void RingHash::ShutdownLocked() {
@@ -780,73 +610,239 @@ void RingHash::ShutdownLocked() {
     gpr_log(GPR_INFO, "[RH %p] Shutting down", this);
   }
   shutdown_ = true;
-  subchannel_list_.reset();
-  latest_pending_subchannel_list_.reset();
+  endpoint_map_.clear();
 }
 
 void RingHash::ResetBackoffLocked() {
-  subchannel_list_->ResetBackoffLocked();
-  if (latest_pending_subchannel_list_ != nullptr) {
-    latest_pending_subchannel_list_->ResetBackoffLocked();
+  for (const auto& p : endpoint_map_) {
+    p.second->ResetBackoffLocked();
   }
 }
 
 absl::Status RingHash::UpdateLocked(UpdateArgs args) {
-  config_ = std::move(args.config);
-  ServerAddressList addresses;
+  // Check address list.
   if (args.addresses.ok()) {
     if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_ring_hash_trace)) {
-      gpr_log(GPR_INFO, "[RH %p] received update with %" PRIuPTR " addresses",
-              this, args.addresses->size());
+      gpr_log(GPR_INFO, "[RH %p] received update", this);
     }
-    addresses = *std::move(args.addresses);
+    // De-dup endpoints, taking weight into account.
+    endpoints_.clear();
+    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) {
+        // Duplicate endpoint.  Combine weights and skip the dup.
+        EndpointAddresses& prev_endpoint = endpoints_[p.first->second];
+        int weight_arg =
+            endpoint.args().GetInt(GRPC_ARG_ADDRESS_WEIGHT).value_or(1);
+        int prev_weight_arg =
+            prev_endpoint.args().GetInt(GRPC_ARG_ADDRESS_WEIGHT).value_or(1);
+        if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_ring_hash_trace)) {
+          gpr_log(GPR_INFO,
+                  "[RH %p] merging duplicate endpoint for %s, combined "
+                  "weight %d",
+                  this, key.ToString().c_str(), weight_arg + prev_weight_arg);
+        }
+        prev_endpoint = EndpointAddresses(
+            prev_endpoint.addresses(),
+            prev_endpoint.args().Set(GRPC_ARG_ADDRESS_WEIGHT,
+                                     weight_arg + prev_weight_arg));
+      } else {
+        endpoints_.push_back(endpoint);
+      }
+    });
   } else {
     if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_ring_hash_trace)) {
       gpr_log(GPR_INFO, "[RH %p] received update with addresses error: %s",
               this, args.addresses.status().ToString().c_str());
     }
-    // If we already have a subchannel list, then keep using the existing
+    // If we already have an endpoint list, then keep using the existing
     // list, but still report back that the update was not accepted.
-    if (subchannel_list_ != nullptr) return args.addresses.status();
+    if (!endpoints_.empty()) return args.addresses.status();
+  }
+  // Save channel args.
+  args_ = std::move(args.args);
+  // Build new ring.
+  ring_ = MakeRefCounted<Ring>(
+      this, static_cast<RingHashLbConfig*>(args.config.get()));
+  // Update endpoint map.
+  std::map<EndpointAddressSet, OrphanablePtr<RingHashEndpoint>> endpoint_map;
+  for (size_t i = 0; i < endpoints_.size(); ++i) {
+    const EndpointAddresses& addresses = endpoints_[i];
+    const EndpointAddressSet address_set(addresses.addresses());
+    // If present in old map, retain it; otherwise, create a new one.
+    auto it = endpoint_map_.find(address_set);
+    if (it != endpoint_map_.end()) {
+      it->second->UpdateLocked(i);
+      endpoint_map.emplace(address_set, std::move(it->second));
+    } else {
+      endpoint_map.emplace(address_set, MakeOrphanable<RingHashEndpoint>(
+                                            RefAsSubclass<RingHash>(), i));
+    }
   }
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_ring_hash_trace) &&
-      latest_pending_subchannel_list_ != nullptr) {
-    gpr_log(GPR_INFO, "[RH %p] replacing latest pending subchannel list %p",
-            this, latest_pending_subchannel_list_.get());
+  endpoint_map_ = std::move(endpoint_map);
+  // 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();
+    channel_control_helper()->UpdateState(
+        GRPC_CHANNEL_TRANSIENT_FAILURE, status,
+        MakeRefCounted<TransientFailurePicker>(status));
+    return status;
   }
-  latest_pending_subchannel_list_ = MakeRefCounted<RingHashSubchannelList>(
-      this, std::move(addresses), args.args);
-  latest_pending_subchannel_list_->StartWatchingLocked();
-  // If we have no existing list or the new list is empty, immediately
-  // promote the new list.
-  // Otherwise, do nothing; the new list will be promoted when the
-  // initial subchannel states are reported.
-  if (subchannel_list_ == nullptr ||
-      latest_pending_subchannel_list_->num_subchannels() == 0) {
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_ring_hash_trace) &&
-        subchannel_list_ != nullptr) {
-      gpr_log(GPR_INFO,
-              "[RH %p] empty address list, replacing subchannel list %p", this,
-              subchannel_list_.get());
+  // Return a new picker.
+  UpdateAggregatedConnectivityStateLocked(/*entered_transient_failure=*/false,
+                                          absl::OkStatus());
+  return absl::OkStatus();
+}
+
+void RingHash::UpdateAggregatedConnectivityStateLocked(
+    bool entered_transient_failure, 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()) {
+      case GRPC_CHANNEL_READY:
+        ++num_ready;
+        break;
+      case GRPC_CHANNEL_IDLE:
+        ++num_idle;
+        break;
+      case GRPC_CHANNEL_CONNECTING:
+        ++num_connecting;
+        break;
+      case GRPC_CHANNEL_TRANSIENT_FAILURE:
+        ++num_transient_failure;
+        break;
+      default:
+        Crash("child policy should never report SHUTDOWN");
     }
-    subchannel_list_ = std::move(latest_pending_subchannel_list_);
-    // If the new list is empty, report TRANSIENT_FAILURE.
-    if (subchannel_list_->num_subchannels() == 0) {
-      absl::Status status =
-          args.addresses.ok()
-              ? absl::UnavailableError(
-                    absl::StrCat("empty address list: ", args.resolution_note))
-              : args.addresses.status();
-      channel_control_helper()->UpdateState(
-          GRPC_CHANNEL_TRANSIENT_FAILURE, status,
-          MakeRefCounted<TransientFailurePicker>(status));
-      return status;
+  }
+  // The overall aggregation rules here are:
+  // 1. If there is at least one endpoint in READY state, report READY.
+  // 2. If there are 2 or more endpoints in TRANSIENT_FAILURE state, report
+  //    TRANSIENT_FAILURE.
+  // 3. If there is at least one endpoint in CONNECTING state, report
+  //    CONNECTING.
+  // 4. If there is one endpoint in TRANSIENT_FAILURE state and there is
+  //    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;
+  }
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_ring_hash_trace)) {
+    gpr_log(GPR_INFO,
+            "[RH %p] setting connectivity state to %s (num_idle=%" PRIuPTR
+            ", num_connecting=%" PRIuPTR ", num_ready=%" PRIuPTR
+            ", num_transient_failure=%" PRIuPTR ", size=%" PRIuPTR
+            ") -- start_connection_attempt=%d",
+            this, ConnectivityStateName(state), num_idle, num_connecting,
+            num_ready, num_transient_failure, endpoints_.size(),
+            start_connection_attempt);
+  }
+  // In TRANSIENT_FAILURE, report the last reported failure.
+  // Otherwise, report OK.
+  if (state == GRPC_CHANNEL_TRANSIENT_FAILURE) {
+    if (!status.ok()) {
+      last_failure_ = absl::UnavailableError(absl::StrCat(
+          "no reachable endpoints; last error: ", status.message()));
+    }
+    status = last_failure_;
+  } else {
+    status = absl::OkStatus();
+  }
+  // Generate new picker and return it to the channel.
+  // Note that we use our own picker regardless of connectivity state.
+  channel_control_helper()->UpdateState(
+      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.
+  //
+  // 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.
+  //
+  // Note that once an endpoint enters TRANSIENT_FAILURE state, it will
+  // stay in that state and automatically retry after appropriate backoff,
+  // never stopping until it establishes a connection.  This means that
+  // if we stay in TRANSIENT_FAILURE for a long period of time, we will
+  // eventually be trying *all* endpoints, which probably isn't ideal.
+  // But it's no different than what can happen if ring_hash is the root
+  // 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()));
+      GPR_ASSERT(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()));
+      GPR_ASSERT(it != endpoint_map_.end());
+      if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_ring_hash_trace)) {
+        gpr_log(GPR_INFO,
+                "[RH %p] triggering internal connection attempt for endpoint "
+                "%p (%s) (index %" PRIuPTR " of %" PRIuPTR ")",
+                this, it->second.get(),
+                endpoints_[first_idle_index].ToString().c_str(),
+                first_idle_index, endpoints_.size());
+      }
+      it->second->RequestConnectionLocked();
     }
-    // Otherwise, report IDLE.
-    subchannel_list_->UpdateRingHashConnectivityStateLocked(
-        /*index=*/0, /*connection_attempt_complete=*/false, absl::OkStatus());
   }
-  return absl::OkStatus();
 }
 
 //