grpc 1.56.2 → 1.58.0

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

@@ -25,13 +25,15 @@
 #include <utility>
 #include <vector>
 
+#include "absl/algorithm/container.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 <grpc/grpc.h>
+#include <grpc/impl/channel_arg_names.h>
 #include <grpc/impl/connectivity_state.h>
 #include <grpc/support/log.h>
 
@@ -45,6 +47,8 @@
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/work_serializer.h"
 #include "src/core/lib/json/json.h"
+#include "src/core/lib/json/json_args.h"
+#include "src/core/lib/json/json_object_loader.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"
@@ -63,6 +67,24 @@ namespace {
 
 constexpr absl::string_view kPickFirst = "pick_first";
 
+class PickFirstConfig : public LoadBalancingPolicy::Config {
+ public:
+  absl::string_view name() const override { return kPickFirst; }
+  bool shuffle_addresses() const { return shuffle_addresses_; }
+
+  static const JsonLoaderInterface* JsonLoader(const JsonArgs&) {
+    static const auto kJsonLoader =
+        JsonObjectLoader<PickFirstConfig>()
+            .OptionalField("shuffleAddressList",
+                           &PickFirstConfig::shuffle_addresses_)
+            .Finish();
+    return kJsonLoader;
+  }
+
+ private:
+  bool shuffle_addresses_ = false;
+};
+
 class PickFirst : public LoadBalancingPolicy {
  public:
   explicit PickFirst(Args args);
@@ -93,8 +115,12 @@ class PickFirst : public LoadBalancingPolicy {
         absl::optional<grpc_connectivity_state> old_state,
         grpc_connectivity_state new_state) override;
 
+   private:
     // Processes the connectivity change to READY for an unselected subchannel.
     void ProcessUnselectedReadyLocked();
+
+    // Reacts to the current connectivity state while trying to connect.
+    void ReactToConnectivityStateLocked();
   };
 
   class PickFirstSubchannelList
@@ -157,6 +183,9 @@ class PickFirst : public LoadBalancingPolicy {
 
   void AttemptToConnectUsingLatestUpdateArgsLocked();
 
+  void UpdateState(grpc_connectivity_state state, const absl::Status& status,
+                   RefCountedPtr<SubchannelPicker> picker);
+
   // Lateset update args.
   UpdateArgs latest_update_args_;
   // All our subchannels.
@@ -165,10 +194,12 @@ class PickFirst : public LoadBalancingPolicy {
   RefCountedPtr<PickFirstSubchannelList> latest_pending_subchannel_list_;
   // Selected subchannel in \a subchannel_list_.
   PickFirstSubchannelData* selected_ = nullptr;
-  // Are we in IDLE state?
-  bool idle_ = false;
+  // Current connectivity state.
+  grpc_connectivity_state state_ = GRPC_CHANNEL_CONNECTING;
   // Are we shut down?
   bool shutdown_ = false;
+  // Random bit generator used for shuffling addresses if configured
+  absl::BitGen bit_gen_;
 };
 
 PickFirst::PickFirst(Args args) : LoadBalancingPolicy(std::move(args)) {
@@ -196,11 +227,10 @@ void PickFirst::ShutdownLocked() {
 
 void PickFirst::ExitIdleLocked() {
   if (shutdown_) return;
-  if (idle_) {
+  if (state_ == GRPC_CHANNEL_IDLE) {
     if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_pick_first_trace)) {
       gpr_log(GPR_INFO, "Pick First %p exiting idle", this);
     }
-    idle_ = false;
     AttemptToConnectUsingLatestUpdateArgsLocked();
   }
 }
@@ -227,19 +257,19 @@ void PickFirst::AttemptToConnectUsingLatestUpdateArgsLocked() {
   }
   latest_pending_subchannel_list_ = MakeRefCounted<PickFirstSubchannelList>(
       this, std::move(addresses), latest_update_args_.args);
-  latest_pending_subchannel_list_->StartWatchingLocked();
+  latest_pending_subchannel_list_->StartWatchingLocked(
+      latest_update_args_.args);
   // Empty update or no valid subchannels.  Put the channel in
   // TRANSIENT_FAILURE and request re-resolution.
   if (latest_pending_subchannel_list_->num_subchannels() == 0) {
+    channel_control_helper()->RequestReresolution();
     absl::Status status =
         latest_update_args_.addresses.ok()
             ? absl::UnavailableError(absl::StrCat(
                   "empty address list: ", latest_update_args_.resolution_note))
             : latest_update_args_.addresses.status();
-    channel_control_helper()->UpdateState(
-        GRPC_CHANNEL_TRANSIENT_FAILURE, status,
-        MakeRefCounted<TransientFailurePicker>(status));
-    channel_control_helper()->RequestReresolution();
+    UpdateState(GRPC_CHANNEL_TRANSIENT_FAILURE, status,
+                MakeRefCounted<TransientFailurePicker>(status));
   }
   // If the new update is empty or we don't yet have a selected subchannel in
   // the current list, replace the current subchannel list immediately.
@@ -274,6 +304,11 @@ absl::Status PickFirst::UpdateLocked(UpdateArgs args) {
     status = args.addresses.status();
   } else if (args.addresses->empty()) {
     status = absl::UnavailableError("address list must not be empty");
+  } else {
+    auto config = static_cast<PickFirstConfig*>(args.config.get());
+    if (config->shuffle_addresses()) {
+      absl::c_shuffle(*args.addresses, bit_gen_);
+    }
   }
   // TODO(roth): This is a hack to disable outlier_detection when used
   // with pick_first, for the reasons described in
@@ -282,9 +317,9 @@ absl::Status PickFirst::UpdateLocked(UpdateArgs args) {
   if (args.addresses.ok()) {
     ServerAddressList addresses;
     for (const auto& address : *args.addresses) {
-      addresses.emplace_back(address.WithAttribute(
-          DisableOutlierDetectionAttribute::kName,
-          std::make_unique<DisableOutlierDetectionAttribute>()));
+      addresses.emplace_back(
+          address.address(),
+          address.args().Set(GRPC_ARG_OUTLIER_DETECTION_DISABLE, 1));
     }
     args.addresses = std::move(addresses);
   }
@@ -297,12 +332,19 @@ absl::Status PickFirst::UpdateLocked(UpdateArgs args) {
   latest_update_args_ = std::move(args);
   // If we are not in idle, start connection attempt immediately.
   // Otherwise, we defer the attempt into ExitIdleLocked().
-  if (!idle_) {
+  if (state_ != GRPC_CHANNEL_IDLE) {
     AttemptToConnectUsingLatestUpdateArgsLocked();
   }
   return status;
 }
 
+void PickFirst::UpdateState(grpc_connectivity_state state,
+                            const absl::Status& status,
+                            RefCountedPtr<SubchannelPicker> picker) {
+  state_ = state;
+  channel_control_helper()->UpdateState(state, status, std::move(picker));
+}
+
 void PickFirst::PickFirstSubchannelData::ProcessConnectivityChangeLocked(
     absl::optional<grpc_connectivity_state> old_state,
     grpc_connectivity_state new_state) {
@@ -322,6 +364,13 @@ void PickFirst::PickFirstSubchannelData::ProcessConnectivityChangeLocked(
     }
     // Any state change is considered to be a failure of the existing
     // connection.
+    // TODO(roth): We could check the connectivity states of all the
+    // subchannels here, just in case one of them happens to be READY,
+    // and we could switch to that rather than going IDLE.
+    // Request a re-resolution.
+    // TODO(qianchengz): We may want to request re-resolution in
+    // ExitIdleLocked().
+    p->channel_control_helper()->RequestReresolution();
     // If there is a pending update, switch to the pending update.
     if (p->latest_pending_subchannel_list_ != nullptr) {
       if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_pick_first_trace)) {
@@ -342,28 +391,18 @@ void PickFirst::PickFirstSubchannelData::ProcessConnectivityChangeLocked(
                 ->subchannel(p->subchannel_list_->num_subchannels())
                 ->connectivity_status()
                 .ToString()));
-        p->channel_control_helper()->UpdateState(
-            GRPC_CHANNEL_TRANSIENT_FAILURE, status,
-            MakeRefCounted<TransientFailurePicker>(status));
-      } else {
-        p->channel_control_helper()->UpdateState(
-            GRPC_CHANNEL_CONNECTING, absl::Status(),
-            MakeRefCounted<QueuePicker>(p->Ref(DEBUG_LOCATION, "QueuePicker")));
+        p->UpdateState(GRPC_CHANNEL_TRANSIENT_FAILURE, status,
+                       MakeRefCounted<TransientFailurePicker>(status));
+      } else if (p->state_ != GRPC_CHANNEL_TRANSIENT_FAILURE) {
+        p->UpdateState(GRPC_CHANNEL_CONNECTING, absl::Status(),
+                       MakeRefCounted<QueuePicker>(nullptr));
       }
       return;
     }
-    // If the selected subchannel goes bad, request a re-resolution.
-    // TODO(qianchengz): We may want to request re-resolution in
-    // ExitIdleLocked().
-    p->channel_control_helper()->RequestReresolution();
-    // TODO(roth): We chould check the connectivity states of all the
-    // subchannels here, just in case one of them happens to be READY,
-    // and we could switch to that rather than going IDLE.
     // Enter idle.
-    p->idle_ = true;
     p->selected_ = nullptr;
     p->subchannel_list_.reset();
-    p->channel_control_helper()->UpdateState(
+    p->UpdateState(
         GRPC_CHANNEL_IDLE, absl::Status(),
         MakeRefCounted<QueuePicker>(p->Ref(DEBUG_LOCATION, "QueuePicker")));
     return;
@@ -383,92 +422,109 @@ void PickFirst::PickFirstSubchannelData::ProcessConnectivityChangeLocked(
     ProcessUnselectedReadyLocked();
     return;
   }
-  // If this is the initial connectivity state notification for this
-  // subchannel, check to see if it's the last one we were waiting for,
-  // in which case we start trying to connect to the first subchannel.
-  // Otherwise, do nothing, since we'll continue to wait until all of
-  // the subchannels report their state.
+  // If we haven't yet seen the initial connectivity state notification
+  // for all subchannels, do nothing.
+  if (!subchannel_list()->AllSubchannelsSeenInitialState()) return;
+  // If we're still here and this is the initial connectivity state
+  // notification for this subchannel, that means it was the last one to
+  // see its initial notification.  Start trying to connect, starting
+  // with the first subchannel.
   if (!old_state.has_value()) {
-    if (subchannel_list()->AllSubchannelsSeenInitialState()) {
-      subchannel_list()->subchannel(0)->subchannel()->RequestConnection();
-    }
+    subchannel_list()->subchannel(0)->ReactToConnectivityStateLocked();
     return;
   }
   // Ignore any other updates for subchannels we're not currently trying to
   // connect to.
   if (Index() != subchannel_list()->attempting_index()) return;
+  // React to the connectivity state.
+  ReactToConnectivityStateLocked();
+}
+
+void PickFirst::PickFirstSubchannelData::ReactToConnectivityStateLocked() {
+  PickFirst* p = static_cast<PickFirst*>(subchannel_list()->policy());
   // Otherwise, process connectivity state.
-  switch (new_state) {
+  switch (connectivity_state().value()) {
     case GRPC_CHANNEL_READY:
       // Already handled this case above, so this should not happen.
       GPR_UNREACHABLE_CODE(break);
     case GRPC_CHANNEL_TRANSIENT_FAILURE: {
-      size_t next_index = (Index() + 1) % subchannel_list()->num_subchannels();
-      subchannel_list()->set_attempting_index(next_index);
-      PickFirstSubchannelData* sd = subchannel_list()->subchannel(next_index);
-      // If we're tried all subchannels, set state to TRANSIENT_FAILURE.
-      if (sd->Index() == 0) {
+      // Find the next subchannel not in state TRANSIENT_FAILURE.
+      // We skip subchannels in state TRANSIENT_FAILURE to avoid a
+      // large recursion that could overflow the stack.
+      PickFirstSubchannelData* found_subchannel = nullptr;
+      for (size_t next_index = Index() + 1;
+           next_index < subchannel_list()->num_subchannels(); ++next_index) {
+        PickFirstSubchannelData* sc = subchannel_list()->subchannel(next_index);
+        GPR_ASSERT(sc->connectivity_state().has_value());
+        if (sc->connectivity_state() != GRPC_CHANNEL_TRANSIENT_FAILURE) {
+          subchannel_list()->set_attempting_index(next_index);
+          found_subchannel = sc;
+          break;
+        }
+      }
+      // If we found another subchannel in the list not in state
+      // TRANSIENT_FAILURE, trigger the right behavior for that subchannel.
+      if (found_subchannel != nullptr) {
+        found_subchannel->ReactToConnectivityStateLocked();
+        break;
+      }
+      // We didn't find another subchannel not in state TRANSIENT_FAILURE,
+      // so report TRANSIENT_FAILURE and wait for the first subchannel
+      // in the list to report IDLE before continuing.
+      if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_pick_first_trace)) {
+        gpr_log(GPR_INFO,
+                "Pick First %p subchannel list %p failed to connect to "
+                "all subchannels",
+                p, subchannel_list());
+      }
+      subchannel_list()->set_attempting_index(0);
+      subchannel_list()->set_in_transient_failure(true);
+      // In case 2, swap to the new subchannel list.  This means reporting
+      // TRANSIENT_FAILURE and dropping the existing (working) connection,
+      // but we can't ignore what the control plane has told us.
+      if (subchannel_list() == p->latest_pending_subchannel_list_.get()) {
         if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_pick_first_trace)) {
           gpr_log(GPR_INFO,
-                  "Pick First %p subchannel list %p failed to connect to "
-                  "all subchannels",
-                  p, subchannel_list());
-        }
-        subchannel_list()->set_in_transient_failure(true);
-        // In case 2, swap to the new subchannel list.  This means reporting
-        // TRANSIENT_FAILURE and dropping the existing (working) connection,
-        // but we can't ignore what the control plane has told us.
-        if (subchannel_list() == p->latest_pending_subchannel_list_.get()) {
-          if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_pick_first_trace)) {
-            gpr_log(GPR_INFO,
-                    "Pick First %p promoting pending subchannel list %p to "
-                    "replace %p",
-                    p, p->latest_pending_subchannel_list_.get(),
-                    p->subchannel_list_.get());
-          }
-          p->selected_ = nullptr;  // owned by p->subchannel_list_
-          p->subchannel_list_ = std::move(p->latest_pending_subchannel_list_);
-        }
-        // If this is the current subchannel list (either because we were
-        // in case 1 or because we were in case 2 and just promoted it to
-        // be the current list), re-resolve and report new state.
-        if (subchannel_list() == p->subchannel_list_.get()) {
-          p->channel_control_helper()->RequestReresolution();
-          absl::Status status = absl::UnavailableError(
-              absl::StrCat("failed to connect to all addresses; last error: ",
-                           connectivity_status().ToString()));
-          p->channel_control_helper()->UpdateState(
-              GRPC_CHANNEL_TRANSIENT_FAILURE, status,
-              MakeRefCounted<TransientFailurePicker>(status));
+                  "Pick First %p promoting pending subchannel list %p to "
+                  "replace %p",
+                  p, p->latest_pending_subchannel_list_.get(),
+                  p->subchannel_list_.get());
         }
+        p->selected_ = nullptr;  // owned by p->subchannel_list_
+        p->subchannel_list_ = std::move(p->latest_pending_subchannel_list_);
       }
-      // If the next subchannel is in IDLE, trigger a connection attempt.
-      // If it's in READY, we can't get here, because we would already
-      // have selected the subchannel above.
-      // If it's already in CONNECTING, we don't need to do this.
-      // If it's in TRANSIENT_FAILURE, then we will trigger the
-      // connection attempt later when it reports IDLE.
-      auto sd_state = sd->connectivity_state();
-      if (sd_state.has_value() && *sd_state == GRPC_CHANNEL_IDLE) {
-        sd->subchannel()->RequestConnection();
+      // If this is the current subchannel list (either because we were
+      // in case 1 or because we were in case 2 and just promoted it to
+      // be the current list), re-resolve and report new state.
+      if (subchannel_list() == p->subchannel_list_.get()) {
+        p->channel_control_helper()->RequestReresolution();
+        absl::Status status = absl::UnavailableError(
+            absl::StrCat("failed to connect to all addresses; last error: ",
+                         connectivity_status().ToString()));
+        p->UpdateState(GRPC_CHANNEL_TRANSIENT_FAILURE, status,
+                       MakeRefCounted<TransientFailurePicker>(status));
+      }
+      // If the first subchannel is already IDLE, trigger the next connection
+      // attempt immediately.  Otherwise, we'll wait for it to report
+      // its own connectivity state change.
+      auto* subchannel0 = subchannel_list()->subchannel(0);
+      if (subchannel0->connectivity_state() == GRPC_CHANNEL_IDLE) {
+        subchannel0->subchannel()->RequestConnection();
       }
       break;
     }
-    case GRPC_CHANNEL_IDLE: {
+    case GRPC_CHANNEL_IDLE:
       subchannel()->RequestConnection();
       break;
-    }
-    case GRPC_CHANNEL_CONNECTING: {
+    case GRPC_CHANNEL_CONNECTING:
       // Only update connectivity state in case 1, and only if we're not
       // already in TRANSIENT_FAILURE.
       if (subchannel_list() == p->subchannel_list_.get() &&
-          !subchannel_list()->in_transient_failure()) {
-        p->channel_control_helper()->UpdateState(
-            GRPC_CHANNEL_CONNECTING, absl::Status(),
-            MakeRefCounted<QueuePicker>(p->Ref(DEBUG_LOCATION, "QueuePicker")));
+          p->state_ != GRPC_CHANNEL_TRANSIENT_FAILURE) {
+        p->UpdateState(GRPC_CHANNEL_CONNECTING, absl::Status(),
+                       MakeRefCounted<QueuePicker>(nullptr));
       }
       break;
-    }
     case GRPC_CHANNEL_SHUTDOWN:
       GPR_UNREACHABLE_CODE(break);
   }
@@ -503,9 +559,8 @@ void PickFirst::PickFirstSubchannelData::ProcessUnselectedReadyLocked() {
     gpr_log(GPR_INFO, "Pick First %p selected subchannel %p", p, subchannel());
   }
   p->selected_ = this;
-  p->channel_control_helper()->UpdateState(
-      GRPC_CHANNEL_READY, absl::Status(),
-      MakeRefCounted<Picker>(subchannel()->Ref()));
+  p->UpdateState(GRPC_CHANNEL_READY, absl::Status(),
+                 MakeRefCounted<Picker>(subchannel()->Ref()));
   for (size_t i = 0; i < subchannel_list()->num_subchannels(); ++i) {
     if (i != Index()) {
       subchannel_list()->subchannel(i)->ShutdownLocked();
@@ -513,11 +568,6 @@ void PickFirst::PickFirstSubchannelData::ProcessUnselectedReadyLocked() {
   }
 }
 
-class PickFirstConfig : public LoadBalancingPolicy::Config {
- public:
-  absl::string_view name() const override { return kPickFirst; }
-};
-
 //
 // factory
 //
@@ -532,8 +582,9 @@ class PickFirstFactory : public LoadBalancingPolicyFactory {
   absl::string_view name() const override { return kPickFirst; }
 
   absl::StatusOr<RefCountedPtr<LoadBalancingPolicy::Config>>
-  ParseLoadBalancingConfig(const Json& /*json*/) const override {
-    return MakeRefCounted<PickFirstConfig>();
+  ParseLoadBalancingConfig(const Json& json) const override {
+    return LoadFromJson<RefCountedPtr<PickFirstConfig>>(
+        json, JsonArgs(), "errors validating pick_first LB policy config");
   }
 };
 

data/src/core/ext/filters/client_channel/lb_policy/pick_first/pick_first.h

@@ -0,0 +1,20 @@
+//
+// Copyright 2023 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#ifndef GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_PICK_FIRST_PICK_FIRST_H
+#define GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_PICK_FIRST_PICK_FIRST_H
+
+#endif  // GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_PICK_FIRST_PICK_FIRST_H

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

@@ -35,7 +35,7 @@
 #include "absl/types/optional.h"
 
 #include <grpc/event_engine/event_engine.h>
-#include <grpc/grpc.h>
+#include <grpc/impl/channel_arg_names.h>
 #include <grpc/impl/connectivity_state.h>
 #include <grpc/support/log.h>
 
@@ -55,10 +55,10 @@
 #include "src/core/lib/json/json.h"
 #include "src/core/lib/json/json_args.h"
 #include "src/core/lib/json/json_object_loader.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/lb_policy_registry.h"
-#include "src/core/lib/load_balancing/subchannel_interface.h"
 #include "src/core/lib/resolver/server_address.h"
 #include "src/core/lib/transport/connectivity_state.h"
 
@@ -162,25 +162,23 @@ class PriorityLb : public LoadBalancingPolicy {
     bool FailoverTimerPending() const { return failover_timer_ != nullptr; }
 
    private:
-    class Helper : public ChannelControlHelper {
+    class Helper : public DelegatingChannelControlHelper {
      public:
       explicit Helper(RefCountedPtr<ChildPriority> priority)
           : priority_(std::move(priority)) {}
 
       ~Helper() override { priority_.reset(DEBUG_LOCATION, "Helper"); }
 
-      RefCountedPtr<SubchannelInterface> CreateSubchannel(
-          ServerAddress address, const ChannelArgs& args) override;
       void UpdateState(grpc_connectivity_state state,
                        const absl::Status& status,
                        RefCountedPtr<SubchannelPicker> picker) override;
       void RequestReresolution() override;
-      absl::string_view GetAuthority() override;
-      EventEngine* GetEventEngine() override;
-      void AddTraceEvent(TraceSeverity severity,
-                         absl::string_view message) override;
 
      private:
+      ChannelControlHelper* parent_helper() const override {
+        return priority_->priority_policy_->channel_control_helper();
+      }
+
       RefCountedPtr<ChildPriority> priority_;
     };
 
@@ -683,7 +681,12 @@ absl::Status PriorityLb::ChildPriority::UpdateLocked(
   UpdateArgs update_args;
   update_args.config = std::move(config);
   if (priority_policy_->addresses_.ok()) {
-    update_args.addresses = (*priority_policy_->addresses_)[name_];
+    auto it = priority_policy_->addresses_->find(name_);
+    if (it == priority_policy_->addresses_->end()) {
+      update_args.addresses.emplace();
+    } else {
+      update_args.addresses = it->second;
+    }
   } else {
     update_args.addresses = priority_policy_->addresses_.status();
   }
@@ -793,14 +796,6 @@ void PriorityLb::ChildPriority::MaybeReactivateLocked() {
 // PriorityLb::ChildPriority::Helper
 //
 
-RefCountedPtr<SubchannelInterface>
-PriorityLb::ChildPriority::Helper::CreateSubchannel(ServerAddress address,
-                                                    const ChannelArgs& args) {
-  if (priority_->priority_policy_->shutting_down_) return nullptr;
-  return priority_->priority_policy_->channel_control_helper()
-      ->CreateSubchannel(std::move(address), args);
-}
-
 void PriorityLb::ChildPriority::Helper::UpdateState(
     grpc_connectivity_state state, const absl::Status& status,
     RefCountedPtr<SubchannelPicker> picker) {
@@ -817,22 +812,6 @@ void PriorityLb::ChildPriority::Helper::RequestReresolution() {
   priority_->priority_policy_->channel_control_helper()->RequestReresolution();
 }
 
-absl::string_view PriorityLb::ChildPriority::Helper::GetAuthority() {
-  return priority_->priority_policy_->channel_control_helper()->GetAuthority();
-}
-
-EventEngine* PriorityLb::ChildPriority::Helper::GetEventEngine() {
-  return priority_->priority_policy_->channel_control_helper()
-      ->GetEventEngine();
-}
-
-void PriorityLb::ChildPriority::Helper::AddTraceEvent(
-    TraceSeverity severity, absl::string_view message) {
-  if (priority_->priority_policy_->shutting_down_) return;
-  priority_->priority_policy_->channel_control_helper()->AddTraceEvent(severity,
-                                                                       message);
-}
-
 //
 // factory
 //

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

@@ -37,10 +37,11 @@
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 
+#include <grpc/impl/channel_arg_names.h>
+
 #define XXH_INLINE_ALL
 #include "xxhash.h"
 
-#include <grpc/grpc.h>
 #include <grpc/impl/connectivity_state.h>
 #include <grpc/support/log.h>
 
@@ -470,16 +471,14 @@ RingHash::RingHashSubchannelList::Ring::Ring(
   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));
+    auto weight_arg = sd->address().args().GetInt(GRPC_ARG_ADDRESS_WEIGHT);
     AddressWeight address_weight;
     address_weight.address =
         grpc_sockaddr_to_string(&sd->address().address(), 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();
+    if (weight_arg.value_or(0) > 0) {
+      address_weight.weight = *weight_arg;
     }
     sum += address_weight.weight;
     address_weights.push_back(std::move(address_weight));
@@ -816,7 +815,7 @@ absl::Status RingHash::UpdateLocked(UpdateArgs args) {
   }
   latest_pending_subchannel_list_ = MakeRefCounted<RingHashSubchannelList>(
       this, std::move(addresses), args.args);
-  latest_pending_subchannel_list_->StartWatchingLocked();
+  latest_pending_subchannel_list_->StartWatchingLocked(args.args);
   // 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