grpc 1.59.5 → 1.60.0.pre1

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

@@ -44,18 +44,19 @@ int HierarchicalPathArg::ChannelArgsCompare(const HierarchicalPathArg* a,
 }
 
 absl::StatusOr<HierarchicalAddressMap> MakeHierarchicalAddressMap(
-    const absl::StatusOr<ServerAddressList>& addresses) {
+    const absl::StatusOr<EndpointAddressesList>& addresses) {
   if (!addresses.ok()) return addresses.status();
   HierarchicalAddressMap result;
   RefCountedPtr<HierarchicalPathArg> remaining_path_attr;
-  for (const ServerAddress& address : *addresses) {
-    const auto* path_arg = address.args().GetObject<HierarchicalPathArg>();
+  for (const EndpointAddresses& endpoint_addresses : *addresses) {
+    const auto* path_arg =
+        endpoint_addresses.args().GetObject<HierarchicalPathArg>();
     if (path_arg == nullptr) continue;
     const std::vector<RefCountedStringValue>& path = path_arg->path();
     auto it = path.begin();
     if (it == path.end()) continue;
-    ServerAddressList& target_list = result[*it];
-    ChannelArgs args = address.args();
+    EndpointAddressesList& target_list = result[*it];
+    ChannelArgs args = endpoint_addresses.args();
     ++it;
     if (it != path.end()) {
       std::vector<RefCountedStringValue> remaining_path(it, path.end());
@@ -66,7 +67,7 @@ absl::StatusOr<HierarchicalAddressMap> MakeHierarchicalAddressMap(
       }
       args = args.SetObject(remaining_path_attr);
     }
-    target_list.emplace_back(address.address(), args);
+    target_list.emplace_back(endpoint_addresses.addresses(), args);
   }
   return result;
 }

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

@@ -28,7 +28,7 @@
 
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_string.h"
-#include "src/core/lib/resolver/server_address.h"
+#include "src/core/lib/resolver/endpoint_addresses.h"
 
 // The resolver returns a flat list of addresses.  When a hierarchy of
 // LB policies is in use, each leaf of the hierarchy will need a
@@ -102,15 +102,15 @@ class HierarchicalPathArg : public RefCounted<HierarchicalPathArg> {
   std::vector<RefCountedStringValue> path_;
 };
 
-// A map from the next path element to the addresses that fall under
-// that path element.
+// A map from the next path element to the endpoint addresses that fall
+// under that path element.
 using HierarchicalAddressMap =
-    std::map<RefCountedStringValue, ServerAddressList,
+    std::map<RefCountedStringValue, EndpointAddressesList,
              RefCountedStringValueLessThan>;
 
 // Splits up the addresses into a separate list for each child.
 absl::StatusOr<HierarchicalAddressMap> MakeHierarchicalAddressMap(
-    const absl::StatusOr<ServerAddressList>& addresses);
+    const absl::StatusOr<EndpointAddressesList>& addresses);
 
 }  // namespace grpc_core
 

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

@@ -32,10 +32,10 @@
 #include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/iomgr/pollset_set.h"
+#include "src/core/lib/iomgr/resolved_address.h"
 #include "src/core/lib/load_balancing/delegating_helper.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"
 
 namespace grpc_core {
@@ -52,11 +52,12 @@ class ChildPolicyHandler::Helper
       : ParentOwningDelegatingChannelControlHelper(std::move(parent)) {}
 
   RefCountedPtr<SubchannelInterface> CreateSubchannel(
-      ServerAddress address, const ChannelArgs& args) override {
+      const grpc_resolved_address& address, const ChannelArgs& per_address_args,
+      const ChannelArgs& args) override {
     if (parent()->shutting_down_) return nullptr;
     if (!CalledByCurrentChild() && !CalledByPendingChild()) return nullptr;
     return parent()->channel_control_helper()->CreateSubchannel(
-        std::move(address), args);
+        address, per_address_args, args);
   }
 
   void UpdateState(grpc_connectivity_state state, const absl::Status& status,
@@ -97,7 +98,7 @@ class ChildPolicyHandler::Helper
             : parent()->child_policy_.get();
     if (child_ != latest_child_policy) return;
     if (GRPC_TRACE_FLAG_ENABLED(*(parent()->tracer_))) {
-      gpr_log(GPR_INFO, "[child_policy_handler %p] started name re-resolving",
+      gpr_log(GPR_INFO, "[child_policy_handler %p] requesting re-resolution",
               parent());
     }
     parent()->channel_control_helper()->RequestReresolution();

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

@@ -20,7 +20,6 @@
 
 #include <stdlib.h>
 
-#include <algorithm>
 #include <memory>
 #include <utility>
 #include <vector>
@@ -44,7 +43,7 @@
 #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_registry.h"
-#include "src/core/lib/resolver/server_address.h"
+#include "src/core/lib/resolver/endpoint_addresses.h"
 
 namespace grpc_core {
 
@@ -61,8 +60,9 @@ class EndpointList::Endpoint::Helper
   ~Helper() override { endpoint_.reset(DEBUG_LOCATION, "Helper"); }
 
   RefCountedPtr<SubchannelInterface> CreateSubchannel(
-      ServerAddress address, const ChannelArgs& args) override {
-    return endpoint_->CreateSubchannel(std::move(address), args);
+      const grpc_resolved_address& address, const ChannelArgs& per_address_args,
+      const ChannelArgs& args) override {
+    return endpoint_->CreateSubchannel(address, per_address_args, args);
   }
 
   void UpdateState(
@@ -86,7 +86,7 @@ class EndpointList::Endpoint::Helper
 //
 
 void EndpointList::Endpoint::Init(
-    const ServerAddress& address, const ChannelArgs& args,
+    const EndpointAddresses& addresses, const ChannelArgs& args,
     std::shared_ptr<WorkSerializer> work_serializer) {
   ChannelArgs child_args =
       args.Set(GRPC_ARG_INTERNAL_PICK_FIRST_ENABLE_HEALTH_CHECKING, true)
@@ -118,7 +118,7 @@ void EndpointList::Endpoint::Init(
   GPR_ASSERT(config.ok());
   // Update child policy.
   LoadBalancingPolicy::UpdateArgs update_args;
-  update_args.addresses.emplace().emplace_back(address);
+  update_args.addresses.emplace().emplace_back(addresses);
   update_args.args = child_args;
   update_args.config = std::move(*config);
   // TODO(roth): If the child reports a non-OK status with the update,
@@ -152,9 +152,10 @@ size_t EndpointList::Endpoint::Index() const {
 }
 
 RefCountedPtr<SubchannelInterface> EndpointList::Endpoint::CreateSubchannel(
-    ServerAddress address, const ChannelArgs& args) {
+    const grpc_resolved_address& address, const ChannelArgs& per_address_args,
+    const ChannelArgs& args) {
   return endpoint_list_->channel_control_helper()->CreateSubchannel(
-      std::move(address), args);
+      address, per_address_args, args);
 }
 
 //
@@ -162,13 +163,14 @@ RefCountedPtr<SubchannelInterface> EndpointList::Endpoint::CreateSubchannel(
 //
 
 void EndpointList::Init(
-    const ServerAddressList& addresses, const ChannelArgs& args,
-    absl::AnyInvocable<OrphanablePtr<Endpoint>(
-        RefCountedPtr<EndpointList>, const ServerAddress&, const ChannelArgs&)>
+    const EndpointAddressesList& endpoints, const ChannelArgs& args,
+    absl::AnyInvocable<OrphanablePtr<Endpoint>(RefCountedPtr<EndpointList>,
+                                               const EndpointAddresses&,
+                                               const ChannelArgs&)>
         create_endpoint) {
-  for (const ServerAddress& address : addresses) {
+  for (const EndpointAddresses& addresses : endpoints) {
     endpoints_.push_back(
-        create_endpoint(Ref(DEBUG_LOCATION, "Endpoint"), address, args));
+        create_endpoint(Ref(DEBUG_LOCATION, "Endpoint"), addresses, args));
   }
 }
 

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

@@ -36,9 +36,10 @@
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/work_serializer.h"
+#include "src/core/lib/iomgr/resolved_address.h"
 #include "src/core/lib/load_balancing/lb_policy.h"
 #include "src/core/lib/load_balancing/subchannel_interface.h"
-#include "src/core/lib/resolver/server_address.h"
+#include "src/core/lib/resolver/endpoint_addresses.h"
 
 namespace grpc_core {
 
@@ -52,16 +53,17 @@ namespace grpc_core {
 class MyEndpointList : public EndpointList {
  public:
   MyEndpointList(RefCountedPtr<MyLbPolicy> lb_policy,
-                 const ServerAddressList& addresses, const ChannelArgs& args)
+                 const EndpointAddressesList& endpoints,
+                 const ChannelArgs& args)
       : EndpointList(std::move(lb_policy),
                      GRPC_TRACE_FLAG_ENABLED(grpc_my_tracer)
                          ? "MyEndpointList"
                          : nullptr) {
-    Init(addresses, args,
+    Init(endpoints, args,
          [&](RefCountedPtr<MyEndpointList> endpoint_list,
-             const ServerAddress& address, const ChannelArgs& args) {
+             const EndpointAddresses& addresses, const ChannelArgs& args) {
            return MakeOrphanable<MyEndpoint>(
-               std::move(endpoint_list), address, args,
+               std::move(endpoint_list), addresses, args,
                policy<MyLbPolicy>()->work_serializer());
          });
   }
@@ -70,10 +72,10 @@ class MyEndpointList : public EndpointList {
   class MyEndpoint : public Endpoint {
    public:
     MyEndpoint(RefCountedPtr<MyEndpointList> endpoint_list,
-               const ServerAddress& address, const ChannelArgs& args,
+               const EndpointAddresses& address, const ChannelArgs& args,
                std::shared_ptr<WorkSerializer> work_serializer)
         : Endpoint(std::move(endpoint_list)) {
-      Init(address, args, std::move(work_serializer));
+      Init(addresses, args, std::move(work_serializer));
     }
 
    private:
@@ -119,7 +121,7 @@ class EndpointList : public InternallyRefCounted<EndpointList> {
     explicit Endpoint(RefCountedPtr<EndpointList> endpoint_list)
         : endpoint_list_(std::move(endpoint_list)) {}
 
-    void Init(const ServerAddress& address, const ChannelArgs& args,
+    void Init(const EndpointAddresses& addresses, const ChannelArgs& args,
               std::shared_ptr<WorkSerializer> work_serializer);
 
     // Templated for convenience, to provide a short-hand for
@@ -150,7 +152,8 @@ class EndpointList : public InternallyRefCounted<EndpointList> {
 
     // Called to create a subchannel.  Subclasses may override.
     virtual RefCountedPtr<SubchannelInterface> CreateSubchannel(
-        ServerAddress address, const ChannelArgs& args);
+        const grpc_resolved_address& address,
+        const ChannelArgs& per_address_args, const ChannelArgs& args);
 
     RefCountedPtr<EndpointList> endpoint_list_;
 
@@ -181,9 +184,9 @@ class EndpointList : public InternallyRefCounted<EndpointList> {
   EndpointList(RefCountedPtr<LoadBalancingPolicy> policy, const char* tracer)
       : policy_(std::move(policy)), tracer_(tracer) {}
 
-  void Init(const ServerAddressList& addresses, const ChannelArgs& args,
+  void Init(const EndpointAddressesList& endpoints, const ChannelArgs& args,
             absl::AnyInvocable<OrphanablePtr<Endpoint>(
-                RefCountedPtr<EndpointList>, const ServerAddress&,
+                RefCountedPtr<EndpointList>, const EndpointAddresses&,
                 const ChannelArgs&)>
                 create_endpoint);
 

data/src/core/ext/filters/client_channel/lb_policy/grpclb/client_load_reporting_filter.cc

@@ -25,7 +25,6 @@
 #include <type_traits>
 #include <utility>
 
-#include "absl/meta/type_traits.h"
 #include "absl/types/optional.h"
 
 #include "src/core/ext/filters/client_channel/lb_policy/grpclb/grpclb_client_stats.h"
@@ -34,7 +33,6 @@
 #include "src/core/lib/promise/context.h"
 #include "src/core/lib/promise/map.h"
 #include "src/core/lib/promise/pipe.h"
-#include "src/core/lib/promise/poll.h"
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/lib/transport/transport.h"

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

@@ -64,7 +64,6 @@
 
 #include <algorithm>
 #include <atomic>
-#include <initializer_list>
 #include <map>
 #include <memory>
 #include <string>
@@ -103,7 +102,6 @@
 #include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/backoff/backoff.h"
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/channel/channel_stack_builder.h"
 #include "src/core/lib/channel/channelz.h"
 #include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/debug/trace.h"
@@ -134,14 +132,13 @@
 #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/endpoint_addresses.h"
 #include "src/core/lib/resolver/resolver.h"
-#include "src/core/lib/resolver/server_address.h"
 #include "src/core/lib/security/credentials/credentials.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/slice/slice_string_helpers.h"
 #include "src/core/lib/surface/call.h"
 #include "src/core/lib/surface/channel.h"
-#include "src/core/lib/surface/channel_init.h"
 #include "src/core/lib/surface/channel_stack_type.h"
 #include "src/core/lib/transport/connectivity_state.h"
 #include "src/core/lib/transport/metadata_batch.h"
@@ -387,8 +384,8 @@ class GrpcLb : public LoadBalancingPolicy {
     // Returns a text representation suitable for logging.
     std::string AsText() const;
 
-    // Extracts all non-drop entries into a ServerAddressList.
-    ServerAddressList GetServerAddressList(
+    // Extracts all non-drop entries into an EndpointAddressesList.
+    EndpointAddressesList GetServerAddressList(
         GrpcLbClientStats* client_stats) const;
 
     // Returns true if the serverlist contains at least one drop entry and
@@ -467,7 +464,8 @@ class GrpcLb : public LoadBalancingPolicy {
         : ParentOwningDelegatingChannelControlHelper(std::move(parent)) {}
 
     RefCountedPtr<SubchannelInterface> CreateSubchannel(
-        ServerAddress address, const ChannelArgs& args) override;
+        const grpc_resolved_address& address,
+        const ChannelArgs& per_address_args, const ChannelArgs& args) override;
     void UpdateState(grpc_connectivity_state state, const absl::Status& status,
                      RefCountedPtr<SubchannelPicker> picker) override;
     void RequestReresolution() override;
@@ -571,7 +569,7 @@ class GrpcLb : public LoadBalancingPolicy {
   // Whether we're in fallback mode.
   bool fallback_mode_ = false;
   // The backend addresses from the resolver.
-  absl::StatusOr<ServerAddressList> fallback_backend_addresses_;
+  absl::StatusOr<EndpointAddressesList> fallback_backend_addresses_;
   // The last resolution note from our parent.
   // To be passed to child policy when fallback_backend_addresses_ is empty.
   std::string resolution_note_;
@@ -668,11 +666,11 @@ bool IsServerValid(const GrpcLbServer& server, size_t idx, bool log) {
 }
 
 // Returns addresses extracted from the serverlist.
-ServerAddressList GrpcLb::Serverlist::GetServerAddressList(
+EndpointAddressesList GrpcLb::Serverlist::GetServerAddressList(
     GrpcLbClientStats* client_stats) const {
   RefCountedPtr<GrpcLbClientStats> stats;
   if (client_stats != nullptr) stats = client_stats->Ref();
-  ServerAddressList addresses;
+  EndpointAddressesList endpoints;
   for (size_t i = 0; i < serverlist_.size(); ++i) {
     const GrpcLbServer& server = serverlist_[i];
     if (!IsServerValid(server, i, false)) continue;
@@ -692,11 +690,11 @@ ServerAddressList GrpcLb::Serverlist::GetServerAddressList(
                             : addr_uri.status().ToString().c_str());
     }
     // Add address with a channel arg containing LB token and stats object.
-    addresses.emplace_back(
+    endpoints.emplace_back(
         addr, ChannelArgs().SetObject(MakeRefCounted<TokenAndClientStatsArg>(
                   std::move(lb_token), stats)));
   }
-  return addresses;
+  return endpoints;
 }
 
 bool GrpcLb::Serverlist::ContainsAllDropEntries() const {
@@ -752,9 +750,11 @@ GrpcLb::PickResult GrpcLb::Picker::Pick(PickArgs args) {
       // The metadata value is a hack: we pretend the pointer points to
       // a string and rely on the client_load_reporting filter to know
       // how to interpret it.
+      // NOLINTBEGIN(bugprone-string-constructor)
       args.initial_metadata->Add(
           GrpcLbClientStatsMetadata::key(),
           absl::string_view(reinterpret_cast<const char*>(client_stats), 0));
+      // NOLINTEND(bugprone-string-constructor)
       // Update calls-started.
       client_stats->AddCallStarted();
     }
@@ -779,19 +779,21 @@ GrpcLb::PickResult GrpcLb::Picker::Pick(PickArgs args) {
 //
 
 RefCountedPtr<SubchannelInterface> GrpcLb::Helper::CreateSubchannel(
-    ServerAddress address, const ChannelArgs& args) {
+    const grpc_resolved_address& address, const ChannelArgs& per_address_args,
+    const ChannelArgs& args) {
   if (parent()->shutting_down_) return nullptr;
-  const auto* arg = address.args().GetObject<TokenAndClientStatsArg>();
+  const auto* arg = per_address_args.GetObject<TokenAndClientStatsArg>();
   if (arg == nullptr) {
+    auto addr_str = grpc_sockaddr_to_string(&address, false);
     Crash(
-        absl::StrFormat("[grpclb %p] no TokenAndClientStatsArg for address %p",
-                        parent(), address.ToString().c_str()));
+        absl::StrFormat("[grpclb %p] no TokenAndClientStatsArg for address %s",
+                        parent(), addr_str.value_or("N/A").c_str()));
   }
   std::string lb_token = arg->lb_token();
   RefCountedPtr<GrpcLbClientStats> client_stats = arg->client_stats();
   return MakeRefCounted<SubchannelWrapper>(
-      parent()->channel_control_helper()->CreateSubchannel(std::move(address),
-                                                           args),
+      parent()->channel_control_helper()->CreateSubchannel(
+          address, per_address_args, args),
       parent()->Ref(DEBUG_LOCATION, "SubchannelWrapper"), std::move(lb_token),
       std::move(client_stats));
 }
@@ -839,14 +841,10 @@ void GrpcLb::Helper::UpdateState(grpc_connectivity_state state,
 
 void GrpcLb::Helper::RequestReresolution() {
   if (parent()->shutting_down_) return;
-  // If we are talking to a balancer, we expect to get updated addresses
-  // from the balancer, so we can ignore the re-resolution request from
-  // the child policy. Otherwise, pass the re-resolution request up to the
-  // channel.
-  if (parent()->lb_calld_ == nullptr ||
-      !parent()->lb_calld_->seen_initial_response()) {
-    parent()->channel_control_helper()->RequestReresolution();
-  }
+  // Ignore if we're not in fallback mode, because if we got the backend
+  // addresses from the balancer, re-resolving is not going to fix it.
+  if (!parent()->fallback_mode_) return;
+  parent()->channel_control_helper()->RequestReresolution();
 }
 
 //
@@ -1347,11 +1345,11 @@ void GrpcLb::BalancerCallState::OnBalancerStatusReceivedLocked(
 // helper code for creating balancer channel
 //
 
-ServerAddressList ExtractBalancerAddresses(const ChannelArgs& args) {
-  const ServerAddressList* addresses =
+EndpointAddressesList ExtractBalancerAddresses(const ChannelArgs& args) {
+  const EndpointAddressesList* endpoints =
       FindGrpclbBalancerAddressesInChannelArgs(args);
-  if (addresses != nullptr) return *addresses;
-  return ServerAddressList();
+  if (endpoints != nullptr) return *endpoints;
+  return EndpointAddressesList();
 }
 
 // Returns the channel args for the LB channel, used to create a bidirectional
@@ -1506,6 +1504,9 @@ void GrpcLb::ResetBackoffLocked() {
 }
 
 absl::Status GrpcLb::UpdateLocked(UpdateArgs args) {
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_glb_trace)) {
+    gpr_log(GPR_INFO, "[grpclb %p] received update", this);
+  }
   const bool is_initial_update = lb_channel_ == nullptr;
   config_ = args.config;
   GPR_ASSERT(config_ != nullptr);
@@ -1514,11 +1515,15 @@ absl::Status GrpcLb::UpdateLocked(UpdateArgs args) {
   fallback_backend_addresses_ = std::move(args.addresses);
   if (fallback_backend_addresses_.ok()) {
     // Add null LB token attributes.
-    for (ServerAddress& address : *fallback_backend_addresses_) {
-      address = ServerAddress(
-          address.address(),
-          address.args().SetObject(
+    for (EndpointAddresses& endpoint : *fallback_backend_addresses_) {
+      endpoint = EndpointAddresses(
+          endpoint.addresses(),
+          endpoint.args().SetObject(
               MakeRefCounted<TokenAndClientStatsArg>("", nullptr)));
+      if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_glb_trace)) {
+        gpr_log(GPR_INFO, "[grpclb %p] fallback address: %s", this,
+                endpoint.ToString().c_str());
+      }
     }
   }
   resolution_note_ = std::move(args.resolution_note);
@@ -1566,7 +1571,13 @@ absl::Status GrpcLb::UpdateLocked(UpdateArgs args) {
 
 absl::Status GrpcLb::UpdateBalancerChannelLocked() {
   // Get balancer addresses.
-  ServerAddressList balancer_addresses = ExtractBalancerAddresses(args_);
+  EndpointAddressesList balancer_addresses = ExtractBalancerAddresses(args_);
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_glb_trace)) {
+    for (const auto& endpoint : balancer_addresses) {
+      gpr_log(GPR_INFO, "[grpclb %p] balancer address: %s", this,
+              endpoint.ToString().c_str());
+    }
+  }
   absl::Status status;
   if (balancer_addresses.empty()) {
     status = absl::UnavailableError("balancer address list must be non-empty");
@@ -1767,6 +1778,9 @@ void GrpcLb::CreateOrUpdateChildPolicyLocked() {
     update_args.addresses = serverlist_->GetServerAddressList(
         lb_calld_ == nullptr ? nullptr : lb_calld_->client_stats());
     is_backend_from_grpclb_load_balancer = true;
+    if (update_args.addresses.ok() && update_args.addresses->empty()) {
+      update_args.resolution_note = "empty serverlist from grpclb balancer";
+    }
   }
   update_args.args =
       CreateChildPolicyArgsLocked(is_backend_from_grpclb_load_balancer);
@@ -1865,16 +1879,10 @@ class GrpcLbFactory : public LoadBalancingPolicyFactory {
 void RegisterGrpcLbPolicy(CoreConfiguration::Builder* builder) {
   builder->lb_policy_registry()->RegisterLoadBalancingPolicyFactory(
       std::make_unique<GrpcLbFactory>());
-  builder->channel_init()->RegisterStage(
-      GRPC_CLIENT_SUBCHANNEL, GRPC_CHANNEL_INIT_BUILTIN_PRIORITY,
-      [](ChannelStackBuilder* builder) {
-        auto enable = builder->channel_args().GetBool(
-            GRPC_ARG_GRPCLB_ENABLE_LOAD_REPORTING_FILTER);
-        if (enable.has_value() && *enable) {
-          builder->PrependFilter(&ClientLoadReportingFilter::kFilter);
-        }
-        return true;
-      });
+  builder->channel_init()
+      ->RegisterFilter(GRPC_CLIENT_SUBCHANNEL,
+                       &ClientLoadReportingFilter::kFilter)
+      .IfChannelArg(GRPC_ARG_GRPCLB_ENABLE_LOAD_REPORTING_FILTER, false);
 }
 
 }  // namespace grpc_core

data/src/core/ext/filters/client_channel/lb_policy/grpclb/grpclb_balancer_addresses.cc

@@ -34,25 +34,25 @@ namespace grpc_core {
 namespace {
 
 void* BalancerAddressesArgCopy(void* p) {
-  ServerAddressList* address_list = static_cast<ServerAddressList*>(p);
-  return new ServerAddressList(*address_list);
+  EndpointAddressesList* endpoint_list = static_cast<EndpointAddressesList*>(p);
+  return new EndpointAddressesList(*endpoint_list);
 }
 
 void BalancerAddressesArgDestroy(void* p) {
-  ServerAddressList* address_list = static_cast<ServerAddressList*>(p);
-  delete address_list;
+  EndpointAddressesList* endpoint_list = static_cast<EndpointAddressesList*>(p);
+  delete endpoint_list;
 }
 
 int BalancerAddressesArgCmp(void* p, void* q) {
-  ServerAddressList* address_list1 = static_cast<ServerAddressList*>(p);
-  ServerAddressList* address_list2 = static_cast<ServerAddressList*>(q);
-  if (address_list1 == nullptr || address_list2 == nullptr) {
-    return QsortCompare(address_list1, address_list2);
+  auto* endpoint_list1 = static_cast<EndpointAddressesList*>(p);
+  auto* endpoint_list2 = static_cast<EndpointAddressesList*>(q);
+  if (endpoint_list1 == nullptr || endpoint_list2 == nullptr) {
+    return QsortCompare(endpoint_list1, endpoint_list2);
   }
-  if (address_list1->size() > address_list2->size()) return 1;
-  if (address_list1->size() < address_list2->size()) return -1;
-  for (size_t i = 0; i < address_list1->size(); ++i) {
-    int retval = (*address_list1)[i].Cmp((*address_list2)[i]);
+  if (endpoint_list1->size() > endpoint_list2->size()) return 1;
+  if (endpoint_list1->size() < endpoint_list2->size()) return -1;
+  for (size_t i = 0; i < endpoint_list1->size(); ++i) {
+    int retval = (*endpoint_list1)[i].Cmp((*endpoint_list2)[i]);
     if (retval != 0) return retval;
   }
   return 0;
@@ -65,24 +65,24 @@ const grpc_arg_pointer_vtable kBalancerAddressesArgVtable = {
 }  // namespace
 
 grpc_arg CreateGrpclbBalancerAddressesArg(
-    const ServerAddressList* address_list) {
+    const EndpointAddressesList* endpoint_list) {
   return grpc_channel_arg_pointer_create(
       const_cast<char*>(GRPC_ARG_GRPCLB_BALANCER_ADDRESSES),
-      const_cast<ServerAddressList*>(address_list),
+      const_cast<EndpointAddressesList*>(endpoint_list),
       &kBalancerAddressesArgVtable);
 }
 
-const ServerAddressList* FindGrpclbBalancerAddressesInChannelArgs(
+const EndpointAddressesList* FindGrpclbBalancerAddressesInChannelArgs(
     const ChannelArgs& args) {
-  return args.GetPointer<const ServerAddressList>(
+  return args.GetPointer<const EndpointAddressesList>(
       GRPC_ARG_GRPCLB_BALANCER_ADDRESSES);
 }
 
 ChannelArgs SetGrpcLbBalancerAddresses(const ChannelArgs& args,
-                                       ServerAddressList address_list) {
+                                       EndpointAddressesList endpoint_list) {
   return args.Set(
       GRPC_ARG_GRPCLB_BALANCER_ADDRESSES,
-      ChannelArgs::Pointer(new ServerAddressList(std::move(address_list)),
+      ChannelArgs::Pointer(new EndpointAddressesList(std::move(endpoint_list)),
                            &kBalancerAddressesArgVtable));
 }
 

data/src/core/ext/filters/client_channel/lb_policy/grpclb/grpclb_balancer_addresses.h

@@ -22,16 +22,16 @@
 #include <grpc/grpc.h>
 
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/resolver/server_address.h"
+#include "src/core/lib/resolver/endpoint_addresses.h"
 
 namespace grpc_core {
 
 grpc_arg CreateGrpclbBalancerAddressesArg(
-    const ServerAddressList* address_list);
+    const EndpointAddressesList* endpoint_list);
 GRPC_MUST_USE_RESULT
 ChannelArgs SetGrpcLbBalancerAddresses(const ChannelArgs& args,
-                                       ServerAddressList address_list);
-const ServerAddressList* FindGrpclbBalancerAddressesInChannelArgs(
+                                       EndpointAddressesList endpoint_list);
+const EndpointAddressesList* FindGrpclbBalancerAddressesInChannelArgs(
     const ChannelArgs& args);
 
 }  // namespace grpc_core