grpc 1.33.0.pre1 → 1.34.0

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

@@ -209,7 +209,7 @@ class ChannelData {
                                 grpc_closure* on_complete,
                                 grpc_closure* watcher_timer_init);
 
-    ~ExternalConnectivityWatcher();
+    ~ExternalConnectivityWatcher() override;
 
     // Removes the watcher from the external_watchers_ map.
     static void RemoveWatcherFromExternalWatchersMap(ChannelData* chand,
@@ -882,9 +882,6 @@ class CallData {
 // ChannelData::SubchannelWrapper
 //
 
-using ServerAddressAttributeMap =
-    std::map<const char*, std::unique_ptr<ServerAddress::AttributeInterface>>;
-
 // This class is a wrapper for Subchannel that hides details of the
 // channel's implementation (such as the health check service name and
 // connected subchannel) from the LB policy API.
@@ -896,13 +893,14 @@ using ServerAddressAttributeMap =
 class ChannelData::SubchannelWrapper : public SubchannelInterface {
  public:
   SubchannelWrapper(ChannelData* chand, Subchannel* subchannel,
-                    grpc_core::UniquePtr<char> health_check_service_name,
-                    ServerAddressAttributeMap attributes)
-      : SubchannelInterface(&grpc_client_channel_routing_trace),
+                    grpc_core::UniquePtr<char> health_check_service_name)
+      : SubchannelInterface(
+            GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_routing_trace)
+                ? "SubchannelWrapper"
+                : nullptr),
         chand_(chand),
         subchannel_(subchannel),
-        health_check_service_name_(std::move(health_check_service_name)),
-        attributes_(std::move(attributes)) {
+        health_check_service_name_(std::move(health_check_service_name)) {
     if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_routing_trace)) {
       gpr_log(GPR_INFO,
               "chand=%p: creating subchannel wrapper %p for subchannel %p",
@@ -921,7 +919,7 @@ class ChannelData::SubchannelWrapper : public SubchannelInterface {
     chand_->subchannel_wrappers_.insert(this);
   }
 
-  ~SubchannelWrapper() {
+  ~SubchannelWrapper() override {
     if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_routing_trace)) {
       gpr_log(GPR_INFO,
               "chand=%p: destroying subchannel wrapper %p for subchannel %p",
@@ -984,13 +982,6 @@ class ChannelData::SubchannelWrapper : public SubchannelInterface {
     return subchannel_->channel_args();
   }
 
-  const ServerAddress::AttributeInterface* GetAttribute(
-      const char* key) const override {
-    auto it = attributes_.find(key);
-    if (it == attributes_.end()) return nullptr;
-    return it->second.get();
-  }
-
   void ThrottleKeepaliveTime(int new_keepalive_time) {
     subchannel_->ThrottleKeepaliveTime(new_keepalive_time);
   }
@@ -1071,7 +1062,7 @@ class ChannelData::SubchannelWrapper : public SubchannelInterface {
           parent_(std::move(parent)),
           last_seen_state_(initial_state) {}
 
-    ~WatcherWrapper() {
+    ~WatcherWrapper() override {
       auto* parent = parent_.release();  // ref owned by lambda
       parent->chand_->work_serializer_->Run(
           [parent]() { parent->Unref(DEBUG_LOCATION, "WatcherWrapper"); },
@@ -1188,7 +1179,6 @@ class ChannelData::SubchannelWrapper : public SubchannelInterface {
   ChannelData* chand_;
   Subchannel* subchannel_;
   grpc_core::UniquePtr<char> health_check_service_name_;
-  ServerAddressAttributeMap attributes_;
   // Maps from the address of the watcher passed to us by the LB policy
   // to the address of the WrapperWatcher that we passed to the underlying
   // subchannel.  This is needed so that when the LB policy calls
@@ -1363,18 +1353,6 @@ class ChannelData::ConnectivityWatcherRemover {
 // ChannelData::ClientChannelControlHelper
 //
 
-}  // namespace
-
-// Allows accessing the attributes from a ServerAddress.
-class ChannelServerAddressPeer {
- public:
-  static ServerAddressAttributeMap GetAttributes(ServerAddress* address) {
-    return std::move(address->attributes_);
-  }
-};
-
-namespace {
-
 class ChannelData::ClientChannelControlHelper
     : public LoadBalancingPolicy::ChannelControlHelper {
  public:
@@ -1426,8 +1404,7 @@ class ChannelData::ClientChannelControlHelper
     subchannel->ThrottleKeepaliveTime(chand_->keepalive_time_);
     // Create and return wrapper for the subchannel.
     return MakeRefCounted<SubchannelWrapper>(
-        chand_, subchannel, std::move(health_check_service_name),
-        ChannelServerAddressPeer::GetAttributes(&address));
+        chand_, subchannel, std::move(health_check_service_name));
   }
 
   void UpdateState(
@@ -2164,7 +2141,7 @@ void ChannelData::RemoveConnectivityWatcher(
 
 CallData::CallData(grpc_call_element* elem, const ChannelData& chand,
                    const grpc_call_element_args& args)
-    : deadline_state_(elem, args.call_stack, args.call_combiner,
+    : deadline_state_(elem, args,
                       GPR_LIKELY(chand.deadline_checking_enabled())
                           ? args.deadline
                           : GRPC_MILLIS_INF_FUTURE),

data/src/core/ext/filters/client_channel/config_selector.h

@@ -24,8 +24,7 @@
 
 #include "absl/strings/string_view.h"
 
-#include <grpc/impl/codegen/grpc_types.h>
-#include <grpc/impl/codegen/slice.h>
+#include <grpc/grpc.h>
 
 #include "src/core/ext/filters/client_channel/service_config.h"
 #include "src/core/ext/filters/client_channel/service_config_parser.h"
@@ -66,7 +65,7 @@ class ConfigSelector : public RefCounted<ConfigSelector> {
     std::function<void()> on_call_committed;
   };
 
-  virtual ~ConfigSelector() = default;
+  ~ConfigSelector() override = default;
 
   virtual const char* name() const = 0;
 

data/src/core/ext/filters/client_channel/health/health_check_client.cc

@@ -51,7 +51,10 @@ HealthCheckClient::HealthCheckClient(
     grpc_pollset_set* interested_parties,
     RefCountedPtr<channelz::SubchannelNode> channelz_node,
     RefCountedPtr<ConnectivityStateWatcherInterface> watcher)
-    : InternallyRefCounted<HealthCheckClient>(&grpc_health_check_client_trace),
+    : InternallyRefCounted<HealthCheckClient>(
+          GRPC_TRACE_FLAG_ENABLED(grpc_health_check_client_trace)
+              ? "HealthCheckClient"
+              : nullptr),
       service_name_(service_name),
       connected_subchannel_(std::move(connected_subchannel)),
       interested_parties_(interested_parties),

data/src/core/ext/filters/client_channel/health/health_check_client.h

@@ -50,7 +50,7 @@ class HealthCheckClient : public InternallyRefCounted<HealthCheckClient> {
                     RefCountedPtr<channelz::SubchannelNode> channelz_node,
                     RefCountedPtr<ConnectivityStateWatcherInterface> watcher);
 
-  ~HealthCheckClient();
+  ~HealthCheckClient() override;
 
   void Orphan() override;
 
@@ -60,7 +60,7 @@ class HealthCheckClient : public InternallyRefCounted<HealthCheckClient> {
    public:
     CallState(RefCountedPtr<HealthCheckClient> health_check_client,
               grpc_pollset_set* interested_parties_);
-    ~CallState();
+    ~CallState() override;
 
     void Orphan() override;
 

data/src/core/ext/filters/client_channel/http_connect_handshaker.cc

@@ -54,7 +54,7 @@ class HttpConnectHandshaker : public Handshaker {
   const char* name() const override { return "http_connect"; }
 
  private:
-  virtual ~HttpConnectHandshaker();
+  ~HttpConnectHandshaker() override;
   void CleanupArgsForFailureLocked();
   void HandshakeFailedLocked(grpc_error* error);
   static void OnWriteDone(void* arg, grpc_error* error);

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

@@ -32,7 +32,11 @@ DebugOnlyTraceFlag grpc_trace_lb_policy_refcount(false, "lb_policy_refcount");
 //
 
 LoadBalancingPolicy::LoadBalancingPolicy(Args args, intptr_t initial_refcount)
-    : InternallyRefCounted(&grpc_trace_lb_policy_refcount, initial_refcount),
+    : InternallyRefCounted(
+          GRPC_TRACE_FLAG_ENABLED(grpc_trace_lb_policy_refcount)
+              ? "LoadBalancingPolicy"
+              : nullptr,
+          initial_refcount),
       work_serializer_(std::move(args.work_serializer)),
       interested_parties_(grpc_pollset_set_create()),
       channel_control_helper_(std::move(args.channel_control_helper)) {}

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

@@ -301,7 +301,7 @@ class LoadBalancingPolicy : public InternallyRefCounted<LoadBalancingPolicy> {
   /// return the parameters they need.
   class Config : public RefCounted<Config> {
    public:
-    virtual ~Config() = default;
+    ~Config() override = default;
 
     // Returns the load balancing policy name
     virtual const char* name() const = 0;
@@ -341,7 +341,7 @@ class LoadBalancingPolicy : public InternallyRefCounted<LoadBalancingPolicy> {
   };
 
   explicit LoadBalancingPolicy(Args args, intptr_t initial_refcount = 1);
-  virtual ~LoadBalancingPolicy();
+  ~LoadBalancingPolicy() override;
 
   // Not copyable nor movable.
   LoadBalancingPolicy(const LoadBalancingPolicy&) = delete;
@@ -376,7 +376,7 @@ class LoadBalancingPolicy : public InternallyRefCounted<LoadBalancingPolicy> {
     explicit QueuePicker(RefCountedPtr<LoadBalancingPolicy> parent)
         : parent_(std::move(parent)) {}
 
-    ~QueuePicker() { parent_.reset(DEBUG_LOCATION, "QueuePicker"); }
+    ~QueuePicker() override { parent_.reset(DEBUG_LOCATION, "QueuePicker"); }
 
     PickResult Pick(PickArgs args) override;
 

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

@@ -36,7 +36,7 @@ class ChildPolicyHandler::Helper
   explicit Helper(RefCountedPtr<ChildPolicyHandler> parent)
       : parent_(std::move(parent)) {}
 
-  ~Helper() { parent_.reset(DEBUG_LOCATION, "Helper"); }
+  ~Helper() override { parent_.reset(DEBUG_LOCATION, "Helper"); }
 
   RefCountedPtr<SubchannelInterface> CreateSubchannel(
       ServerAddress address, const grpc_channel_args& args) override {

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

@@ -36,7 +36,7 @@ class ChildPolicyHandler : public LoadBalancingPolicy {
   ChildPolicyHandler(Args args, TraceFlag* tracer)
       : LoadBalancingPolicy(std::move(args)), tracer_(tracer) {}
 
-  virtual const char* name() const override { return "child_policy_handler"; }
+  const char* name() const override { return "child_policy_handler"; }
 
   void UpdateLocked(UpdateArgs args) override;
   void ExitIdleLocked() override;

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

@@ -164,7 +164,7 @@ class GrpcLb : public LoadBalancingPolicy {
    public:
     explicit BalancerCallState(
         RefCountedPtr<LoadBalancingPolicy> parent_grpclb_policy);
-    ~BalancerCallState();
+    ~BalancerCallState() override;
 
     // It's the caller's responsibility to ensure that Orphan() is called from
     // inside the combiner.
@@ -235,6 +235,23 @@ class GrpcLb : public LoadBalancingPolicy {
     grpc_closure client_load_report_closure_;
   };
 
+  class SubchannelWrapper : public DelegatingSubchannel {
+   public:
+    SubchannelWrapper(RefCountedPtr<SubchannelInterface> subchannel,
+                      std::string lb_token,
+                      RefCountedPtr<GrpcLbClientStats> client_stats)
+        : DelegatingSubchannel(std::move(subchannel)),
+          lb_token_(std::move(lb_token)),
+          client_stats_(std::move(client_stats)) {}
+
+    const std::string& lb_token() const { return lb_token_; }
+    GrpcLbClientStats* client_stats() const { return client_stats_.get(); }
+
+   private:
+    std::string lb_token_;
+    RefCountedPtr<GrpcLbClientStats> client_stats_;
+  };
+
   class TokenAndClientStatsAttribute
       : public ServerAddress::AttributeInterface {
    public:
@@ -262,7 +279,9 @@ class GrpcLb : public LoadBalancingPolicy {
     }
 
     const std::string& lb_token() const { return lb_token_; }
-    GrpcLbClientStats* client_stats() const { return client_stats_.get(); }
+    RefCountedPtr<GrpcLbClientStats> client_stats() const {
+      return client_stats_;
+    }
 
    private:
     std::string lb_token_;
@@ -310,21 +329,16 @@ class GrpcLb : public LoadBalancingPolicy {
 
   class Picker : public SubchannelPicker {
    public:
-    Picker(GrpcLb* parent, RefCountedPtr<Serverlist> serverlist,
+    Picker(RefCountedPtr<Serverlist> serverlist,
            std::unique_ptr<SubchannelPicker> child_picker,
            RefCountedPtr<GrpcLbClientStats> client_stats)
-        : parent_(parent),
-          serverlist_(std::move(serverlist)),
+        : serverlist_(std::move(serverlist)),
           child_picker_(std::move(child_picker)),
           client_stats_(std::move(client_stats)) {}
 
     PickResult Pick(PickArgs args) override;
 
    private:
-    // Storing the address for logging, but not holding a ref.
-    // DO NOT DEFERENCE!
-    GrpcLb* parent_;
-
     // Serverlist to be used for determining drops.
     RefCountedPtr<Serverlist> serverlist_;
 
@@ -355,7 +369,7 @@ class GrpcLb : public LoadBalancingPolicy {
         : AsyncConnectivityStateWatcherInterface(parent->work_serializer()),
           parent_(std::move(parent)) {}
 
-    ~StateWatcher() { parent_.reset(DEBUG_LOCATION, "StateWatcher"); }
+    ~StateWatcher() override { parent_.reset(DEBUG_LOCATION, "StateWatcher"); }
 
    private:
     void OnConnectivityStateChange(grpc_connectivity_state new_state,
@@ -381,7 +395,7 @@ class GrpcLb : public LoadBalancingPolicy {
     RefCountedPtr<GrpcLb> parent_;
   };
 
-  ~GrpcLb();
+  ~GrpcLb() override;
 
   void ShutdownLocked() override;
 
@@ -591,7 +605,8 @@ const char* GrpcLb::Serverlist::ShouldDrop() {
 GrpcLb::PickResult GrpcLb::Picker::Pick(PickArgs args) {
   PickResult result;
   // Check if we should drop the call.
-  const char* drop_token = serverlist_->ShouldDrop();
+  const char* drop_token =
+      serverlist_ == nullptr ? nullptr : serverlist_->ShouldDrop();
   if (drop_token != nullptr) {
     // Update client load reporting stats to indicate the number of
     // dropped calls.  Note that we have to do this here instead of in
@@ -609,17 +624,11 @@ GrpcLb::PickResult GrpcLb::Picker::Pick(PickArgs args) {
   // If pick succeeded, add LB token to initial metadata.
   if (result.type == PickResult::PICK_COMPLETE &&
       result.subchannel != nullptr) {
-    const TokenAndClientStatsAttribute* attribute =
-        static_cast<const TokenAndClientStatsAttribute*>(
-            result.subchannel->GetAttribute(kGrpcLbAddressAttributeKey));
-    if (attribute == nullptr) {
-      gpr_log(GPR_ERROR, "[grpclb %p picker %p] No LB token for subchannel %p",
-              parent_, this, result.subchannel.get());
-      abort();
-    }
+    const SubchannelWrapper* subchannel_wrapper =
+        static_cast<SubchannelWrapper*>(result.subchannel.get());
     // Encode client stats object into metadata for use by
     // client_load_reporting filter.
-    GrpcLbClientStats* client_stats = attribute->client_stats();
+    GrpcLbClientStats* client_stats = subchannel_wrapper->client_stats();
     if (client_stats != nullptr) {
       client_stats->Ref().release();  // Ref passed via metadata.
       // The metadata value is a hack: we pretend the pointer points to
@@ -635,10 +644,14 @@ GrpcLb::PickResult GrpcLb::Picker::Pick(PickArgs args) {
     // Create a new copy on the call arena, since the subchannel list
     // may get refreshed between when we return this pick and when the
     // initial metadata goes out on the wire.
-    char* lb_token = static_cast<char*>(
-        args.call_state->Alloc(attribute->lb_token().size() + 1));
-    strcpy(lb_token, attribute->lb_token().c_str());
-    args.initial_metadata->Add(kGrpcLbLbTokenMetadataKey, lb_token);
+    if (!subchannel_wrapper->lb_token().empty()) {
+      char* lb_token = static_cast<char*>(
+          args.call_state->Alloc(subchannel_wrapper->lb_token().size() + 1));
+      strcpy(lb_token, subchannel_wrapper->lb_token().c_str());
+      args.initial_metadata->Add(kGrpcLbLbTokenMetadataKey, lb_token);
+    }
+    // Unwrap subchannel to pass up to the channel.
+    result.subchannel = subchannel_wrapper->wrapped_subchannel();
   }
   return result;
 }
@@ -650,8 +663,21 @@ GrpcLb::PickResult GrpcLb::Picker::Pick(PickArgs args) {
 RefCountedPtr<SubchannelInterface> GrpcLb::Helper::CreateSubchannel(
     ServerAddress address, const grpc_channel_args& args) {
   if (parent_->shutting_down_) return nullptr;
-  return parent_->channel_control_helper()->CreateSubchannel(std::move(address),
-                                                             args);
+  const TokenAndClientStatsAttribute* attribute =
+      static_cast<const TokenAndClientStatsAttribute*>(
+          address.GetAttribute(kGrpcLbAddressAttributeKey));
+  if (attribute == nullptr) {
+    gpr_log(GPR_ERROR,
+            "[grpclb %p] no TokenAndClientStatsAttribute for address %p",
+            parent_.get(), address.ToString().c_str());
+    abort();
+  }
+  std::string lb_token = attribute->lb_token();
+  RefCountedPtr<GrpcLbClientStats> client_stats = attribute->client_stats();
+  return MakeRefCounted<SubchannelWrapper>(
+      parent_->channel_control_helper()->CreateSubchannel(std::move(address),
+                                                          args),
+      std::move(lb_token), std::move(client_stats));
 }
 
 void GrpcLb::Helper::UpdateState(grpc_connectivity_state state,
@@ -662,56 +688,37 @@ void GrpcLb::Helper::UpdateState(grpc_connectivity_state state,
   parent_->child_policy_ready_ = state == GRPC_CHANNEL_READY;
   // Enter fallback mode if needed.
   parent_->MaybeEnterFallbackModeAfterStartup();
-  // There are three cases to consider here:
-  // 1. We're in fallback mode.  In this case, we're always going to use
-  //    the child policy's result, so we pass its picker through as-is.
-  // 2. The serverlist contains only drop entries.  In this case, we
-  //    want to use our own picker so that we can return the drops.
-  // 3. Not in fallback mode and serverlist is not all drops (i.e., it
-  //    may be empty or contain at least one backend address).  There are
-  //    two sub-cases:
-  //    a. The child policy is reporting state READY.  In this case, we wrap
-  //       the child's picker in our own, so that we can handle drops and LB
-  //       token metadata for each pick.
-  //    b. The child policy is reporting a state other than READY.  In this
-  //       case, we don't want to use our own picker, because we don't want
-  //       to process drops for picks that yield a QUEUE result; this would
-  //       result in dropping too many calls, since we will see the
-  //       queued picks multiple times, and we'd consider each one a
-  //       separate call for the drop calculation.
-  //
-  // Cases 1 and 3b: return picker from the child policy as-is.
-  if (parent_->serverlist_ == nullptr ||
-      (!parent_->serverlist_->ContainsAllDropEntries() &&
-       state != GRPC_CHANNEL_READY)) {
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_glb_trace)) {
-      gpr_log(GPR_INFO,
-              "[grpclb %p helper %p] state=%s (%s) passing "
-              "child picker %p as-is",
-              parent_.get(), this, ConnectivityStateName(state),
-              status.ToString().c_str(), picker.get());
-    }
-    parent_->channel_control_helper()->UpdateState(state, status,
-                                                   std::move(picker));
-    return;
-  }
-  // Cases 2 and 3a: wrap picker from the child in our own picker.
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_glb_trace)) {
-    gpr_log(GPR_INFO,
-            "[grpclb %p helper %p] state=%s (%s) wrapping child "
-            "picker %p",
-            parent_.get(), this, ConnectivityStateName(state),
-            status.ToString().c_str(), picker.get());
+  // We pass the serverlist to the picker so that it can handle drops.
+  // However, we don't want to handle drops in the case where the child
+  // policy is reporting a state other than READY (unless we are
+  // dropping *all* calls), because we don't want to process drops for picks
+  // that yield a QUEUE result; this would result in dropping too many calls,
+  // since we will see the queued picks multiple times, and we'd consider each
+  // one a separate call for the drop calculation.  So in this case, we pass
+  // a null serverlist to the picker, which tells it not to do drops.
+  RefCountedPtr<Serverlist> serverlist;
+  if (state == GRPC_CHANNEL_READY ||
+      (parent_->serverlist_ != nullptr &&
+       parent_->serverlist_->ContainsAllDropEntries())) {
+    serverlist = parent_->serverlist_;
   }
   RefCountedPtr<GrpcLbClientStats> client_stats;
   if (parent_->lb_calld_ != nullptr &&
       parent_->lb_calld_->client_stats() != nullptr) {
     client_stats = parent_->lb_calld_->client_stats()->Ref();
   }
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_glb_trace)) {
+    gpr_log(GPR_INFO,
+            "[grpclb %p helper %p] state=%s (%s) wrapping child "
+            "picker %p (serverlist=%p, client_stats=%p)",
+            parent_.get(), this, ConnectivityStateName(state),
+            status.ToString().c_str(), picker.get(), serverlist.get(),
+            client_stats.get());
+  }
   parent_->channel_control_helper()->UpdateState(
       state, status,
-      absl::make_unique<Picker>(parent_.get(), parent_->serverlist_,
-                                std::move(picker), std::move(client_stats)));
+      absl::make_unique<Picker>(std::move(serverlist), std::move(picker),
+                                std::move(client_stats)));
 }
 
 void GrpcLb::Helper::RequestReresolution() {
@@ -738,7 +745,9 @@ void GrpcLb::Helper::AddTraceEvent(TraceSeverity severity,
 
 GrpcLb::BalancerCallState::BalancerCallState(
     RefCountedPtr<LoadBalancingPolicy> parent_grpclb_policy)
-    : InternallyRefCounted<BalancerCallState>(&grpc_lb_glb_trace),
+    : InternallyRefCounted<BalancerCallState>(
+          GRPC_TRACE_FLAG_ENABLED(grpc_lb_glb_trace) ? "BalancerCallState"
+                                                     : nullptr),
       grpclb_policy_(std::move(parent_grpclb_policy)) {
   GPR_ASSERT(grpclb_policy_ != nullptr);
   GPR_ASSERT(!grpclb_policy()->shutting_down_);
@@ -932,7 +941,7 @@ void GrpcLb::BalancerCallState::SendClientLoadReportLocked() {
   if (num_calls_started == 0 && num_calls_finished == 0 &&
       num_calls_finished_with_client_failed_to_send == 0 &&
       num_calls_finished_known_received == 0 &&
-      (drop_token_counts == nullptr || drop_token_counts->size() == 0)) {
+      (drop_token_counts == nullptr || drop_token_counts->empty())) {
     if (last_client_load_report_counters_were_zero_) {
       ScheduleNextClientLoadReportLocked();
       return;