grpc 1.24.0 → 1.25.0.pre1

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

@@ -46,11 +46,35 @@ grpc_connectivity_state grpc_client_channel_check_connectivity_state(
 int grpc_client_channel_num_external_connectivity_watchers(
     grpc_channel_element* elem);
 
+// Starts a one-time connectivity state watch.  When the channel's state
+// becomes different from *state, sets *state to the new state and
+// schedules on_complete.  The watcher_timer_init callback is invoked as
+// soon as the watch is actually started (i.e., after hopping into the
+// client channel combiner).  I/O will be serviced via pollent.
+//
+// This is intended to be used when starting a watch from outside of C-core
+// via grpc_channel_watch_connectivity_state().  It should not be used
+// by other callers.
 void grpc_client_channel_watch_connectivity_state(
     grpc_channel_element* elem, grpc_polling_entity pollent,
     grpc_connectivity_state* state, grpc_closure* on_complete,
     grpc_closure* watcher_timer_init);
 
+// Starts and stops a connectivity watch.  The watcher will be initially
+// notified as soon as the state changes from initial_state and then on
+// every subsequent state change until either the watch is stopped or
+// it is notified that the state has changed to SHUTDOWN.
+//
+// This is intended to be used when starting watches from code inside of
+// C-core (e.g., for a nested control plane channel for things like xds).
+void grpc_client_channel_start_connectivity_watch(
+    grpc_channel_element* elem, grpc_connectivity_state initial_state,
+    grpc_core::OrphanablePtr<grpc_core::AsyncConnectivityStateWatcherInterface>
+        watcher);
+void grpc_client_channel_stop_connectivity_watch(
+    grpc_channel_element* elem,
+    grpc_core::AsyncConnectivityStateWatcherInterface* watcher);
+
 /* Debug helper: pull the subchannel call from a call stack element */
 grpc_core::RefCountedPtr<grpc_core::SubchannelCall>
 grpc_client_channel_get_subchannel_call(grpc_call_element* elem);

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

@@ -53,9 +53,8 @@ void SubchannelNode::PopulateConnectivityState(grpc_json* json) {
       connectivity_state_.Load(MemoryOrder::RELAXED);
   json = grpc_json_create_child(nullptr, json, "state", nullptr,
                                 GRPC_JSON_OBJECT, false);
-  grpc_json_create_child(nullptr, json, "state",
-                         grpc_connectivity_state_name(state), GRPC_JSON_STRING,
-                         false);
+  grpc_json_create_child(nullptr, json, "state", ConnectivityStateName(state),
+                         GRPC_JSON_STRING, false);
 }
 
 grpc_json* SubchannelNode::RenderJson() {

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

@@ -24,7 +24,6 @@
 #include <grpc/impl/codegen/grpc_types.h>
 
 #include "src/core/ext/filters/client_channel/subchannel.h"
-#include "src/core/lib/gprpp/abstract.h"
 
 namespace grpc_core {
 
@@ -33,8 +32,7 @@ class ClientChannelFactory {
   virtual ~ClientChannelFactory() = default;
 
   // Creates a subchannel with the specified args.
-  virtual Subchannel* CreateSubchannel(const grpc_channel_args* args)
-      GRPC_ABSTRACT;
+  virtual Subchannel* CreateSubchannel(const grpc_channel_args* args) = 0;
 
   // Returns a channel arg containing the specified factory.
   static grpc_arg CreateChannelArg(ClientChannelFactory* factory);
@@ -42,8 +40,6 @@ class ClientChannelFactory {
   // Returns the factory from args, or null if not found.
   static ClientChannelFactory* GetFromChannelArgs(
       const grpc_channel_args* args);
-
-  GRPC_ABSTRACT_BASE_CLASS
 };
 
 }  // namespace grpc_core

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

@@ -47,12 +47,14 @@ HealthCheckClient::HealthCheckClient(
     const char* service_name,
     RefCountedPtr<ConnectedSubchannel> connected_subchannel,
     grpc_pollset_set* interested_parties,
-    RefCountedPtr<channelz::SubchannelNode> channelz_node)
+    RefCountedPtr<channelz::SubchannelNode> channelz_node,
+    RefCountedPtr<ConnectivityStateWatcherInterface> watcher)
     : InternallyRefCounted<HealthCheckClient>(&grpc_health_check_client_trace),
       service_name_(service_name),
       connected_subchannel_(std::move(connected_subchannel)),
       interested_parties_(interested_parties),
       channelz_node_(std::move(channelz_node)),
+      watcher_(std::move(watcher)),
       retry_backoff_(
           BackOff::Options()
               .set_initial_backoff(
@@ -73,43 +75,21 @@ HealthCheckClient::~HealthCheckClient() {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_health_check_client_trace)) {
     gpr_log(GPR_INFO, "destroying HealthCheckClient %p", this);
   }
-  GRPC_ERROR_UNREF(error_);
-}
-
-void HealthCheckClient::NotifyOnHealthChange(grpc_connectivity_state* state,
-                                             grpc_closure* closure) {
-  MutexLock lock(&mu_);
-  GPR_ASSERT(notify_state_ == nullptr);
-  if (*state != state_) {
-    *state = state_;
-    GRPC_CLOSURE_SCHED(closure, GRPC_ERROR_REF(error_));
-    return;
-  }
-  notify_state_ = state;
-  on_health_changed_ = closure;
 }
 
 void HealthCheckClient::SetHealthStatus(grpc_connectivity_state state,
-                                        grpc_error* error) {
+                                        const char* reason) {
   MutexLock lock(&mu_);
-  SetHealthStatusLocked(state, error);
+  SetHealthStatusLocked(state, reason);
 }
 
 void HealthCheckClient::SetHealthStatusLocked(grpc_connectivity_state state,
-                                              grpc_error* error) {
+                                              const char* reason) {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_health_check_client_trace)) {
-    gpr_log(GPR_INFO, "HealthCheckClient %p: setting state=%d error=%s", this,
-            state, grpc_error_string(error));
-  }
-  if (notify_state_ != nullptr && *notify_state_ != state) {
-    *notify_state_ = state;
-    notify_state_ = nullptr;
-    GRPC_CLOSURE_SCHED(on_health_changed_, GRPC_ERROR_REF(error));
-    on_health_changed_ = nullptr;
+    gpr_log(GPR_INFO, "HealthCheckClient %p: setting state=%s reason=%s", this,
+            ConnectivityStateName(state), reason);
   }
-  state_ = state;
-  GRPC_ERROR_UNREF(error_);
-  error_ = error;
+  if (watcher_ != nullptr) watcher_->Notify(state);
 }
 
 void HealthCheckClient::Orphan() {
@@ -118,13 +98,8 @@ void HealthCheckClient::Orphan() {
   }
   {
     MutexLock lock(&mu_);
-    if (on_health_changed_ != nullptr) {
-      *notify_state_ = GRPC_CHANNEL_SHUTDOWN;
-      notify_state_ = nullptr;
-      GRPC_CLOSURE_SCHED(on_health_changed_, GRPC_ERROR_NONE);
-      on_health_changed_ = nullptr;
-    }
     shutting_down_ = true;
+    watcher_.reset();
     call_state_.reset();
     if (retry_timer_callback_pending_) {
       grpc_timer_cancel(&retry_timer_);
@@ -141,7 +116,7 @@ void HealthCheckClient::StartCall() {
 void HealthCheckClient::StartCallLocked() {
   if (shutting_down_) return;
   GPR_ASSERT(call_state_ == nullptr);
-  SetHealthStatusLocked(GRPC_CHANNEL_CONNECTING, GRPC_ERROR_NONE);
+  SetHealthStatusLocked(GRPC_CHANNEL_CONNECTING, "starting health watch");
   call_state_ = MakeOrphanable<CallState>(Ref(), interested_parties_);
   if (GRPC_TRACE_FLAG_ENABLED(grpc_health_check_client_trace)) {
     gpr_log(GPR_INFO, "HealthCheckClient %p: created CallState %p", this,
@@ -152,10 +127,8 @@ void HealthCheckClient::StartCallLocked() {
 
 void HealthCheckClient::StartRetryTimer() {
   MutexLock lock(&mu_);
-  SetHealthStatusLocked(
-      GRPC_CHANNEL_TRANSIENT_FAILURE,
-      GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "health check call failed; will retry after backoff"));
+  SetHealthStatusLocked(GRPC_CHANNEL_TRANSIENT_FAILURE,
+                        "health check call failed; will retry after backoff");
   grpc_millis next_try = retry_backoff_.NextAttemptTime();
   if (GRPC_TRACE_FLAG_ENABLED(grpc_health_check_client_trace)) {
     gpr_log(GPR_INFO, "HealthCheckClient %p: health check call lost...", this);
@@ -489,10 +462,10 @@ void HealthCheckClient::CallState::DoneReadingRecvMessage(grpc_error* error) {
   const bool healthy = DecodeResponse(&recv_message_buffer_, &error);
   const grpc_connectivity_state state =
       healthy ? GRPC_CHANNEL_READY : GRPC_CHANNEL_TRANSIENT_FAILURE;
-  if (error == GRPC_ERROR_NONE && !healthy) {
-    error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("backend unhealthy");
-  }
-  health_check_client_->SetHealthStatus(state, error);
+  const char* reason = error == GRPC_ERROR_NONE && !healthy
+                           ? "backend unhealthy"
+                           : grpc_error_string(error);
+  health_check_client_->SetHealthStatus(state, reason);
   seen_response_.Store(true, MemoryOrder::RELEASE);
   grpc_slice_buffer_destroy_internal(&recv_message_buffer_);
   // Start another recv_message batch.
@@ -603,7 +576,7 @@ void HealthCheckClient::CallState::RecvTrailingMetadataReady(
           grpc_slice_from_static_string(kErrorMessage));
     }
     self->health_check_client_->SetHealthStatus(GRPC_CHANNEL_READY,
-                                                GRPC_ERROR_NONE);
+                                                kErrorMessage);
     retry = false;
   }
   self->CallEnded(retry);

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

@@ -47,16 +47,11 @@ class HealthCheckClient : public InternallyRefCounted<HealthCheckClient> {
   HealthCheckClient(const char* service_name,
                     RefCountedPtr<ConnectedSubchannel> connected_subchannel,
                     grpc_pollset_set* interested_parties,
-                    RefCountedPtr<channelz::SubchannelNode> channelz_node);
+                    RefCountedPtr<channelz::SubchannelNode> channelz_node,
+                    RefCountedPtr<ConnectivityStateWatcherInterface> watcher);
 
   ~HealthCheckClient();
 
-  // When the health state changes from *state, sets *state to the new
-  // value and schedules closure.
-  // Only one closure can be outstanding at a time.
-  void NotifyOnHealthChange(grpc_connectivity_state* state,
-                            grpc_closure* closure);
-
   void Orphan() override;
 
  private:
@@ -151,9 +146,9 @@ class HealthCheckClient : public InternallyRefCounted<HealthCheckClient> {
   void StartRetryTimer();
   static void OnRetryTimer(void* arg, grpc_error* error);
 
-  void SetHealthStatus(grpc_connectivity_state state, grpc_error* error);
+  void SetHealthStatus(grpc_connectivity_state state, const char* reason);
   void SetHealthStatusLocked(grpc_connectivity_state state,
-                             grpc_error* error);  // Requires holding mu_.
+                             const char* reason);  // Requires holding mu_.
 
   const char* service_name_;  // Do not own.
   RefCountedPtr<ConnectedSubchannel> connected_subchannel_;
@@ -161,10 +156,7 @@ class HealthCheckClient : public InternallyRefCounted<HealthCheckClient> {
   RefCountedPtr<channelz::SubchannelNode> channelz_node_;
 
   Mutex mu_;
-  grpc_connectivity_state state_ = GRPC_CHANNEL_CONNECTING;
-  grpc_error* error_ = GRPC_ERROR_NONE;
-  grpc_connectivity_state* notify_state_ = nullptr;
-  grpc_closure* on_health_changed_ = nullptr;
+  RefCountedPtr<ConnectivityStateWatcherInterface> watcher_;
   bool shutting_down_ = false;
 
   // The data associated with the current health check call.  It holds a ref

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

@@ -356,5 +356,5 @@ void grpc_http_connect_register_handshaker_factory() {
   using namespace grpc_core;
   HandshakerRegistry::RegisterHandshakerFactory(
       true /* at_start */, HANDSHAKER_CLIENT,
-      UniquePtr<HandshakerFactory>(New<HttpConnectHandshakerFactory>()));
+      MakeUnique<HttpConnectHandshakerFactory>());
 }

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

@@ -105,9 +105,8 @@ LoadBalancingPolicy::PickResult LoadBalancingPolicy::QueuePicker::Pick(
   if (!exit_idle_called_) {
     exit_idle_called_ = true;
     parent_->Ref().release();  // ref held by closure.
-    GRPC_CLOSURE_SCHED(
-        GRPC_CLOSURE_CREATE(&CallExitIdle, parent_.get(),
-                            grpc_combiner_scheduler(parent_->combiner())),
+    parent_->combiner()->Run(
+        GRPC_CLOSURE_CREATE(&CallExitIdle, parent_.get(), nullptr),
         GRPC_ERROR_NONE);
   }
   PickResult result;

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

@@ -21,10 +21,11 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <iterator>
+
 #include "src/core/ext/filters/client_channel/server_address.h"
 #include "src/core/ext/filters/client_channel/service_config.h"
 #include "src/core/ext/filters/client_channel/subchannel_interface.h"
-#include "src/core/lib/gprpp/abstract.h"
 #include "src/core/lib/gprpp/map.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
@@ -109,23 +110,42 @@ class LoadBalancingPolicy : public InternallyRefCounted<LoadBalancingPolicy> {
     /// automatically freed when the call is complete.
     /// It is more efficient to use this than to allocate memory directly
     /// for allocations that need to be made on a per-call basis.
-    virtual void* Alloc(size_t size) GRPC_ABSTRACT;
+    virtual void* Alloc(size_t size) = 0;
 
     /// Returns the backend metric data returned by the server for the call,
     /// or null if no backend metric data was returned.
-    virtual const BackendMetricData* GetBackendMetricData() GRPC_ABSTRACT;
-
-    GRPC_ABSTRACT_BASE_CLASS
+    virtual const BackendMetricData* GetBackendMetricData() = 0;
   };
 
   /// Interface for accessing metadata.
   /// Implemented by the client channel and used by the SubchannelPicker.
   class MetadataInterface {
    public:
-    // Implementations whose iterators fit in intptr_t may internally
-    // cast this directly to their iterator type.  Otherwise, they may
-    // dynamically allocate their iterators and store the address here.
-    typedef intptr_t Iterator;
+    class iterator
+        : public std::iterator<std::input_iterator_tag,
+                               std::pair<StringView, StringView>,  // value_type
+                               std::ptrdiff_t,  // difference_type
+                               std::pair<StringView, StringView>*,  // pointer
+                               std::pair<StringView, StringView>&   // reference
+                               > {
+     public:
+      iterator(const MetadataInterface* md, intptr_t handle)
+          : md_(md), handle_(handle) {}
+      iterator& operator++() {
+        handle_ = md_->IteratorHandleNext(handle_);
+        return *this;
+      }
+      bool operator==(iterator other) const {
+        return md_ == other.md_ && handle_ == other.handle_;
+      }
+      bool operator!=(iterator other) const { return !(*this == other); }
+      value_type operator*() const { return md_->IteratorHandleGet(handle_); }
+
+     private:
+      friend class MetadataInterface;
+      const MetadataInterface* md_;
+      intptr_t handle_;
+    };
 
     virtual ~MetadataInterface() = default;
 
@@ -134,20 +154,25 @@ class LoadBalancingPolicy : public InternallyRefCounted<LoadBalancingPolicy> {
     /// Implementations must ensure that the key and value remain alive
     /// until the call ends.  If desired, they may be allocated via
     /// CallState::Alloc().
-    virtual void Add(StringView key, StringView value) GRPC_ABSTRACT;
+    virtual void Add(StringView key, StringView value) = 0;
 
     /// Iteration interface.
-    virtual Iterator Begin() const GRPC_ABSTRACT;
-    virtual bool IsEnd(Iterator it) const GRPC_ABSTRACT;
-    virtual void Next(Iterator* it) const GRPC_ABSTRACT;
-    virtual StringView Key(Iterator it) const GRPC_ABSTRACT;
-    virtual StringView Value(Iterator it) const GRPC_ABSTRACT;
+    virtual iterator begin() const = 0;
+    virtual iterator end() const = 0;
+
+    /// Removes the element pointed to by \a it.
+    /// Returns an iterator pointing to the next element.
+    virtual iterator erase(iterator it) = 0;
+
+   protected:
+    intptr_t GetIteratorHandle(const iterator& it) const { return it.handle_; }
 
-    /// Removes the element pointed to by \a it, which is modified to
-    /// point to the next element.
-    virtual void Erase(Iterator* it) GRPC_ABSTRACT;
+   private:
+    friend class iterator;
 
-    GRPC_ABSTRACT_BASE_CLASS
+    virtual intptr_t IteratorHandleNext(intptr_t handle) const = 0;
+    virtual std::pair<StringView /*key*/, StringView /*value */>
+    IteratorHandleGet(intptr_t handle) const = 0;
   };
 
   /// Arguments used when picking a subchannel for a call.
@@ -194,20 +219,14 @@ class LoadBalancingPolicy : public InternallyRefCounted<LoadBalancingPolicy> {
 
     /// Used only if type is PICK_COMPLETE.
     /// Callback set by LB policy to be notified of trailing metadata.
-    /// The user_data argument will be set to the
-    /// recv_trailing_metadata_ready_user_data field.
-    /// recv_trailing_metadata will be set to the metadata, which may be
-    /// modified by the callback.  The callback does not take ownership,
-    /// however, so any data that needs to be used after returning must
-    /// be copied.
-    /// call_state can be used to obtain backend metric data.
-    // TODO(roth): Replace grpc_error with something better before we allow
-    // people outside of gRPC team to use this API.
-    void (*recv_trailing_metadata_ready)(
-        void* user_data, grpc_error* error,
-        MetadataInterface* recv_trailing_metadata,
-        CallState* call_state) = nullptr;
-    void* recv_trailing_metadata_ready_user_data = nullptr;
+    /// If set by LB policy, the client channel will invoke the callback
+    /// when trailing metadata is returned.
+    /// The metadata may be modified by the callback.  However, the callback
+    /// does not take ownership, so any data that needs to be used after
+    /// returning must be copied.
+    /// The call state can be used to obtain backend metric data.
+    std::function<void(grpc_error*, MetadataInterface*, CallState*)>
+        recv_trailing_metadata_ready;
   };
 
   /// A subchannel picker is the object used to pick the subchannel to
@@ -229,9 +248,7 @@ class LoadBalancingPolicy : public InternallyRefCounted<LoadBalancingPolicy> {
     SubchannelPicker() = default;
     virtual ~SubchannelPicker() = default;
 
-    virtual PickResult Pick(PickArgs args) GRPC_ABSTRACT;
-
-    GRPC_ABSTRACT_BASE_CLASS
+    virtual PickResult Pick(PickArgs args) = 0;
   };
 
   /// A proxy object implemented by the client channel and used by the
@@ -246,22 +263,19 @@ class LoadBalancingPolicy : public InternallyRefCounted<LoadBalancingPolicy> {
 
     /// Creates a new subchannel with the specified channel args.
     virtual RefCountedPtr<SubchannelInterface> CreateSubchannel(
-        const grpc_channel_args& args) GRPC_ABSTRACT;
+        const grpc_channel_args& args) = 0;
 
     /// Sets the connectivity state and returns a new picker to be used
     /// by the client channel.
     virtual void UpdateState(grpc_connectivity_state state,
-                             UniquePtr<SubchannelPicker>) GRPC_ABSTRACT;
+                             UniquePtr<SubchannelPicker>) = 0;
 
     /// Requests that the resolver re-resolve.
-    virtual void RequestReresolution() GRPC_ABSTRACT;
+    virtual void RequestReresolution() = 0;
 
     /// Adds a trace message associated with the channel.
     enum TraceSeverity { TRACE_INFO, TRACE_WARNING, TRACE_ERROR };
-    virtual void AddTraceEvent(TraceSeverity severity,
-                               StringView message) GRPC_ABSTRACT;
-
-    GRPC_ABSTRACT_BASE_CLASS
+    virtual void AddTraceEvent(TraceSeverity severity, StringView message) = 0;
   };
 
   /// Interface for configuration data used by an LB policy implementation.
@@ -272,9 +286,7 @@ class LoadBalancingPolicy : public InternallyRefCounted<LoadBalancingPolicy> {
     virtual ~Config() = default;
 
     // Returns the load balancing policy name
-    virtual const char* name() const GRPC_ABSTRACT;
-
-    GRPC_ABSTRACT_BASE_CLASS
+    virtual const char* name() const = 0;
   };
 
   /// Data passed to the UpdateLocked() method when new addresses and
@@ -301,7 +313,7 @@ class LoadBalancingPolicy : public InternallyRefCounted<LoadBalancingPolicy> {
     // TODO(roth): Once we have a C++-like interface for combiners, this
     // API should change to take a smart pointer that does pass ownership
     // of a reference.
-    grpc_combiner* combiner = nullptr;
+    Combiner* combiner = nullptr;
     /// Channel control helper.
     /// Note: LB policies MUST NOT call any method on the helper from
     /// their constructor.
@@ -319,12 +331,12 @@ class LoadBalancingPolicy : public InternallyRefCounted<LoadBalancingPolicy> {
   LoadBalancingPolicy& operator=(const LoadBalancingPolicy&) = delete;
 
   /// Returns the name of the LB policy.
-  virtual const char* name() const GRPC_ABSTRACT;
+  virtual const char* name() const = 0;
 
   /// Updates the policy with new data from the resolver.  Will be invoked
   /// immediately after LB policy is constructed, and then again whenever
   /// the resolver returns a new result.
-  virtual void UpdateLocked(UpdateArgs) GRPC_ABSTRACT;  // NOLINT
+  virtual void UpdateLocked(UpdateArgs) = 0;  // NOLINT
 
   /// Tries to enter a READY connectivity state.
   /// This is a no-op by default, since most LB policies never go into
@@ -332,7 +344,7 @@ class LoadBalancingPolicy : public InternallyRefCounted<LoadBalancingPolicy> {
   virtual void ExitIdleLocked() {}
 
   /// Resets connection backoff.
-  virtual void ResetBackoffLocked() GRPC_ABSTRACT;
+  virtual void ResetBackoffLocked() = 0;
 
   grpc_pollset_set* interested_parties() const { return interested_parties_; }
 
@@ -370,10 +382,8 @@ class LoadBalancingPolicy : public InternallyRefCounted<LoadBalancingPolicy> {
     grpc_error* error_;
   };
 
-  GRPC_ABSTRACT_BASE_CLASS
-
  protected:
-  grpc_combiner* combiner() const { return combiner_; }
+  Combiner* combiner() const { return combiner_; }
 
   // Note: LB policies MUST NOT call any method on the helper from their
   // constructor.
@@ -382,11 +392,11 @@ class LoadBalancingPolicy : public InternallyRefCounted<LoadBalancingPolicy> {
   }
 
   /// Shuts down the policy.
-  virtual void ShutdownLocked() GRPC_ABSTRACT;
+  virtual void ShutdownLocked() = 0;
 
  private:
   /// Combiner under which LB policy actions take place.
-  grpc_combiner* combiner_;
+  Combiner* combiner_;
   /// Owned pointer to interested parties in load balancing decisions.
   grpc_pollset_set* interested_parties_;
   /// Channel control helper.