grpc 1.24.0 → 1.25.0

data/src/core/ext/transport/chttp2/transport/hpack_encoder.h

@@ -38,14 +38,10 @@
 
 extern grpc_core::TraceFlag grpc_http_trace;
 
-typedef struct {
-  uint32_t filter_elems_sum;
+struct grpc_chttp2_hpack_compressor {
   uint32_t max_table_size;
   uint32_t max_table_elems;
   uint32_t cap_table_elems;
-  /** if non-zero, advertise to the decoder that we'll start using a table
-      of this size */
-  uint8_t advertise_table_size_change;
   /** maximum number of bytes we'll use for the decode table (to guard against
       peers ooming us by setting decode table size high) */
   uint32_t max_usable_size;
@@ -53,23 +49,39 @@ typedef struct {
   uint32_t tail_remote_index;
   uint32_t table_size;
   uint32_t table_elems;
+  uint16_t* table_elem_size;
+  /** if non-zero, advertise to the decoder that we'll start using a table
+      of this size */
+  uint8_t advertise_table_size_change;
 
   /* filter tables for elems: this tables provides an approximate
      popularity count for particular hashes, and are used to determine whether
      a new literal should be added to the compression table or not.
      They track a single integer that counts how often a particular value has
      been seen. When that count reaches max (255), all values are halved. */
+  uint32_t filter_elems_sum;
   uint8_t filter_elems[GRPC_CHTTP2_HPACKC_NUM_VALUES];
 
   /* entry tables for keys & elems: these tables track values that have been
      seen and *may* be in the decompressor table */
-  grpc_slice entries_keys[GRPC_CHTTP2_HPACKC_NUM_VALUES];
-  grpc_mdelem entries_elems[GRPC_CHTTP2_HPACKC_NUM_VALUES];
-  uint32_t indices_keys[GRPC_CHTTP2_HPACKC_NUM_VALUES];
-  uint32_t indices_elems[GRPC_CHTTP2_HPACKC_NUM_VALUES];
-
-  uint16_t* table_elem_size;
-} grpc_chttp2_hpack_compressor;
+  struct {
+    struct {
+      grpc_mdelem value;
+      uint32_t index;
+    } entries[GRPC_CHTTP2_HPACKC_NUM_VALUES];
+  } elem_table; /* Metadata table management */
+  struct {
+    struct {
+      /* Only store the slice refcount - we do not need the byte buffer or
+         length of the slice since we only need to store a mapping between the
+         identity of the slice and the corresponding HPACK index. Since the
+         slice *must* be static or interned, the refcount is sufficient to
+         establish identity. */
+      grpc_slice_refcount* value;
+      uint32_t index;
+    } entries[GRPC_CHTTP2_HPACKC_NUM_VALUES];
+  } key_table; /* Key table management */
+};
 
 void grpc_chttp2_hpack_compressor_init(grpc_chttp2_hpack_compressor* c);
 void grpc_chttp2_hpack_compressor_destroy(grpc_chttp2_hpack_compressor* c);

data/src/core/ext/transport/chttp2/transport/hpack_parser.cc

@@ -1741,9 +1741,8 @@ grpc_error* grpc_chttp2_header_parser_parse(void* hpack_parser,
              however -- it might be that we receive a RST_STREAM following this
              and can avoid the extra write */
           GRPC_CHTTP2_STREAM_REF(s, "final_rst");
-          GRPC_CLOSURE_SCHED(
-              GRPC_CLOSURE_CREATE(force_client_rst_stream, s,
-                                  grpc_combiner_finally_scheduler(t->combiner)),
+          t->combiner->FinallyRun(
+              GRPC_CLOSURE_CREATE(force_client_rst_stream, s, nullptr),
               GRPC_ERROR_NONE);
         }
         grpc_chttp2_mark_stream_closed(t, s, true, false, GRPC_ERROR_NONE);

data/src/core/ext/transport/chttp2/transport/internal.h

@@ -300,16 +300,12 @@ struct grpc_chttp2_transport {
 
   grpc_resource_user* resource_user;
 
-  grpc_combiner* combiner;
+  grpc_core::Combiner* combiner;
 
   grpc_closure* notify_on_receive_settings = nullptr;
 
   /** write execution state of the transport */
   grpc_chttp2_write_state write_state = GRPC_CHTTP2_WRITE_STATE_IDLE;
-  /** is this the first write in a series of writes?
-      set when we initiate writing from idle, cleared when we
-      initiate writing from writing+more */
-  bool is_first_write_in_batch = false;
 
   /** is the transport destroying itself? */
   uint8_t destroying = false;
@@ -319,8 +315,6 @@ struct grpc_chttp2_transport {
   /** is there a read request to the endpoint outstanding? */
   uint8_t endpoint_reading = 1;
 
-  grpc_chttp2_optimization_target opt_target = GRPC_CHTTP2_OPTIMIZE_FOR_LATENCY;
-
   /** various lists of streams */
   grpc_chttp2_stream_list lists[STREAM_LIST_COUNT] = {};
 
@@ -341,15 +335,13 @@ struct grpc_chttp2_transport {
       publish the accepted server stream */
   grpc_chttp2_stream** accepting_stream = nullptr;
 
-  struct {
-    /* accept stream callback */
-    void (*accept_stream)(void* user_data, grpc_transport* transport,
-                          const void* server_data);
-    void* accept_stream_user_data;
+  /* accept stream callback */
+  void (*accept_stream_cb)(void* user_data, grpc_transport* transport,
+                           const void* server_data);
+  void* accept_stream_cb_user_data;
 
-    /** connectivity tracking */
-    grpc_connectivity_state_tracker state_tracker;
-  } channel_callback;
+  /** connectivity tracking */
+  grpc_core::ConnectivityStateTracker state_tracker;
 
   /** data to write now */
   grpc_slice_buffer outbuf;
@@ -467,6 +459,8 @@ struct grpc_chttp2_transport {
 
   /* next bdp ping timer */
   bool have_next_bdp_ping_timer = false;
+  /** If start_bdp_ping_locked has been called */
+  bool bdp_ping_started = false;
   grpc_timer next_bdp_ping_timer;
 
   /* keep-alive ping support */
@@ -488,6 +482,8 @@ struct grpc_chttp2_transport {
   grpc_millis keepalive_timeout;
   /** if keepalive pings are allowed when there's no outstanding streams */
   bool keepalive_permit_without_calls = false;
+  /** If start_keepalive_ping_locked has been called */
+  bool keepalive_ping_started = false;
   /** keep-alive state machine state */
   grpc_chttp2_keepalive_state keepalive_state;
   grpc_core::ContextList* cl = nullptr;
@@ -870,4 +866,6 @@ void grpc_chttp2_fail_pending_writes(grpc_chttp2_transport* t,
 void grpc_chttp2_config_default_keepalive_args(grpc_channel_args* args,
                                                bool is_client);
 
+void grpc_chttp2_retry_initiate_ping(void* tp, grpc_error* error);
+
 #endif /* GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_INTERNAL_H */

data/src/core/ext/transport/chttp2/transport/writing.cc

@@ -96,6 +96,9 @@ static void maybe_initiate_ping(grpc_chttp2_transport* t) {
     if (!t->ping_state.is_delayed_ping_timer_set) {
       t->ping_state.is_delayed_ping_timer_set = true;
       GRPC_CHTTP2_REF_TRANSPORT(t, "retry_initiate_ping_locked");
+      GRPC_CLOSURE_INIT(&t->retry_initiate_ping_locked,
+                        grpc_chttp2_retry_initiate_ping, t,
+                        grpc_schedule_on_exec_ctx);
       grpc_timer_init(&t->ping_state.delayed_ping_timer, next_allowed_ping,
                       &t->retry_initiate_ping_locked);
     }

data/src/core/ext/transport/inproc/inproc_transport.cc

@@ -75,17 +75,17 @@ struct shared_mu {
 struct inproc_transport {
   inproc_transport(const grpc_transport_vtable* vtable, shared_mu* mu,
                    bool is_client)
-      : mu(mu), is_client(is_client) {
+      : mu(mu),
+        is_client(is_client),
+        state_tracker(is_client ? "inproc_client" : "inproc_server",
+                      GRPC_CHANNEL_READY) {
     base.vtable = vtable;
     // Start each side of transport with 2 refs since they each have a ref
     // to the other
     gpr_ref_init(&refs, 2);
-    grpc_connectivity_state_init(&connectivity, GRPC_CHANNEL_READY,
-                                 is_client ? "inproc_client" : "inproc_server");
   }
 
   ~inproc_transport() {
-    grpc_connectivity_state_destroy(&connectivity);
     if (gpr_unref(&mu->refs)) {
       mu->~shared_mu();
       gpr_free(mu);
@@ -111,7 +111,7 @@ struct inproc_transport {
   shared_mu* mu;
   gpr_refcount refs;
   bool is_client;
-  grpc_connectivity_state_tracker connectivity;
+  grpc_core::ConnectivityStateTracker state_tracker;
   void (*accept_stream_cb)(void* user_data, grpc_transport* transport,
                            const void* server_data);
   void* accept_stream_data;
@@ -1090,8 +1090,7 @@ void perform_stream_op(grpc_transport* gt, grpc_stream* gs,
 
 void close_transport_locked(inproc_transport* t) {
   INPROC_LOG(GPR_INFO, "close_transport %p %d", t, t->is_closed);
-  grpc_connectivity_state_set(&t->connectivity, GRPC_CHANNEL_SHUTDOWN,
-                              "close transport");
+  t->state_tracker.SetState(GRPC_CHANNEL_SHUTDOWN, "close transport");
   if (!t->is_closed) {
     t->is_closed = true;
     /* Also end all streams on this transport */
@@ -1110,10 +1109,12 @@ void perform_transport_op(grpc_transport* gt, grpc_transport_op* op) {
   inproc_transport* t = reinterpret_cast<inproc_transport*>(gt);
   INPROC_LOG(GPR_INFO, "perform_transport_op %p %p", t, op);
   gpr_mu_lock(&t->mu->mu);
-  if (op->on_connectivity_state_change) {
-    grpc_connectivity_state_notify_on_state_change(
-        &t->connectivity, op->connectivity_state,
-        op->on_connectivity_state_change);
+  if (op->start_connectivity_watch != nullptr) {
+    t->state_tracker.AddWatcher(op->start_connectivity_watch_state,
+                                std::move(op->start_connectivity_watch));
+  }
+  if (op->stop_connectivity_watch != nullptr) {
+    t->state_tracker.RemoveWatcher(op->stop_connectivity_watch);
   }
   if (op->set_accept_stream) {
     t->accept_stream_cb = op->set_accept_stream_fn;
@@ -1226,10 +1227,15 @@ grpc_channel* grpc_inproc_channel_create(grpc_server* server,
 
   grpc_core::ExecCtx exec_ctx;
 
-  const grpc_channel_args* server_args = grpc_server_get_channel_args(server);
+  // Remove max_connection_idle and max_connection_age channel arguments since
+  // those do not apply to inproc transports.
+  const char* args_to_remove[] = {GRPC_ARG_MAX_CONNECTION_IDLE_MS,
+                                  GRPC_ARG_MAX_CONNECTION_AGE_MS};
+  const grpc_channel_args* server_args = grpc_channel_args_copy_and_remove(
+      grpc_server_get_channel_args(server), args_to_remove,
+      GPR_ARRAY_SIZE(args_to_remove));
 
   // Add a default authority channel argument for the client
-
   grpc_arg default_authority_arg;
   default_authority_arg.type = GRPC_ARG_STRING;
   default_authority_arg.key = (char*)GRPC_ARG_DEFAULT_AUTHORITY;
@@ -1249,6 +1255,7 @@ grpc_channel* grpc_inproc_channel_create(grpc_server* server,
       "inproc", client_args, GRPC_CLIENT_DIRECT_CHANNEL, client_transport);
 
   // Free up created channel args
+  grpc_channel_args_destroy(server_args);
   grpc_channel_args_destroy(client_args);
 
   // Now finish scheduled operations

data/src/core/lib/channel/channel_args.cc

@@ -22,6 +22,8 @@
 #include <string.h>
 
 #include <grpc/grpc.h>
+#include <grpc/impl/codegen/grpc_types.h>
+#include <grpc/impl/codegen/log.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
@@ -361,3 +363,17 @@ char* grpc_channel_args_string(const grpc_channel_args* args) {
   gpr_strvec_destroy(&v);
   return result;
 }
+
+namespace {
+grpc_channel_args_client_channel_creation_mutator g_mutator = nullptr;
+}  // namespace
+
+void grpc_channel_args_set_client_channel_creation_mutator(
+    grpc_channel_args_client_channel_creation_mutator cb) {
+  GPR_DEBUG_ASSERT(g_mutator == nullptr);
+  g_mutator = cb;
+}
+grpc_channel_args_client_channel_creation_mutator
+grpc_channel_args_get_client_channel_creation_mutator() {
+  return g_mutator;
+}

data/src/core/lib/channel/channel_args.h

@@ -23,6 +23,8 @@
 
 #include <grpc/grpc.h>
 
+#include "src/core/lib/surface/channel_stack_type.h"
+
 // Channel args are intentionally immutable, to avoid the need for locking.
 
 /** Copy the arguments in \a src into a new instance */
@@ -98,6 +100,14 @@ bool grpc_channel_arg_get_bool(const grpc_arg* arg, bool default_value);
 bool grpc_channel_args_find_bool(const grpc_channel_args* args,
                                  const char* name, bool default_value);
 
+template <typename T>
+T* grpc_channel_args_find_pointer(const grpc_channel_args* args,
+                                  const char* name) {
+  const grpc_arg* arg = grpc_channel_args_find(args, name);
+  if (arg == nullptr || arg->type != GRPC_ARG_POINTER) return nullptr;
+  return static_cast<T*>(arg->value.pointer.p);
+}
+
 // Helpers for creating channel args.
 grpc_arg grpc_channel_arg_string_create(char* name, char* value);
 grpc_arg grpc_channel_arg_integer_create(char* name, int value);
@@ -108,4 +118,16 @@ grpc_arg grpc_channel_arg_pointer_create(char* name, void* value,
 // Callers takes ownership of result.
 char* grpc_channel_args_string(const grpc_channel_args* args);
 
+// Takes ownership of the old_args
+typedef grpc_channel_args* (*grpc_channel_args_client_channel_creation_mutator)(
+    const char* target, grpc_channel_args* old_args,
+    grpc_channel_stack_type type);
+
+// Should be called only once globaly before grpc is init'ed.
+void grpc_channel_args_set_client_channel_creation_mutator(
+    grpc_channel_args_client_channel_creation_mutator cb);
+// This will be called at the creation of each channel.
+grpc_channel_args_client_channel_creation_mutator
+grpc_channel_args_get_client_channel_creation_mutator();
+
 #endif /* GRPC_CORE_LIB_CHANNEL_CHANNEL_ARGS_H */

data/src/core/lib/channel/channelz.cc

@@ -234,8 +234,7 @@ grpc_json* ChannelNode::RenderJson() {
         static_cast<grpc_connectivity_state>(state_field >> 1);
     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_create_child(nullptr, json, "state", ConnectivityStateName(state),
                            GRPC_JSON_STRING, false);
     json = data;
   }
@@ -294,7 +293,7 @@ void ChannelNode::SetConnectivityState(grpc_connectivity_state state) {
 
 void ChannelNode::AddChildChannel(intptr_t child_uuid) {
   MutexLock lock(&child_mu_);
-  child_channels_.insert(MakePair(child_uuid, true));
+  child_channels_.insert(std::make_pair(child_uuid, true));
 }
 
 void ChannelNode::RemoveChildChannel(intptr_t child_uuid) {
@@ -304,7 +303,7 @@ void ChannelNode::RemoveChildChannel(intptr_t child_uuid) {
 
 void ChannelNode::AddChildSubchannel(intptr_t child_uuid) {
   MutexLock lock(&child_mu_);
-  child_subchannels_.insert(MakePair(child_uuid, true));
+  child_subchannels_.insert(std::make_pair(child_uuid, true));
 }
 
 void ChannelNode::RemoveChildSubchannel(intptr_t child_uuid) {
@@ -324,7 +323,7 @@ ServerNode::~ServerNode() {}
 
 void ServerNode::AddChildSocket(RefCountedPtr<SocketNode> node) {
   MutexLock lock(&child_mu_);
-  child_sockets_.insert(MakePair(node->uuid(), std::move(node)));
+  child_sockets_.insert(std::make_pair(node->uuid(), std::move(node)));
 }
 
 void ServerNode::RemoveChildSocket(intptr_t child_uuid) {
@@ -334,7 +333,7 @@ void ServerNode::RemoveChildSocket(intptr_t child_uuid) {
 
 void ServerNode::AddChildListenSocket(RefCountedPtr<ListenSocketNode> node) {
   MutexLock lock(&child_mu_);
-  child_listen_sockets_.insert(MakePair(node->uuid(), std::move(node)));
+  child_listen_sockets_.insert(std::make_pair(node->uuid(), std::move(node)));
 }
 
 void ServerNode::RemoveChildListenSocket(intptr_t child_uuid) {

data/src/core/lib/channel/channelz.h

@@ -88,7 +88,7 @@ class BaseNode : public RefCounted<BaseNode> {
   virtual ~BaseNode();
 
   // All children must implement this function.
-  virtual grpc_json* RenderJson() GRPC_ABSTRACT;
+  virtual grpc_json* RenderJson() = 0;
 
   // Renders the json and returns allocated string that must be freed by the
   // caller.

data/src/core/lib/channel/connected_channel.cc

@@ -97,7 +97,7 @@ static callback_state* get_state_for_batch(
 
 /* Intercept a call operation and either push it directly up or translate it
    into transport stream operations */
-static void con_start_transport_stream_op_batch(
+static void connected_channel_start_transport_stream_op_batch(
     grpc_call_element* elem, grpc_transport_stream_op_batch* batch) {
   call_data* calld = static_cast<call_data*>(elem->call_data);
   channel_data* chand = static_cast<channel_data*>(elem->channel_data);
@@ -137,15 +137,15 @@ static void con_start_transport_stream_op_batch(
   GRPC_CALL_COMBINER_STOP(calld->call_combiner, "passed batch to transport");
 }
 
-static void con_start_transport_op(grpc_channel_element* elem,
-                                   grpc_transport_op* op) {
+static void connected_channel_start_transport_op(grpc_channel_element* elem,
+                                                 grpc_transport_op* op) {
   channel_data* chand = static_cast<channel_data*>(elem->channel_data);
   grpc_transport_perform_op(chand->transport, op);
 }
 
 /* Constructor for call_data */
-static grpc_error* init_call_elem(grpc_call_element* elem,
-                                  const grpc_call_element_args* args) {
+static grpc_error* connected_channel_init_call_elem(
+    grpc_call_element* elem, const grpc_call_element_args* args) {
   call_data* calld = static_cast<call_data*>(elem->call_data);
   channel_data* chand = static_cast<channel_data*>(elem->channel_data);
   calld->call_combiner = args->call_combiner;
@@ -166,9 +166,9 @@ static void set_pollset_or_pollset_set(grpc_call_element* elem,
 }
 
 /* Destructor for call_data */
-static void destroy_call_elem(grpc_call_element* elem,
-                              const grpc_call_final_info* final_info,
-                              grpc_closure* then_schedule_closure) {
+static void connected_channel_destroy_call_elem(
+    grpc_call_element* elem, const grpc_call_final_info* final_info,
+    grpc_closure* then_schedule_closure) {
   call_data* calld = static_cast<call_data*>(elem->call_data);
   channel_data* chand = static_cast<channel_data*>(elem->channel_data);
   grpc_transport_destroy_stream(chand->transport,
@@ -177,8 +177,8 @@ static void destroy_call_elem(grpc_call_element* elem,
 }
 
 /* Constructor for channel_data */
-static grpc_error* init_channel_elem(grpc_channel_element* elem,
-                                     grpc_channel_element_args* args) {
+static grpc_error* connected_channel_init_channel_elem(
+    grpc_channel_element* elem, grpc_channel_element_args* args) {
   channel_data* cd = static_cast<channel_data*>(elem->channel_data);
   GPR_ASSERT(args->is_last);
   cd->transport = nullptr;
@@ -186,7 +186,7 @@ static grpc_error* init_channel_elem(grpc_channel_element* elem,
 }
 
 /* Destructor for channel_data */
-static void destroy_channel_elem(grpc_channel_element* elem) {
+static void connected_channel_destroy_channel_elem(grpc_channel_element* elem) {
   channel_data* cd = static_cast<channel_data*>(elem->channel_data);
   if (cd->transport) {
     grpc_transport_destroy(cd->transport);
@@ -194,20 +194,20 @@ static void destroy_channel_elem(grpc_channel_element* elem) {
 }
 
 /* No-op. */
-static void con_get_channel_info(grpc_channel_element* elem,
-                                 const grpc_channel_info* channel_info) {}
+static void connected_channel_get_channel_info(
+    grpc_channel_element* elem, const grpc_channel_info* channel_info) {}
 
 const grpc_channel_filter grpc_connected_filter = {
-    con_start_transport_stream_op_batch,
-    con_start_transport_op,
+    connected_channel_start_transport_stream_op_batch,
+    connected_channel_start_transport_op,
     sizeof(call_data),
-    init_call_elem,
+    connected_channel_init_call_elem,
     set_pollset_or_pollset_set,
-    destroy_call_elem,
+    connected_channel_destroy_call_elem,
     sizeof(channel_data),
-    init_channel_elem,
-    destroy_channel_elem,
-    con_get_channel_info,
+    connected_channel_init_channel_elem,
+    connected_channel_destroy_channel_elem,
+    connected_channel_get_channel_info,
     "connected",
 };