grpc 1.31.1 → 1.32.0.pre1

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

@@ -33,7 +33,6 @@
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/iomgr/exec_ctx.h"  // for grpc_millis
 #include "src/core/lib/json/json.h"
-#include "src/core/lib/slice/slice_hash_table.h"
 
 namespace grpc_core {
 namespace internal {

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

@@ -114,10 +114,11 @@ class ResolvingLoadBalancingPolicy::ResolvingControlHelper
     return parent_->channel_control_helper()->CreateSubchannel(args);
   }
 
-  void UpdateState(grpc_connectivity_state state,
+  void UpdateState(grpc_connectivity_state state, const absl::Status& status,
                    std::unique_ptr<SubchannelPicker> picker) override {
     if (parent_->resolver_ == nullptr) return;  // Shutting down.
-    parent_->channel_control_helper()->UpdateState(state, std::move(picker));
+    parent_->channel_control_helper()->UpdateState(state, status,
+                                                   std::move(picker));
   }
 
   void RequestReresolution() override {
@@ -160,7 +161,7 @@ ResolvingLoadBalancingPolicy::ResolvingLoadBalancingPolicy(
   if (GRPC_TRACE_FLAG_ENABLED(*tracer_)) {
     gpr_log(GPR_INFO, "resolving_lb=%p: starting name resolution", this);
   }
-  channel_control_helper()->UpdateState(GRPC_CHANNEL_CONNECTING,
+  channel_control_helper()->UpdateState(GRPC_CHANNEL_CONNECTING, absl::Status(),
                                         absl::make_unique<QueuePicker>(Ref()));
   resolver_->StartLocked();
 }
@@ -214,7 +215,7 @@ void ResolvingLoadBalancingPolicy::OnResolverError(grpc_error* error) {
         "Resolver transient failure", &error, 1);
     helper_->ResolverTransientFailure(GRPC_ERROR_REF(state_error));
     channel_control_helper()->UpdateState(
-        GRPC_CHANNEL_TRANSIENT_FAILURE,
+        GRPC_CHANNEL_TRANSIENT_FAILURE, grpc_error_to_absl_status(state_error),
         absl::make_unique<TransientFailurePicker>(state_error));
   }
   GRPC_ERROR_UNREF(error);

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

@@ -26,23 +26,56 @@ namespace grpc_core {
 // ServerAddress
 //
 
-ServerAddress::ServerAddress(const grpc_resolved_address& address,
-                             grpc_channel_args* args)
-    : address_(address), args_(args) {}
+ServerAddress::ServerAddress(
+    const grpc_resolved_address& address, grpc_channel_args* args,
+    std::map<const char*, std::unique_ptr<AttributeInterface>> attributes)
+    : address_(address), args_(args), attributes_(std::move(attributes)) {}
 
-ServerAddress::ServerAddress(const void* address, size_t address_len,
-                             grpc_channel_args* args)
-    : args_(args) {
+ServerAddress::ServerAddress(
+    const void* address, size_t address_len, grpc_channel_args* args,
+    std::map<const char*, std::unique_ptr<AttributeInterface>> attributes)
+    : args_(args), attributes_(std::move(attributes)) {
   memcpy(address_.addr, address, address_len);
   address_.len = static_cast<socklen_t>(address_len);
 }
 
+namespace {
+
+int CompareAttributes(
+    const std::map<const char*,
+                   std::unique_ptr<ServerAddress::AttributeInterface>>&
+        attributes1,
+    const std::map<const char*,
+                   std::unique_ptr<ServerAddress::AttributeInterface>>&
+        attributes2) {
+  auto it2 = attributes2.begin();
+  for (auto it1 = attributes1.begin(); it1 != attributes1.end(); ++it1) {
+    // attributes2 has fewer elements than attributes1
+    if (it2 == attributes2.end()) return -1;
+    // compare keys
+    int retval = strcmp(it1->first, it2->first);
+    if (retval != 0) return retval;
+    // compare values
+    retval = it1->second->Cmp(it2->second.get());
+    if (retval != 0) return retval;
+    ++it2;
+  }
+  // attributes1 has fewer elements than attributes2
+  if (it2 != attributes2.end()) return 1;
+  // equal
+  return 0;
+}
+
+}  // namespace
+
 int ServerAddress::Cmp(const ServerAddress& other) const {
   if (address_.len > other.address_.len) return 1;
   if (address_.len < other.address_.len) return -1;
   int retval = memcmp(address_.addr, other.address_.addr, address_.len);
   if (retval != 0) return retval;
-  return grpc_channel_args_compare(args_, other.args_);
+  retval = grpc_channel_args_compare(args_, other.args_);
+  if (retval != 0) return retval;
+  return CompareAttributes(attributes_, other.attributes_);
 }
 
 }  // namespace grpc_core

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

@@ -21,6 +21,8 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <map>
+
 #include "absl/container/inlined_vector.h"
 
 #include "src/core/lib/channel/channel_args.h"
@@ -37,26 +39,54 @@ namespace grpc_core {
 // args when a subchannel is created for this address.
 class ServerAddress {
  public:
+  // Base class for resolver-supplied attributes.
+  // Unlike channel args, these attributes don't affect subchannel
+  // uniqueness or behavior.  They are for use by LB policies only.
+  class AttributeInterface {
+   public:
+    virtual ~AttributeInterface();
+
+    // Creates a copy of the attribute.
+    virtual std::unique_ptr<AttributeInterface> Copy() const = 0;
+
+    // Compares this attribute with another.
+    virtual int Cmp(const AttributeInterface* other) const = 0;
+  };
+
   // Takes ownership of args.
-  ServerAddress(const grpc_resolved_address& address, grpc_channel_args* args);
+  ServerAddress(const grpc_resolved_address& address, grpc_channel_args* args,
+                std::map<const char*, std::unique_ptr<AttributeInterface>>
+                    attributes = {});
   ServerAddress(const void* address, size_t address_len,
-                grpc_channel_args* args);
+                grpc_channel_args* args,
+                std::map<const char*, std::unique_ptr<AttributeInterface>>
+                    attributes = {});
 
   ~ServerAddress() { grpc_channel_args_destroy(args_); }
 
   // Copyable.
   ServerAddress(const ServerAddress& other)
-      : address_(other.address_), args_(grpc_channel_args_copy(other.args_)) {}
+      : address_(other.address_), args_(grpc_channel_args_copy(other.args_)) {
+    for (const auto& p : other.attributes_) {
+      attributes_[p.first] = p.second->Copy();
+    }
+  }
   ServerAddress& operator=(const ServerAddress& other) {
     address_ = other.address_;
     grpc_channel_args_destroy(args_);
     args_ = grpc_channel_args_copy(other.args_);
+    attributes_.clear();
+    for (const auto& p : other.attributes_) {
+      attributes_[p.first] = p.second->Copy();
+    }
     return *this;
   }
 
   // Movable.
   ServerAddress(ServerAddress&& other)
-      : address_(other.address_), args_(other.args_) {
+      : address_(other.address_),
+        args_(other.args_),
+        attributes_(std::move(other.attributes_)) {
     other.args_ = nullptr;
   }
   ServerAddress& operator=(ServerAddress&& other) {
@@ -64,6 +94,7 @@ class ServerAddress {
     grpc_channel_args_destroy(args_);
     args_ = other.args_;
     other.args_ = nullptr;
+    attributes_ = std::move(other.attributes_);
     return *this;
   }
 
@@ -74,9 +105,16 @@ class ServerAddress {
   const grpc_resolved_address& address() const { return address_; }
   const grpc_channel_args* args() const { return args_; }
 
+  const AttributeInterface* GetAttribute(const char* key) const {
+    auto it = attributes_.find(key);
+    if (it == attributes_.end()) return nullptr;
+    return it->second.get();
+  }
+
  private:
   grpc_resolved_address address_;
   grpc_channel_args* args_;
+  std::map<const char*, std::unique_ptr<AttributeInterface>> attributes_;
 };
 
 //

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

@@ -26,12 +26,13 @@
 #include <algorithm>
 #include <cstring>
 
+#include "absl/strings/str_format.h"
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/string_util.h>
 
 #include "src/core/ext/filters/client_channel/client_channel.h"
 #include "src/core/ext/filters/client_channel/health/health_check_client.h"
-#include "src/core/ext/filters/client_channel/parse_address.h"
 #include "src/core/ext/filters/client_channel/proxy_mapper_registry.h"
 #include "src/core/ext/filters/client_channel/service_config.h"
 #include "src/core/ext/filters/client_channel/subchannel_pool_interface.h"
@@ -44,6 +45,7 @@
 #include "src/core/lib/gprpp/manual_constructor.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/sync.h"
+#include "src/core/lib/iomgr/parse_address.h"
 #include "src/core/lib/iomgr/sockaddr_utils.h"
 #include "src/core/lib/profiling/timers.h"
 #include "src/core/lib/slice/slice_internal.h"
@@ -325,7 +327,8 @@ class Subchannel::ConnectedSubchannelStateWatcher
   }
 
  private:
-  void OnConnectivityStateChange(grpc_connectivity_state new_state) override {
+  void OnConnectivityStateChange(grpc_connectivity_state new_state,
+                                 const absl::Status& status) override {
     Subchannel* c = subchannel_;
     MutexLock lock(&c->mu_);
     switch (new_state) {
@@ -343,7 +346,15 @@ class Subchannel::ConnectedSubchannelStateWatcher
           if (c->channelz_node() != nullptr) {
             c->channelz_node()->SetChildSocket(nullptr);
           }
-          c->SetConnectivityStateLocked(GRPC_CHANNEL_TRANSIENT_FAILURE);
+          // We need to construct our own status if the underlying state was
+          // shutdown since the accompanying status will be StatusCode::OK
+          // otherwise.
+          c->SetConnectivityStateLocked(
+              GRPC_CHANNEL_TRANSIENT_FAILURE,
+              new_state == GRPC_CHANNEL_SHUTDOWN
+                  ? absl::Status(absl::StatusCode::kUnavailable,
+                                 "Subchannel has disconnected.")
+                  : status);
           c->backoff_begun_ = false;
           c->backoff_.Reset();
         }
@@ -354,7 +365,7 @@ class Subchannel::ConnectedSubchannelStateWatcher
         // a callback for READY, because that was the state we started
         // this watch from.  And a connected subchannel should never go
         // from READY to CONNECTING or IDLE.
-        c->SetConnectivityStateLocked(new_state);
+        c->SetConnectivityStateLocked(new_state, status);
       }
     }
   }
@@ -368,14 +379,15 @@ class Subchannel::AsyncWatcherNotifierLocked {
  public:
   AsyncWatcherNotifierLocked(
       RefCountedPtr<Subchannel::ConnectivityStateWatcherInterface> watcher,
-      Subchannel* subchannel, grpc_connectivity_state state)
+      Subchannel* subchannel, grpc_connectivity_state state,
+      const absl::Status& status)
       : watcher_(std::move(watcher)) {
     RefCountedPtr<ConnectedSubchannel> connected_subchannel;
     if (state == GRPC_CHANNEL_READY) {
       connected_subchannel = subchannel->connected_subchannel_;
     }
     watcher_->PushConnectivityStateChange(
-        {state, std::move(connected_subchannel)});
+        {state, status, std::move(connected_subchannel)});
     ExecCtx::Run(
         DEBUG_LOCATION,
         GRPC_CLOSURE_INIT(&closure_,
@@ -409,9 +421,10 @@ void Subchannel::ConnectivityStateWatcherList::RemoveWatcherLocked(
 }
 
 void Subchannel::ConnectivityStateWatcherList::NotifyLocked(
-    Subchannel* subchannel, grpc_connectivity_state state) {
+    Subchannel* subchannel, grpc_connectivity_state state,
+    const absl::Status& status) {
   for (const auto& p : watchers_) {
-    new AsyncWatcherNotifierLocked(p.second, subchannel, state);
+    new AsyncWatcherNotifierLocked(p.second, subchannel, state, status);
   }
 }
 
@@ -450,7 +463,7 @@ class Subchannel::HealthWatcherMap::HealthWatcher
       grpc_connectivity_state initial_state,
       RefCountedPtr<Subchannel::ConnectivityStateWatcherInterface> watcher) {
     if (state_ != initial_state) {
-      new AsyncWatcherNotifierLocked(watcher, subchannel_, state_);
+      new AsyncWatcherNotifierLocked(watcher, subchannel_, state_, status_);
     }
     watcher_list_.AddWatcherLocked(std::move(watcher));
   }
@@ -462,7 +475,7 @@ class Subchannel::HealthWatcherMap::HealthWatcher
 
   bool HasWatchers() const { return !watcher_list_.empty(); }
 
-  void NotifyLocked(grpc_connectivity_state state) {
+  void NotifyLocked(grpc_connectivity_state state, const absl::Status& status) {
     if (state == GRPC_CHANNEL_READY) {
       // If we had not already notified for CONNECTING state, do so now.
       // (We may have missed this earlier, because if the transition
@@ -470,13 +483,15 @@ class Subchannel::HealthWatcherMap::HealthWatcher
       // subchannel may not have sent us a notification for CONNECTING.)
       if (state_ != GRPC_CHANNEL_CONNECTING) {
         state_ = GRPC_CHANNEL_CONNECTING;
-        watcher_list_.NotifyLocked(subchannel_, state_);
+        status_ = status;
+        watcher_list_.NotifyLocked(subchannel_, state_, status);
       }
       // If we've become connected, start health checking.
       StartHealthCheckingLocked();
     } else {
       state_ = state;
-      watcher_list_.NotifyLocked(subchannel_, state_);
+      status_ = status;
+      watcher_list_.NotifyLocked(subchannel_, state_, status);
       // We're not connected, so stop health checking.
       health_check_client_.reset();
     }
@@ -489,11 +504,13 @@ class Subchannel::HealthWatcherMap::HealthWatcher
   }
 
  private:
-  void OnConnectivityStateChange(grpc_connectivity_state new_state) override {
+  void OnConnectivityStateChange(grpc_connectivity_state new_state,
+                                 const absl::Status& status) override {
     MutexLock lock(&subchannel_->mu_);
     if (new_state != GRPC_CHANNEL_SHUTDOWN && health_check_client_ != nullptr) {
       state_ = new_state;
-      watcher_list_.NotifyLocked(subchannel_, new_state);
+      status_ = status;
+      watcher_list_.NotifyLocked(subchannel_, new_state, status);
     }
   }
 
@@ -508,6 +525,7 @@ class Subchannel::HealthWatcherMap::HealthWatcher
   grpc_core::UniquePtr<char> health_check_service_name_;
   OrphanablePtr<HealthCheckClient> health_check_client_;
   grpc_connectivity_state state_;
+  absl::Status status_;
   ConnectivityStateWatcherList watcher_list_;
 };
 
@@ -547,9 +565,10 @@ void Subchannel::HealthWatcherMap::RemoveWatcherLocked(
   if (!it->second->HasWatchers()) map_.erase(it);
 }
 
-void Subchannel::HealthWatcherMap::NotifyLocked(grpc_connectivity_state state) {
+void Subchannel::HealthWatcherMap::NotifyLocked(grpc_connectivity_state state,
+                                                const absl::Status& status) {
   for (const auto& p : map_) {
-    p.second->NotifyLocked(state);
+    p.second->NotifyLocked(state, status);
   }
 }
 
@@ -724,6 +743,25 @@ Subchannel* Subchannel::Create(OrphanablePtr<SubchannelConnector> connector,
   return registered;
 }
 
+void Subchannel::ThrottleKeepaliveTime(int new_keepalive_time) {
+  MutexLock lock(&mu_);
+  // Only update the value if the new keepalive time is larger.
+  if (new_keepalive_time > keepalive_time_) {
+    keepalive_time_ = new_keepalive_time;
+    if (grpc_trace_subchannel.enabled()) {
+      gpr_log(GPR_INFO, "Subchannel=%p: Throttling keepalive time to %d", this,
+              new_keepalive_time);
+    }
+    const grpc_arg arg_to_add = grpc_channel_arg_integer_create(
+        const_cast<char*>(GRPC_ARG_KEEPALIVE_TIME_MS), new_keepalive_time);
+    const char* arg_to_remove = GRPC_ARG_KEEPALIVE_TIME_MS;
+    grpc_channel_args* new_args = grpc_channel_args_copy_and_add_and_remove(
+        args_, &arg_to_remove, 1, &arg_to_add, 1);
+    grpc_channel_args_destroy(args_);
+    args_ = new_args;
+  }
+}
+
 Subchannel* Subchannel::Ref(GRPC_SUBCHANNEL_REF_EXTRA_ARGS) {
   gpr_atm old_refs;
   old_refs = RefMutate((1 << INTERNAL_REF_BITS),
@@ -826,7 +864,7 @@ void Subchannel::WatchConnectivityState(
   }
   if (health_check_service_name == nullptr) {
     if (state_ != initial_state) {
-      new AsyncWatcherNotifierLocked(watcher, this, state_);
+      new AsyncWatcherNotifierLocked(watcher, this, state_, status_);
     }
     watcher_list_.AddWatcherLocked(std::move(watcher));
   } else {
@@ -928,8 +966,10 @@ const char* SubchannelConnectivityStateChangeString(
 }  // namespace
 
 // Note: Must be called with a state that is different from the current state.
-void Subchannel::SetConnectivityStateLocked(grpc_connectivity_state state) {
+void Subchannel::SetConnectivityStateLocked(grpc_connectivity_state state,
+                                            const absl::Status& status) {
   state_ = state;
+  status_ = status;
   if (channelz_node_ != nullptr) {
     channelz_node_->UpdateConnectivityState(state);
     channelz_node_->AddTraceEvent(
@@ -938,9 +978,9 @@ void Subchannel::SetConnectivityStateLocked(grpc_connectivity_state state) {
             SubchannelConnectivityStateChangeString(state)));
   }
   // Notify non-health watchers.
-  watcher_list_.NotifyLocked(this, state);
+  watcher_list_.NotifyLocked(this, state, status);
   // Notify health watchers.
-  health_watcher_map_.NotifyLocked(state);
+  health_watcher_map_.NotifyLocked(state, status);
 }
 
 void Subchannel::MaybeStartConnectingLocked() {
@@ -1012,7 +1052,7 @@ void Subchannel::ContinueConnectingLocked() {
   next_attempt_deadline_ = backoff_.NextAttemptTime();
   args.deadline = std::max(next_attempt_deadline_, min_deadline);
   args.channel_args = args_;
-  SetConnectivityStateLocked(GRPC_CHANNEL_CONNECTING);
+  SetConnectivityStateLocked(GRPC_CHANNEL_CONNECTING, absl::Status());
   connector_->Connect(args, &connecting_result_, &on_connecting_finished_);
 }
 
@@ -1031,7 +1071,8 @@ void Subchannel::OnConnectingFinished(void* arg, grpc_error* error) {
       GRPC_SUBCHANNEL_WEAK_UNREF(c, "connecting");
     } else {
       gpr_log(GPR_INFO, "Connect failed: %s", grpc_error_string(error));
-      c->SetConnectivityStateLocked(GRPC_CHANNEL_TRANSIENT_FAILURE);
+      c->SetConnectivityStateLocked(GRPC_CHANNEL_TRANSIENT_FAILURE,
+                                    grpc_error_to_absl_status(error));
       GRPC_SUBCHANNEL_WEAK_UNREF(c, "connecting");
     }
   }
@@ -1091,7 +1132,7 @@ bool Subchannel::PublishTransportLocked() {
   connected_subchannel_->StartWatch(
       pollset_set_, MakeOrphanable<ConnectedSubchannelStateWatcher>(this));
   // Report initial state.
-  SetConnectivityStateLocked(GRPC_CHANNEL_READY);
+  SetConnectivityStateLocked(GRPC_CHANNEL_READY, absl::Status());
   return true;
 }
 

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

@@ -39,7 +39,7 @@
 #include "src/core/lib/transport/connectivity_state.h"
 #include "src/core/lib/transport/metadata.h"
 
-// Channel arg containing a grpc_resolved_address to connect to.
+// Channel arg containing a URI indicating the address to connect to.
 #define GRPC_ARG_SUBCHANNEL_ADDRESS "grpc.subchannel_address"
 
 // For debugging refcounting.
@@ -182,6 +182,7 @@ class Subchannel {
    public:
     struct ConnectivityStateChange {
       grpc_connectivity_state state;
+      absl::Status status;
       RefCountedPtr<ConnectedSubchannel> connected_subchannel;
     };
 
@@ -227,6 +228,11 @@ class Subchannel {
   static Subchannel* Create(OrphanablePtr<SubchannelConnector> connector,
                             const grpc_channel_args* args);
 
+  // Throttles keepalive time to \a new_keepalive_time iff \a new_keepalive_time
+  // is larger than the subchannel's current keepalive time. The updated value
+  // will have an affect when the subchannel creates a new ConnectedSubchannel.
+  void ThrottleKeepaliveTime(int new_keepalive_time);
+
   // Strong and weak refcounting.
   Subchannel* Ref(GRPC_SUBCHANNEL_REF_EXTRA_ARGS);
   void Unref(GRPC_SUBCHANNEL_REF_EXTRA_ARGS);
@@ -306,7 +312,8 @@ class Subchannel {
     void RemoveWatcherLocked(ConnectivityStateWatcherInterface* watcher);
 
     // Notifies all watchers in the list about a change to state.
-    void NotifyLocked(Subchannel* subchannel, grpc_connectivity_state state);
+    void NotifyLocked(Subchannel* subchannel, grpc_connectivity_state state,
+                      const absl::Status& status);
 
     void Clear() { watchers_.clear(); }
 
@@ -339,7 +346,8 @@ class Subchannel {
                              ConnectivityStateWatcherInterface* watcher);
 
     // Notifies the watcher when the subchannel's state changes.
-    void NotifyLocked(grpc_connectivity_state state);
+    void NotifyLocked(grpc_connectivity_state state,
+                      const absl::Status& status);
 
     grpc_connectivity_state CheckConnectivityStateLocked(
         Subchannel* subchannel, const char* health_check_service_name);
@@ -357,7 +365,8 @@ class Subchannel {
   class AsyncWatcherNotifierLocked;
 
   // Sets the subchannel's connectivity state to \a state.
-  void SetConnectivityStateLocked(grpc_connectivity_state state);
+  void SetConnectivityStateLocked(grpc_connectivity_state state,
+                                  const absl::Status& status);
 
   // Methods for connection.
   void MaybeStartConnectingLocked();
@@ -400,6 +409,7 @@ class Subchannel {
 
   // Connectivity state tracking.
   grpc_connectivity_state state_ = GRPC_CHANNEL_IDLE;
+  absl::Status status_;
   // The list of watchers without a health check service name.
   ConnectivityStateWatcherList watcher_list_;
   // The map of watchers with health check service names.
@@ -417,6 +427,8 @@ class Subchannel {
   bool have_retry_alarm_ = false;
   // reset_backoff() was called while alarm was pending.
   bool retry_immediately_ = false;
+  // Keepalive time period (-1 for unset)
+  int keepalive_time_ = -1;
 
   // Channelz tracking.
   RefCountedPtr<channelz::SubchannelNode> channelz_node_;