grpc 1.21.0 → 1.22.0

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

@@ -23,10 +23,12 @@
 
 #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_interface.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/gprpp/arena.h"
+#include "src/core/lib/gprpp/map.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/sync.h"
@@ -68,7 +70,7 @@ namespace grpc_core {
 
 class SubchannelCall;
 
-class ConnectedSubchannel : public RefCounted<ConnectedSubchannel> {
+class ConnectedSubchannel : public ConnectedSubchannelInterface {
  public:
   struct CallArgs {
     grpc_polling_entity* pollent;
@@ -77,7 +79,7 @@ class ConnectedSubchannel : public RefCounted<ConnectedSubchannel> {
     grpc_millis deadline;
     Arena* arena;
     grpc_call_context_element* context;
-    grpc_core::CallCombiner* call_combiner;
+    CallCombiner* call_combiner;
     size_t parent_data_size;
   };
 
@@ -95,7 +97,7 @@ class ConnectedSubchannel : public RefCounted<ConnectedSubchannel> {
                                            grpc_error** error);
 
   grpc_channel_stack* channel_stack() const { return channel_stack_; }
-  const grpc_channel_args* args() const { return args_; }
+  const grpc_channel_args* args() const override { return args_; }
   channelz::SubchannelNode* channelz_subchannel() const {
     return channelz_subchannel_.get();
   }
@@ -176,6 +178,9 @@ class SubchannelCall {
 // provides a target for load balancing.
 class Subchannel {
  public:
+  typedef SubchannelInterface::ConnectivityStateWatcher
+      ConnectivityStateWatcher;
+
   // The ctor and dtor are not intended to use directly.
   Subchannel(SubchannelKey* key, grpc_connector* connector,
              const grpc_channel_args* args);
@@ -201,20 +206,36 @@ class Subchannel {
   // Caller doesn't take ownership.
   const char* GetTargetAddress();
 
-  // 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(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);
+  // Returns the current connectivity state of the subchannel.
+  // If health_check_service_name is non-null, the returned connectivity
+  // state will be based on the state reported by the backend for that
+  // service name.
+  // If the return value is GRPC_CHANNEL_READY, also sets *connected_subchannel.
+  grpc_connectivity_state CheckConnectivityState(
+      const char* health_check_service_name,
+      RefCountedPtr<ConnectedSubchannel>* connected_subchannel);
+
+  // Starts watching the subchannel's connectivity state.
+  // The first callback to the watcher will be delivered when the
+  // subchannel's connectivity state becomes a value other than
+  // initial_state, which may happen immediately.
+  // Subsequent callbacks will be delivered as the subchannel's state
+  // changes.
+  // The watcher will be destroyed either when the subchannel is
+  // destroyed or when CancelConnectivityStateWatch() is called.
+  void WatchConnectivityState(grpc_connectivity_state initial_state,
+                              UniquePtr<char> health_check_service_name,
+                              UniquePtr<ConnectivityStateWatcher> watcher);
+
+  // Cancels a connectivity state watch.
+  // If the watcher has already been destroyed, this is a no-op.
+  void CancelConnectivityStateWatch(const char* health_check_service_name,
+                                    ConnectivityStateWatcher* watcher);
+
+  // Attempt to connect to the backend.  Has no effect if already connected.
+  void AttemptToConnect();
 
   // Resets the connection backoff of the subchannel.
   // TODO(roth): Move connection backoff out of subchannels and up into LB
@@ -236,12 +257,65 @@ class Subchannel {
                                                  grpc_resolved_address* addr);
 
  private:
-  struct ExternalStateWatcher;
+  // A linked list of ConnectivityStateWatchers that are monitoring the
+  // subchannel's state.
+  class ConnectivityStateWatcherList {
+   public:
+    ~ConnectivityStateWatcherList() { Clear(); }
+
+    void AddWatcherLocked(UniquePtr<ConnectivityStateWatcher> watcher);
+    void RemoveWatcherLocked(ConnectivityStateWatcher* watcher);
+
+    // Notifies all watchers in the list about a change to state.
+    void NotifyLocked(Subchannel* subchannel, grpc_connectivity_state state);
+
+    void Clear() { watchers_.clear(); }
+
+    bool empty() const { return watchers_.empty(); }
+
+   private:
+    // TODO(roth): This could be a set instead of a map if we had a set
+    // implementation.
+    Map<ConnectivityStateWatcher*, UniquePtr<ConnectivityStateWatcher>>
+        watchers_;
+  };
+
+  // A map that tracks ConnectivityStateWatchers using a particular health
+  // check service name.
+  //
+  // There is one entry in the map for each health check service name.
+  // Entries exist only as long as there are watchers using the
+  // corresponding service name.
+  //
+  // A health check client is maintained only while the subchannel is in
+  // state READY.
+  class HealthWatcherMap {
+   public:
+    void AddWatcherLocked(Subchannel* subchannel,
+                          grpc_connectivity_state initial_state,
+                          UniquePtr<char> health_check_service_name,
+                          UniquePtr<ConnectivityStateWatcher> watcher);
+    void RemoveWatcherLocked(const char* health_check_service_name,
+                             ConnectivityStateWatcher* watcher);
+
+    // Notifies the watcher when the subchannel's state changes.
+    void NotifyLocked(grpc_connectivity_state state);
+
+    grpc_connectivity_state CheckConnectivityStateLocked(
+        Subchannel* subchannel, const char* health_check_service_name);
+
+    void ShutdownLocked();
+
+   private:
+    class HealthWatcher;
+
+    Map<const char*, OrphanablePtr<HealthWatcher>, StringLess> map_;
+  };
+
   class ConnectedSubchannelStateWatcher;
 
   // Sets the subchannel's connectivity state to \a state.
-  void SetConnectivityStateLocked(grpc_connectivity_state state,
-                                  const char* reason);
+  void SetConnectivityStateLocked(grpc_connectivity_state state);
 
   // Methods for connection.
   void MaybeStartConnectingLocked();
@@ -279,15 +353,15 @@ class Subchannel {
   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;
+  grpc_connectivity_state state_ = GRPC_CHANNEL_IDLE;
+  // The list of watchers without a health check service name.
+  ConnectivityStateWatcherList watcher_list_;
+  // The map of watchers with health check service names.
+  HealthWatcherMap health_watcher_map_;
 
   // Backoff state.
   BackOff backoff_;

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

@@ -0,0 +1,113 @@
+/*
+ *
+ * Copyright 2019 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.
+ *
+ */
+
+#ifndef GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_SUBCHANNEL_INTERFACE_H
+#define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_SUBCHANNEL_INTERFACE_H
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/debug/trace.h"
+#include "src/core/lib/gprpp/ref_counted.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
+
+namespace grpc_core {
+
+// TODO(roth): In a subsequent PR, remove this from this API.
+class ConnectedSubchannelInterface
+    : public RefCounted<ConnectedSubchannelInterface> {
+ public:
+  virtual const grpc_channel_args* args() const GRPC_ABSTRACT;
+
+ protected:
+  template <typename TraceFlagT = TraceFlag>
+  explicit ConnectedSubchannelInterface(TraceFlagT* trace_flag = nullptr)
+      : RefCounted<ConnectedSubchannelInterface>(trace_flag) {}
+};
+
+class SubchannelInterface : public RefCounted<SubchannelInterface> {
+ public:
+  class ConnectivityStateWatcher {
+   public:
+    virtual ~ConnectivityStateWatcher() = default;
+
+    // Will be invoked whenever the subchannel's connectivity state
+    // changes.  There will be only one invocation of this method on a
+    // given watcher instance at any given time.
+    //
+    // When the state changes to READY, connected_subchannel will
+    // contain a ref to the connected subchannel.  When it changes from
+    // READY to some other state, the implementation must release its
+    // ref to the connected subchannel.
+    virtual void OnConnectivityStateChange(
+        grpc_connectivity_state new_state,
+        RefCountedPtr<ConnectedSubchannelInterface>
+            connected_subchannel)  // NOLINT
+        GRPC_ABSTRACT;
+
+    // TODO(roth): Remove this as soon as we move to EventManager-based
+    // polling.
+    virtual grpc_pollset_set* interested_parties() GRPC_ABSTRACT;
+
+    GRPC_ABSTRACT_BASE_CLASS
+  };
+
+  virtual ~SubchannelInterface() = default;
+
+  // Returns the current connectivity state of the subchannel.
+  virtual grpc_connectivity_state CheckConnectivityState(
+      RefCountedPtr<ConnectedSubchannelInterface>* connected_subchannel)
+      GRPC_ABSTRACT;
+
+  // Starts watching the subchannel's connectivity state.
+  // The first callback to the watcher will be delivered when the
+  // subchannel's connectivity state becomes a value other than
+  // initial_state, which may happen immediately.
+  // Subsequent callbacks will be delivered as the subchannel's state
+  // changes.
+  // The watcher will be destroyed either when the subchannel is
+  // destroyed or when CancelConnectivityStateWatch() is called.
+  // There can be only one watcher of a given subchannel.  It is not
+  // valid to call this method a second time without first cancelling
+  // the previous watcher using CancelConnectivityStateWatch().
+  virtual void WatchConnectivityState(
+      grpc_connectivity_state initial_state,
+      UniquePtr<ConnectivityStateWatcher> watcher) GRPC_ABSTRACT;
+
+  // Cancels a connectivity state watch.
+  // If the watcher has already been destroyed, this is a no-op.
+  virtual void CancelConnectivityStateWatch(ConnectivityStateWatcher* watcher)
+      GRPC_ABSTRACT;
+
+  // Attempt to connect to the backend.  Has no effect if already connected.
+  // If the subchannel is currently in backoff delay due to a previously
+  // failed attempt, the new connection attempt will not start until the
+  // backoff delay has elapsed.
+  virtual void AttemptToConnect() GRPC_ABSTRACT;
+
+  // Resets the subchannel's connection backoff state.  If AttemptToConnect()
+  // has been called since the subchannel entered TRANSIENT_FAILURE state,
+  // starts a new connection attempt immediately; otherwise, a new connection
+  // attempt will be started as soon as AttemptToConnect() is called.
+  virtual void ResetBackoff() GRPC_ABSTRACT;
+
+  GRPC_ABSTRACT_BASE_CLASS
+};
+
+}  // namespace grpc_core
+
+#endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_SUBCHANNEL_INTERFACE_H */

data/src/core/ext/filters/message_size/message_size_filter.cc

@@ -88,7 +88,7 @@ UniquePtr<ServiceConfig::ParsedConfig> MessageSizeParser::ParsePerMethodParams(
     *error = GRPC_ERROR_CREATE_FROM_VECTOR("Message size parser", &error_list);
     return nullptr;
   }
-  return UniquePtr<ServiceConfig::ParsedConfig>(New<MessageSizeParsedObject>(
+  return UniquePtr<ServiceConfig::ParsedConfig>(New<MessageSizeParsedConfig>(
       max_request_message_bytes, max_response_message_bytes));
 }
 
@@ -102,7 +102,7 @@ size_t MessageSizeParser::ParserIndex() { return g_message_size_parser_index; }
 
 namespace {
 struct channel_data {
-  grpc_core::MessageSizeParsedObject::message_size_limits limits;
+  grpc_core::MessageSizeParsedConfig::message_size_limits limits;
   grpc_core::RefCountedPtr<grpc_core::ServiceConfig> svc_cfg;
 };
 
@@ -119,21 +119,21 @@ struct call_data {
     // Note: Per-method config is only available on the client, so we
     // apply the max request size to the send limit and the max response
     // size to the receive limit.
-    const grpc_core::MessageSizeParsedObject* limits = nullptr;
+    const grpc_core::MessageSizeParsedConfig* limits = nullptr;
     grpc_core::ServiceConfig::CallData* svc_cfg_call_data = nullptr;
     if (args.context != nullptr) {
       svc_cfg_call_data = static_cast<grpc_core::ServiceConfig::CallData*>(
-          args.context[GRPC_SERVICE_CONFIG_CALL_DATA].value);
+          args.context[GRPC_CONTEXT_SERVICE_CONFIG_CALL_DATA].value);
     }
     if (svc_cfg_call_data != nullptr) {
-      limits = static_cast<const grpc_core::MessageSizeParsedObject*>(
-          svc_cfg_call_data->GetMethodParsedObject(
+      limits = static_cast<const grpc_core::MessageSizeParsedConfig*>(
+          svc_cfg_call_data->GetMethodParsedConfig(
               grpc_core::MessageSizeParser::ParserIndex()));
     } else if (chand.svc_cfg != nullptr) {
       const auto* objs_vector =
-          chand.svc_cfg->GetMethodServiceConfigObjectsVector(args.path);
+          chand.svc_cfg->GetMethodParsedConfigVector(args.path);
       if (objs_vector != nullptr) {
-        limits = static_cast<const grpc_core::MessageSizeParsedObject*>(
+        limits = static_cast<const grpc_core::MessageSizeParsedConfig*>(
             (*objs_vector)[grpc_core::MessageSizeParser::ParserIndex()].get());
       }
     }
@@ -154,7 +154,7 @@ struct call_data {
   ~call_data() { GRPC_ERROR_UNREF(error); }
 
   grpc_core::CallCombiner* call_combiner;
-  grpc_core::MessageSizeParsedObject::message_size_limits limits;
+  grpc_core::MessageSizeParsedConfig::message_size_limits limits;
   // Receive closures are chained: we inject this closure as the
   // recv_message_ready up-call on transport_stream_op, and remember to
   // call our next_recv_message_ready member after handling it.
@@ -300,9 +300,9 @@ static int default_size(const grpc_channel_args* args,
   return without_minimal_stack;
 }
 
-grpc_core::MessageSizeParsedObject::message_size_limits get_message_size_limits(
+grpc_core::MessageSizeParsedConfig::message_size_limits get_message_size_limits(
     const grpc_channel_args* channel_args) {
-  grpc_core::MessageSizeParsedObject::message_size_limits lim;
+  grpc_core::MessageSizeParsedConfig::message_size_limits lim;
   lim.max_send_size =
       default_size(channel_args, GRPC_DEFAULT_MAX_SEND_MESSAGE_LENGTH);
   lim.max_recv_size =
@@ -392,7 +392,7 @@ static bool maybe_add_message_size_filter(grpc_channel_stack_builder* builder,
   const grpc_channel_args* channel_args =
       grpc_channel_stack_builder_get_channel_arguments(builder);
   bool enable = false;
-  grpc_core::MessageSizeParsedObject::message_size_limits lim =
+  grpc_core::MessageSizeParsedConfig::message_size_limits lim =
       get_message_size_limits(channel_args);
   if (lim.max_send_size != -1 || lim.max_recv_size != -1) {
     enable = true;

data/src/core/ext/filters/message_size/message_size_filter.h

@@ -26,14 +26,14 @@ extern const grpc_channel_filter grpc_message_size_filter;
 
 namespace grpc_core {
 
-class MessageSizeParsedObject : public ServiceConfig::ParsedConfig {
+class MessageSizeParsedConfig : public ServiceConfig::ParsedConfig {
  public:
   struct message_size_limits {
     int max_send_size;
     int max_recv_size;
   };
 
-  MessageSizeParsedObject(int max_send_size, int max_recv_size) {
+  MessageSizeParsedConfig(int max_send_size, int max_recv_size) {
     limits_.max_send_size = max_send_size;
     limits_.max_recv_size = max_recv_size;
   }

data/src/core/ext/transport/chttp2/server/chttp2_server.cc

@@ -20,12 +20,12 @@
 
 #include "src/core/ext/transport/chttp2/server/chttp2_server.h"
 
-#include <grpc/grpc.h>
-
 #include <inttypes.h>
 #include <limits.h>
 #include <string.h>
 
+#include <grpc/grpc.h>
+#include <grpc/impl/codegen/grpc_types.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
@@ -289,6 +289,50 @@ static void server_destroy_listener(grpc_server* server, void* arg,
   grpc_tcp_server_unref(tcp_server);
 }
 
+static grpc_error* chttp2_server_add_acceptor(grpc_server* server,
+                                              const char* name,
+                                              grpc_channel_args* args) {
+  grpc_tcp_server* tcp_server = nullptr;
+  grpc_error* err = GRPC_ERROR_NONE;
+  server_state* state = nullptr;
+  const grpc_arg* arg = nullptr;
+  grpc_core::TcpServerFdHandler** arg_val = nullptr;
+  state = static_cast<server_state*>(gpr_zalloc(sizeof(*state)));
+  GRPC_CLOSURE_INIT(&state->tcp_server_shutdown_complete,
+                    tcp_server_shutdown_complete, state,
+                    grpc_schedule_on_exec_ctx);
+  err = grpc_tcp_server_create(&state->tcp_server_shutdown_complete, args,
+                               &tcp_server);
+  if (err != GRPC_ERROR_NONE) {
+    goto error;
+  }
+  state->server = server;
+  state->tcp_server = tcp_server;
+  state->args = args;
+  state->shutdown = true;
+  gpr_mu_init(&state->mu);
+  // TODO(yangg) channelz
+  arg = grpc_channel_args_find(args, name);
+  GPR_ASSERT(arg->type == GRPC_ARG_POINTER);
+  arg_val = static_cast<grpc_core::TcpServerFdHandler**>(arg->value.pointer.p);
+  *arg_val = grpc_tcp_server_create_fd_handler(tcp_server);
+
+  grpc_server_add_listener(server, state, server_start_listener,
+                           server_destroy_listener, /* socket_uuid */ 0);
+  return err;
+
+/* Error path: cleanup and return */
+error:
+  GPR_ASSERT(err != GRPC_ERROR_NONE);
+  if (tcp_server) {
+    grpc_tcp_server_unref(tcp_server);
+  } else {
+    grpc_channel_args_destroy(args);
+    gpr_free(state);
+  }
+  return err;
+}
+
 grpc_error* grpc_chttp2_server_add_port(grpc_server* server, const char* addr,
                                         grpc_channel_args* args,
                                         int* port_num) {
@@ -306,6 +350,10 @@ grpc_error* grpc_chttp2_server_add_port(grpc_server* server, const char* addr,
 
   *port_num = -1;
 
+  if (strncmp(addr, "external:", 9) == 0) {
+    return chttp2_server_add_acceptor(server, addr, args);
+  }
+
   /* resolve address */
   err = grpc_blocking_resolve_address(addr, "https", &resolved);
   if (err != GRPC_ERROR_NONE) {