grpc 1.18.0 → 1.19.0.pre1

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

@@ -23,55 +23,50 @@
 
 #include "src/core/ext/filters/client_channel/client_channel_channelz.h"
 #include "src/core/ext/filters/client_channel/connector.h"
+#include "src/core/ext/filters/client_channel/subchannel_pool_interface.h"
+#include "src/core/lib/backoff/backoff.h"
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/gpr/arena.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/iomgr/polling_entity.h"
+#include "src/core/lib/iomgr/timer.h"
 #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.
 #define GRPC_ARG_SUBCHANNEL_ADDRESS "grpc.subchannel_address"
 
-/** A (sub-)channel that knows how to connect to exactly one target
-    address. Provides a target for load balancing. */
-typedef struct grpc_subchannel grpc_subchannel;
-typedef struct grpc_subchannel_call grpc_subchannel_call;
-typedef struct grpc_subchannel_args grpc_subchannel_args;
-typedef struct grpc_subchannel_key grpc_subchannel_key;
-
+// For debugging refcounting.
 #ifndef NDEBUG
-#define GRPC_SUBCHANNEL_REF(p, r) \
-  grpc_subchannel_ref((p), __FILE__, __LINE__, (r))
+#define GRPC_SUBCHANNEL_REF(p, r) (p)->Ref(__FILE__, __LINE__, (r))
 #define GRPC_SUBCHANNEL_REF_FROM_WEAK_REF(p, r) \
-  grpc_subchannel_ref_from_weak_ref((p), __FILE__, __LINE__, (r))
-#define GRPC_SUBCHANNEL_UNREF(p, r) \
-  grpc_subchannel_unref((p), __FILE__, __LINE__, (r))
-#define GRPC_SUBCHANNEL_WEAK_REF(p, r) \
-  grpc_subchannel_weak_ref((p), __FILE__, __LINE__, (r))
-#define GRPC_SUBCHANNEL_WEAK_UNREF(p, r) \
-  grpc_subchannel_weak_unref((p), __FILE__, __LINE__, (r))
-#define GRPC_SUBCHANNEL_CALL_REF(p, r) \
-  grpc_subchannel_call_ref((p), __FILE__, __LINE__, (r))
-#define GRPC_SUBCHANNEL_CALL_UNREF(p, r) \
-  grpc_subchannel_call_unref((p), __FILE__, __LINE__, (r))
+  (p)->RefFromWeakRef(__FILE__, __LINE__, (r))
+#define GRPC_SUBCHANNEL_UNREF(p, r) (p)->Unref(__FILE__, __LINE__, (r))
+#define GRPC_SUBCHANNEL_WEAK_REF(p, r) (p)->WeakRef(__FILE__, __LINE__, (r))
+#define GRPC_SUBCHANNEL_WEAK_UNREF(p, r) (p)->WeakUnref(__FILE__, __LINE__, (r))
 #define GRPC_SUBCHANNEL_REF_EXTRA_ARGS \
-  , const char *file, int line, const char *reason
+  const char *file, int line, const char *reason
+#define GRPC_SUBCHANNEL_REF_REASON reason
+#define GRPC_SUBCHANNEL_REF_MUTATE_EXTRA_ARGS \
+  , GRPC_SUBCHANNEL_REF_EXTRA_ARGS, const char* purpose
+#define GRPC_SUBCHANNEL_REF_MUTATE_PURPOSE(x) , file, line, reason, x
 #else
-#define GRPC_SUBCHANNEL_REF(p, r) grpc_subchannel_ref((p))
-#define GRPC_SUBCHANNEL_REF_FROM_WEAK_REF(p, r) \
-  grpc_subchannel_ref_from_weak_ref((p))
-#define GRPC_SUBCHANNEL_UNREF(p, r) grpc_subchannel_unref((p))
-#define GRPC_SUBCHANNEL_WEAK_REF(p, r) grpc_subchannel_weak_ref((p))
-#define GRPC_SUBCHANNEL_WEAK_UNREF(p, r) grpc_subchannel_weak_unref((p))
-#define GRPC_SUBCHANNEL_CALL_REF(p, r) grpc_subchannel_call_ref((p))
-#define GRPC_SUBCHANNEL_CALL_UNREF(p, r) grpc_subchannel_call_unref((p))
+#define GRPC_SUBCHANNEL_REF(p, r) (p)->Ref()
+#define GRPC_SUBCHANNEL_REF_FROM_WEAK_REF(p, r) (p)->RefFromWeakRef()
+#define GRPC_SUBCHANNEL_UNREF(p, r) (p)->Unref()
+#define GRPC_SUBCHANNEL_WEAK_REF(p, r) (p)->WeakRef()
+#define GRPC_SUBCHANNEL_WEAK_UNREF(p, r) (p)->WeakUnref()
 #define GRPC_SUBCHANNEL_REF_EXTRA_ARGS
+#define GRPC_SUBCHANNEL_REF_REASON ""
+#define GRPC_SUBCHANNEL_REF_MUTATE_EXTRA_ARGS
+#define GRPC_SUBCHANNEL_REF_MUTATE_PURPOSE(x)
 #endif
 
 namespace grpc_core {
 
+class SubchannelCall;
+
 class ConnectedSubchannel : public RefCounted<ConnectedSubchannel> {
  public:
   struct CallArgs {
@@ -87,8 +82,7 @@ class ConnectedSubchannel : public RefCounted<ConnectedSubchannel> {
 
   ConnectedSubchannel(
       grpc_channel_stack* channel_stack, const grpc_channel_args* args,
-      grpc_core::RefCountedPtr<grpc_core::channelz::SubchannelNode>
-          channelz_subchannel,
+      RefCountedPtr<channelz::SubchannelNode> channelz_subchannel,
       intptr_t socket_uuid);
   ~ConnectedSubchannel();
 
@@ -96,7 +90,8 @@ class ConnectedSubchannel : public RefCounted<ConnectedSubchannel> {
                            grpc_connectivity_state* state,
                            grpc_closure* closure);
   void Ping(grpc_closure* on_initiate, grpc_closure* on_ack);
-  grpc_error* CreateCall(const CallArgs& args, grpc_subchannel_call** call);
+  RefCountedPtr<SubchannelCall> CreateCall(const CallArgs& args,
+                                           grpc_error** error);
 
   grpc_channel_stack* channel_stack() const { return channel_stack_; }
   const grpc_channel_args* args() const { return args_; }
@@ -112,107 +107,202 @@ class ConnectedSubchannel : public RefCounted<ConnectedSubchannel> {
   grpc_channel_args* args_;
   // ref counted pointer to the channelz node in this connected subchannel's
   // owning subchannel.
-  grpc_core::RefCountedPtr<grpc_core::channelz::SubchannelNode>
-      channelz_subchannel_;
+  RefCountedPtr<channelz::SubchannelNode> channelz_subchannel_;
   // uuid of this subchannel's socket. 0 if this subchannel is not connected.
   const intptr_t socket_uuid_;
 };
 
-}  // namespace grpc_core
+// Implements the interface of RefCounted<>.
+class SubchannelCall {
+ public:
+  SubchannelCall(RefCountedPtr<ConnectedSubchannel> connected_subchannel,
+                 const ConnectedSubchannel::CallArgs& args)
+      : connected_subchannel_(std::move(connected_subchannel)),
+        deadline_(args.deadline) {}
+
+  // Continues processing a transport stream op batch.
+  void StartTransportStreamOpBatch(grpc_transport_stream_op_batch* batch);
+
+  // Returns a pointer to the parent data associated with the subchannel call.
+  // The data will be of the size specified in \a parent_data_size field of
+  // the args passed to \a ConnectedSubchannel::CreateCall().
+  void* GetParentData();
 
-grpc_subchannel* grpc_subchannel_ref(
-    grpc_subchannel* channel GRPC_SUBCHANNEL_REF_EXTRA_ARGS);
-grpc_subchannel* grpc_subchannel_ref_from_weak_ref(
-    grpc_subchannel* channel GRPC_SUBCHANNEL_REF_EXTRA_ARGS);
-void grpc_subchannel_unref(
-    grpc_subchannel* channel GRPC_SUBCHANNEL_REF_EXTRA_ARGS);
-grpc_subchannel* grpc_subchannel_weak_ref(
-    grpc_subchannel* channel GRPC_SUBCHANNEL_REF_EXTRA_ARGS);
-void grpc_subchannel_weak_unref(
-    grpc_subchannel* channel GRPC_SUBCHANNEL_REF_EXTRA_ARGS);
-grpc_subchannel_call* grpc_subchannel_call_ref(
-    grpc_subchannel_call* call GRPC_SUBCHANNEL_REF_EXTRA_ARGS);
-void grpc_subchannel_call_unref(
-    grpc_subchannel_call* call GRPC_SUBCHANNEL_REF_EXTRA_ARGS);
-
-grpc_core::channelz::SubchannelNode* grpc_subchannel_get_channelz_node(
-    grpc_subchannel* subchannel);
-
-intptr_t grpc_subchannel_get_child_socket_uuid(grpc_subchannel* subchannel);
-
-/** Returns a pointer to the parent data associated with \a subchannel_call.
-    The data will be of the size specified in \a parent_data_size
-    field of the args passed to \a grpc_connected_subchannel_create_call(). */
-void* grpc_connected_subchannel_call_get_parent_data(
-    grpc_subchannel_call* subchannel_call);
-
-/** poll the current connectivity state of a channel */
-grpc_connectivity_state grpc_subchannel_check_connectivity(
-    grpc_subchannel* channel, grpc_error** error, bool inhibit_health_checking);
-
-/** Calls notify when the connectivity state of a channel becomes different
-    from *state.  Updates *state with the new state of the channel. */
-void grpc_subchannel_notify_on_state_change(
-    grpc_subchannel* channel, grpc_pollset_set* interested_parties,
-    grpc_connectivity_state* state, grpc_closure* notify,
-    bool inhibit_health_checks);
-
-/** retrieve the grpc_core::ConnectedSubchannel - or nullptr if not connected
- * (which may happen before it initially connects or during transient failures)
- * */
-grpc_core::RefCountedPtr<grpc_core::ConnectedSubchannel>
-grpc_subchannel_get_connected_subchannel(grpc_subchannel* c);
-
-/** return the subchannel index key for \a subchannel */
-const grpc_subchannel_key* grpc_subchannel_get_key(
-    const grpc_subchannel* subchannel);
-
-// Resets the connection backoff of the subchannel.
-// TODO(roth): Move connection backoff out of subchannels and up into LB
-// policy code (probably by adding a SubchannelGroup between
-// SubchannelList and SubchannelData), at which point this method can
-// go away.
-void grpc_subchannel_reset_backoff(grpc_subchannel* subchannel);
-
-/** continue processing a transport op */
-void grpc_subchannel_call_process_op(grpc_subchannel_call* subchannel_call,
-                                     grpc_transport_stream_op_batch* op);
-
-/** Must be called once per call. Sets the 'then_schedule_closure' argument for
-    call stack destruction. */
-void grpc_subchannel_call_set_cleanup_closure(
-    grpc_subchannel_call* subchannel_call, grpc_closure* closure);
-
-grpc_call_stack* grpc_subchannel_call_get_call_stack(
-    grpc_subchannel_call* subchannel_call);
-
-struct grpc_subchannel_args {
-  /* When updating this struct, also update subchannel_index.c */
-
-  /** Channel filters for this channel - wrapped factories will likely
-      want to mutate this */
-  const grpc_channel_filter** filters;
-  /** The number of filters in the above array */
-  size_t filter_count;
-  /** Channel arguments to be supplied to the newly created channel */
-  const grpc_channel_args* args;
+  // Returns the call stack of the subchannel call.
+  grpc_call_stack* GetCallStack();
+
+  // Sets the 'then_schedule_closure' argument for call stack destruction.
+  // Must be called once per call.
+  void SetAfterCallStackDestroy(grpc_closure* closure);
+
+  // Interface of RefCounted<>.
+  RefCountedPtr<SubchannelCall> Ref() GRPC_MUST_USE_RESULT;
+  RefCountedPtr<SubchannelCall> Ref(const DebugLocation& location,
+                                    const char* reason) GRPC_MUST_USE_RESULT;
+  // When refcount drops to 0, destroys itself and the associated call stack,
+  // but does NOT free the memory because it's in the call arena.
+  void Unref();
+  void Unref(const DebugLocation& location, const char* reason);
+
+  static void Destroy(void* arg, grpc_error* error);
+
+ private:
+  // Allow RefCountedPtr<> to access IncrementRefCount().
+  template <typename T>
+  friend class RefCountedPtr;
+
+  // If channelz is enabled, intercepts recv_trailing so that we may check the
+  // status and associate it to a subchannel.
+  void MaybeInterceptRecvTrailingMetadata(
+      grpc_transport_stream_op_batch* batch);
+
+  static void RecvTrailingMetadataReady(void* arg, grpc_error* error);
+
+  // Interface of RefCounted<>.
+  void IncrementRefCount();
+  void IncrementRefCount(const DebugLocation& location, const char* reason);
+
+  RefCountedPtr<ConnectedSubchannel> connected_subchannel_;
+  grpc_closure* after_call_stack_destroy_ = nullptr;
+  // State needed to support channelz interception of recv trailing metadata.
+  grpc_closure recv_trailing_metadata_ready_;
+  grpc_closure* original_recv_trailing_metadata_ = nullptr;
+  grpc_metadata_batch* recv_trailing_metadata_ = nullptr;
+  grpc_millis deadline_;
 };
 
-/** create a subchannel given a connector */
-grpc_subchannel* grpc_subchannel_create(grpc_connector* connector,
-                                        const grpc_subchannel_args* args);
+// A subchannel that knows how to connect to exactly one target address. It
+// provides a target for load balancing.
+class Subchannel {
+ public:
+  // The ctor and dtor are not intended to use directly.
+  Subchannel(SubchannelKey* key, grpc_connector* connector,
+             const grpc_channel_args* args);
+  ~Subchannel();
+
+  // Creates a subchannel given \a connector and \a args.
+  static Subchannel* Create(grpc_connector* connector,
+                            const grpc_channel_args* args);
 
-/// Sets \a addr from \a args.
-void grpc_get_subchannel_address_arg(const grpc_channel_args* args,
-                                     grpc_resolved_address* addr);
+  // Strong and weak refcounting.
+  Subchannel* Ref(GRPC_SUBCHANNEL_REF_EXTRA_ARGS);
+  void Unref(GRPC_SUBCHANNEL_REF_EXTRA_ARGS);
+  Subchannel* WeakRef(GRPC_SUBCHANNEL_REF_EXTRA_ARGS);
+  void WeakUnref(GRPC_SUBCHANNEL_REF_EXTRA_ARGS);
+  Subchannel* RefFromWeakRef(GRPC_SUBCHANNEL_REF_EXTRA_ARGS);
 
-const char* grpc_subchannel_get_target(grpc_subchannel* subchannel);
+  intptr_t GetChildSocketUuid();
 
-/// Returns the URI string for the address to connect to.
-const char* grpc_get_subchannel_address_uri_arg(const grpc_channel_args* args);
+  // Gets the string representing the subchannel address.
+  // Caller doesn't take ownership.
+  const char* GetTargetAddress();
 
-/// Returns a new channel arg encoding the subchannel address as a string.
-/// Caller is responsible for freeing the string.
-grpc_arg grpc_create_subchannel_address_arg(const grpc_resolved_address* addr);
+  // Gets the connected subchannel - or nullptr if not connected (which may
+  // happen before it initially connects or during transient failures).
+  RefCountedPtr<ConnectedSubchannel> connected_subchannel();
+
+  channelz::SubchannelNode* channelz_node();
+
+  // Polls the current connectivity state of the subchannel.
+  grpc_connectivity_state CheckConnectivity(grpc_error** error,
+                                            bool inhibit_health_checking);
+
+  // When the connectivity state of the subchannel changes from \a *state,
+  // invokes \a notify and updates \a *state with the new state.
+  void NotifyOnStateChange(grpc_pollset_set* interested_parties,
+                           grpc_connectivity_state* state, grpc_closure* notify,
+                           bool inhibit_health_checking);
+
+  // Resets the connection backoff of the subchannel.
+  // TODO(roth): Move connection backoff out of subchannels and up into LB
+  // policy code (probably by adding a SubchannelGroup between
+  // SubchannelList and SubchannelData), at which point this method can
+  // go away.
+  void ResetBackoff();
+
+  // Returns a new channel arg encoding the subchannel address as a URI
+  // string. Caller is responsible for freeing the string.
+  static grpc_arg CreateSubchannelAddressArg(const grpc_resolved_address* addr);
+
+  // Returns the URI string from the subchannel address arg in \a args.
+  static const char* GetUriFromSubchannelAddressArg(
+      const grpc_channel_args* args);
+
+  // Sets \a addr from the subchannel address arg in \a args.
+  static void GetAddressFromSubchannelAddressArg(const grpc_channel_args* args,
+                                                 grpc_resolved_address* addr);
+
+ private:
+  struct ExternalStateWatcher;
+  class ConnectedSubchannelStateWatcher;
+
+  // Sets the subchannel's connectivity state to \a state.
+  void SetConnectivityStateLocked(grpc_connectivity_state state,
+                                  grpc_error* error, const char* reason);
+
+  // Methods for connection.
+  void MaybeStartConnectingLocked();
+  static void OnRetryAlarm(void* arg, grpc_error* error);
+  void ContinueConnectingLocked();
+  static void OnConnectingFinished(void* arg, grpc_error* error);
+  bool PublishTransportLocked();
+  void Disconnect();
+
+  gpr_atm RefMutate(gpr_atm delta,
+                    int barrier GRPC_SUBCHANNEL_REF_MUTATE_EXTRA_ARGS);
+
+  // The subchannel pool this subchannel is in.
+  RefCountedPtr<SubchannelPoolInterface> subchannel_pool_;
+  // TODO(juanlishen): Consider using args_ as key_ directly.
+  // Subchannel key that identifies this subchannel in the subchannel pool.
+  SubchannelKey* key_;
+  // Channel args.
+  grpc_channel_args* args_;
+  // pollset_set tracking who's interested in a connection being setup.
+  grpc_pollset_set* pollset_set_;
+  // Protects the other members.
+  gpr_mu mu_;
+  // Refcount
+  //    - lower INTERNAL_REF_BITS bits are for internal references:
+  //      these do not keep the subchannel open.
+  //    - upper remaining bits are for public references: these do
+  //      keep the subchannel open
+  gpr_atm ref_pair_;
+
+  // Connection states.
+  grpc_connector* connector_ = nullptr;
+  // Set during connection.
+  grpc_connect_out_args connecting_result_;
+  grpc_closure on_connecting_finished_;
+  // Active connection, or null.
+  RefCountedPtr<ConnectedSubchannel> connected_subchannel_;
+  OrphanablePtr<ConnectedSubchannelStateWatcher> connected_subchannel_watcher_;
+  bool connecting_ = false;
+  bool disconnected_ = false;
+
+  // Connectivity state tracking.
+  grpc_connectivity_state_tracker state_tracker_;
+  grpc_connectivity_state_tracker state_and_health_tracker_;
+  UniquePtr<char> health_check_service_name_;
+  ExternalStateWatcher* external_state_watcher_list_ = nullptr;
+
+  // Backoff state.
+  BackOff backoff_;
+  grpc_millis next_attempt_deadline_;
+  grpc_millis min_connect_timeout_ms_;
+  bool backoff_begun_ = false;
+
+  // Retry alarm.
+  grpc_timer retry_alarm_;
+  grpc_closure on_retry_alarm_;
+  bool have_retry_alarm_ = false;
+  // reset_backoff() was called while alarm was pending.
+  bool retry_immediately_ = false;
+
+  // Channelz tracking.
+  RefCountedPtr<channelz::SubchannelNode> channelz_node_;
+};
+
+}  // namespace grpc_core
 
 #endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_SUBCHANNEL_H */

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

@@ -0,0 +1,97 @@
+//
+//
+// Copyright 2018 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/ext/filters/client_channel/subchannel_pool_interface.h"
+
+#include "src/core/lib/gpr/useful.h"
+
+// The subchannel pool to reuse subchannels.
+#define GRPC_ARG_SUBCHANNEL_POOL "grpc.subchannel_pool"
+// The subchannel key ID that is only used in test to make each key unique.
+#define GRPC_ARG_SUBCHANNEL_KEY_TEST_ONLY_ID "grpc.subchannel_key_test_only_id"
+
+namespace grpc_core {
+
+TraceFlag grpc_subchannel_pool_trace(false, "subchannel_pool");
+
+SubchannelKey::SubchannelKey(const grpc_channel_args* args) {
+  Init(args, grpc_channel_args_normalize);
+}
+
+SubchannelKey::~SubchannelKey() {
+  grpc_channel_args_destroy(const_cast<grpc_channel_args*>(args_));
+}
+
+SubchannelKey::SubchannelKey(const SubchannelKey& other) {
+  Init(other.args_, grpc_channel_args_copy);
+}
+
+SubchannelKey& SubchannelKey::operator=(const SubchannelKey& other) {
+  grpc_channel_args_destroy(const_cast<grpc_channel_args*>(args_));
+  Init(other.args_, grpc_channel_args_copy);
+  return *this;
+}
+
+int SubchannelKey::Cmp(const SubchannelKey& other) const {
+  return grpc_channel_args_compare(args_, other.args_);
+}
+
+void SubchannelKey::Init(
+    const grpc_channel_args* args,
+    grpc_channel_args* (*copy_channel_args)(const grpc_channel_args* args)) {
+  args_ = copy_channel_args(args);
+}
+
+namespace {
+
+void* arg_copy(void* p) {
+  auto* subchannel_pool = static_cast<SubchannelPoolInterface*>(p);
+  subchannel_pool->Ref().release();
+  return p;
+}
+
+void arg_destroy(void* p) {
+  auto* subchannel_pool = static_cast<SubchannelPoolInterface*>(p);
+  subchannel_pool->Unref();
+}
+
+int arg_cmp(void* a, void* b) { return GPR_ICMP(a, b); }
+
+const grpc_arg_pointer_vtable subchannel_pool_arg_vtable = {
+    arg_copy, arg_destroy, arg_cmp};
+
+}  // namespace
+
+grpc_arg SubchannelPoolInterface::CreateChannelArg(
+    SubchannelPoolInterface* subchannel_pool) {
+  return grpc_channel_arg_pointer_create(
+      const_cast<char*>(GRPC_ARG_SUBCHANNEL_POOL), subchannel_pool,
+      &subchannel_pool_arg_vtable);
+}
+
+SubchannelPoolInterface*
+SubchannelPoolInterface::GetSubchannelPoolFromChannelArgs(
+    const grpc_channel_args* args) {
+  const grpc_arg* arg = grpc_channel_args_find(args, GRPC_ARG_SUBCHANNEL_POOL);
+  if (arg == nullptr || arg->type != GRPC_ARG_POINTER) return nullptr;
+  return static_cast<SubchannelPoolInterface*>(arg->value.pointer.p);
+}
+
+}  // namespace grpc_core