grpc 1.30.2 → 1.31.0.pre1

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

@@ -25,9 +25,13 @@
 
 #include "src/core/lib/iomgr/error.h"
 
+namespace grpc_core {
+
 /// Adds a port to \a server.  Sets \a port_num to the port number.
 /// Takes ownership of \a args.
-grpc_error* grpc_chttp2_server_add_port(grpc_server* server, const char* addr,
-                                        grpc_channel_args* args, int* port_num);
+grpc_error* Chttp2ServerAddPort(grpc_server* server, const char* addr,
+                                grpc_channel_args* args, int* port_num);
+
+}  // namespace grpc_core
 
 #endif /* GRPC_CORE_EXT_TRANSPORT_CHTTP2_SERVER_CHTTP2_SERVER_H */

data/src/core/ext/transport/chttp2/server/insecure/server_chttp2.cc

@@ -32,7 +32,7 @@ int grpc_server_add_insecure_http2_port(grpc_server* server, const char* addr) {
   int port_num = 0;
   GRPC_API_TRACE("grpc_server_add_insecure_http2_port(server=%p, addr=%s)", 2,
                  (server, addr));
-  grpc_error* err = grpc_chttp2_server_add_port(
+  grpc_error* err = grpc_core::Chttp2ServerAddPort(
       server, addr,
       grpc_channel_args_copy(grpc_server_get_channel_args(server)), &port_num);
   if (err != GRPC_ERROR_NONE) {

data/src/core/ext/transport/chttp2/server/insecure/server_chttp2_posix.cc

@@ -24,8 +24,9 @@
 
 #ifdef GPR_SUPPORT_CHANNELS_FROM_FD
 
+#include "absl/strings/str_cat.h"
+
 #include <grpc/support/alloc.h>
-#include <grpc/support/string_util.h>
 
 #include "src/core/ext/transport/chttp2/transport/chttp2_transport.h"
 #include "src/core/lib/channel/channel_args.h"
@@ -40,25 +41,18 @@ void grpc_server_add_insecure_channel_from_fd(grpc_server* server,
   GPR_ASSERT(reserved == nullptr);
 
   grpc_core::ExecCtx exec_ctx;
-  char* name;
-  gpr_asprintf(&name, "fd:%d", fd);
 
+  std::string name = absl::StrCat("fd:", fd);
   grpc_endpoint* server_endpoint =
-      grpc_tcp_create(grpc_fd_create(fd, name, true),
-                      grpc_server_get_channel_args(server), name);
-
-  gpr_free(name);
+      grpc_tcp_create(grpc_fd_create(fd, name.c_str(), true),
+                      grpc_server_get_channel_args(server), name.c_str());
 
   const grpc_channel_args* server_args = grpc_server_get_channel_args(server);
   grpc_transport* transport = grpc_create_chttp2_transport(
       server_args, server_endpoint, false /* is_client */);
 
-  grpc_pollset** pollsets;
-  size_t num_pollsets = 0;
-  grpc_server_get_pollsets(server, &pollsets, &num_pollsets);
-
-  for (size_t i = 0; i < num_pollsets; i++) {
-    grpc_endpoint_add_to_pollset(server_endpoint, pollsets[i]);
+  for (grpc_pollset* pollset : grpc_server_get_pollsets(server)) {
+    grpc_endpoint_add_to_pollset(server_endpoint, pollset);
   }
 
   grpc_server_setup_transport(server, transport, nullptr, server_args, nullptr);

data/src/core/ext/transport/chttp2/server/secure/server_secure_chttp2.cc

@@ -22,9 +22,10 @@
 
 #include <string.h>
 
+#include "absl/strings/str_cat.h"
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
-#include <grpc/support/string_util.h>
 
 #include "src/core/ext/transport/chttp2/server/chttp2_server.h"
 
@@ -56,12 +57,10 @@ int grpc_server_add_secure_http2_port(grpc_server* server, const char* addr,
   }
   sc = creds->create_security_connector();
   if (sc == nullptr) {
-    char* msg;
-    gpr_asprintf(&msg,
-                 "Unable to create secure server with credentials of type %s.",
-                 creds->type());
-    err = GRPC_ERROR_CREATE_FROM_COPIED_STRING(msg);
-    gpr_free(msg);
+    err = GRPC_ERROR_CREATE_FROM_COPIED_STRING(
+        absl::StrCat("Unable to create secure server with credentials of type ",
+                     creds->type())
+            .c_str());
     goto done;
   }
   // Create channel args.
@@ -72,7 +71,7 @@ int grpc_server_add_secure_http2_port(grpc_server* server, const char* addr,
       grpc_channel_args_copy_and_add(grpc_server_get_channel_args(server),
                                      args_to_add, GPR_ARRAY_SIZE(args_to_add));
   // Add server port.
-  err = grpc_chttp2_server_add_port(server, addr, args, &port_num);
+  err = grpc_core::Chttp2ServerAddPort(server, addr, args, &port_num);
 done:
   sc.reset(DEBUG_LOCATION, "server");
 

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

@@ -1105,7 +1105,6 @@ void grpc_chttp2_add_incoming_goaway(grpc_chttp2_transport* t,
             : static_cast<grpc_millis>(current_keepalive_time_ms *
                                        KEEPALIVE_TIME_BACKOFF_MULTIPLIER);
   }
-
   /* lie: use transient failure from the transport to indicate goaway has been
    * received */
   connectivity_state_set(t, GRPC_CHANNEL_TRANSIENT_FAILURE, "got_goaway");
@@ -1526,6 +1525,7 @@ static void perform_stream_op_locked(void* stream_op,
     s->send_trailing_metadata_finished = add_closure_barrier(on_complete);
     s->send_trailing_metadata =
         op_payload->send_trailing_metadata.send_trailing_metadata;
+    s->sent_trailing_metadata_op = op_payload->send_trailing_metadata.sent;
     s->write_buffering = false;
     const size_t metadata_size =
         grpc_metadata_batch_size(s->send_trailing_metadata);
@@ -1551,6 +1551,7 @@ static void perform_stream_op_locked(void* stream_op,
       }
       if (s->write_closed) {
         s->send_trailing_metadata = nullptr;
+        s->sent_trailing_metadata_op = nullptr;
         grpc_chttp2_complete_closure_step(
             t, s, &s->send_trailing_metadata_finished,
             grpc_metadata_batch_is_empty(
@@ -1794,6 +1795,15 @@ void grpc_chttp2_add_ping_strike(grpc_chttp2_transport* t) {
   }
 }
 
+void grpc_chttp2_reset_ping_clock(grpc_chttp2_transport* t) {
+  if (!t->is_client) {
+    t->ping_recv_state.last_ping_recv_time = GRPC_MILLIS_INF_PAST;
+    t->ping_recv_state.ping_strikes = 0;
+  }
+  t->ping_state.pings_before_data_required =
+      t->ping_policy.max_pings_without_data;
+}
+
 static void perform_transport_op_locked(void* stream_op,
                                         grpc_error* /*error_ignored*/) {
   grpc_transport_op* op = static_cast<grpc_transport_op*>(stream_op);
@@ -2177,6 +2187,7 @@ void grpc_chttp2_fail_pending_writes(grpc_chttp2_transport* t,
                                     "send_initial_metadata_finished");
 
   s->send_trailing_metadata = nullptr;
+  s->sent_trailing_metadata_op = nullptr;
   grpc_chttp2_complete_closure_step(t, s, &s->send_trailing_metadata_finished,
                                     GRPC_ERROR_REF(error),
                                     "send_trailing_metadata_finished");
@@ -2193,9 +2204,12 @@ void grpc_chttp2_mark_stream_closed(grpc_chttp2_transport* t,
                                     grpc_chttp2_stream* s, int close_reads,
                                     int close_writes, grpc_error* error) {
   if (s->read_closed && s->write_closed) {
-    /* already closed */
+    /* already closed, but we should still fake the status if needed. */
+    grpc_error* overall_error = removal_error(error, s, "Stream removed");
+    if (overall_error != GRPC_ERROR_NONE) {
+      grpc_chttp2_fake_status(t, s, overall_error);
+    }
     grpc_chttp2_maybe_complete_recv_trailing_metadata(t, s);
-    GRPC_ERROR_UNREF(error);
     return;
   }
   bool closed_read = false;
@@ -2390,6 +2404,7 @@ static void close_from_api(grpc_chttp2_transport* t, grpc_chttp2_stream* s,
   grpc_slice_buffer_add(&t->qbuf, status_hdr);
   grpc_slice_buffer_add(&t->qbuf, message_pfx);
   grpc_slice_buffer_add(&t->qbuf, grpc_slice_ref_internal(slice));
+  grpc_chttp2_reset_ping_clock(t);
   grpc_chttp2_add_rst_stream_to_next_write(t, s->id, GRPC_HTTP2_NO_ERROR,
                                            &s->stats.outgoing);
 
@@ -2878,7 +2893,7 @@ static void keepalive_watchdog_fired_locked(void* arg, grpc_error* error) {
   grpc_chttp2_transport* t = static_cast<grpc_chttp2_transport*>(arg);
   if (t->keepalive_state == GRPC_CHTTP2_KEEPALIVE_STATE_PINGING) {
     if (error == GRPC_ERROR_NONE) {
-      gpr_log(GPR_ERROR, "%s: Keepalive watchdog fired. Closing transport.",
+      gpr_log(GPR_INFO, "%s: Keepalive watchdog fired. Closing transport.",
               t->peer_string);
       t->keepalive_state = GRPC_CHTTP2_KEEPALIVE_STATE_DYING;
       close_transport_locked(

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

@@ -25,9 +25,12 @@
 #include <math.h>
 #include <string.h>
 
+#include <string>
+
+#include "absl/strings/str_format.h"
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
-#include <grpc/support/string_util.h>
 
 #include "src/core/ext/transport/chttp2/transport/internal.h"
 #include "src/core/lib/gpr/string.h"
@@ -43,27 +46,23 @@ static constexpr const int kTracePadding = 30;
 static constexpr const uint32_t kMaxWindowUpdateSize = (1u << 31) - 1;
 
 static char* fmt_int64_diff_str(int64_t old_val, int64_t new_val) {
-  char* str;
+  std::string str;
   if (old_val != new_val) {
-    gpr_asprintf(&str, "%" PRId64 " -> %" PRId64 "", old_val, new_val);
+    str = absl::StrFormat("%" PRId64 " -> %" PRId64 "", old_val, new_val);
   } else {
-    gpr_asprintf(&str, "%" PRId64 "", old_val);
+    str = absl::StrFormat("%" PRId64 "", old_val);
   }
-  char* str_lp = gpr_leftpad(str, ' ', kTracePadding);
-  gpr_free(str);
-  return str_lp;
+  return gpr_leftpad(str.c_str(), ' ', kTracePadding);
 }
 
 static char* fmt_uint32_diff_str(uint32_t old_val, uint32_t new_val) {
-  char* str;
+  std::string str;
   if (old_val != new_val) {
-    gpr_asprintf(&str, "%" PRIu32 " -> %" PRIu32 "", old_val, new_val);
+    str = absl::StrFormat("%" PRIu32 " -> %" PRIu32 "", old_val, new_val);
   } else {
-    gpr_asprintf(&str, "%" PRIu32 "", old_val);
+    str = absl::StrFormat("%" PRIu32 "", old_val);
   }
-  char* str_lp = gpr_leftpad(str, ' ', kTracePadding);
-  gpr_free(str);
-  return str_lp;
+  return gpr_leftpad(str.c_str(), ' ', kTracePadding);
 }
 }  // namespace
 
@@ -204,13 +203,11 @@ uint32_t TransportFlowControl::MaybeSendUpdate(bool writing_anyway) {
 grpc_error* TransportFlowControl::ValidateRecvData(
     int64_t incoming_frame_size) {
   if (incoming_frame_size > announced_window_) {
-    char* msg;
-    gpr_asprintf(&msg,
-                 "frame of size %" PRId64 " overflows local window of %" PRId64,
-                 incoming_frame_size, announced_window_);
-    grpc_error* err = GRPC_ERROR_CREATE_FROM_COPIED_STRING(msg);
-    gpr_free(msg);
-    return err;
+    return GRPC_ERROR_CREATE_FROM_COPIED_STRING(
+        absl::StrFormat("frame of size %" PRId64
+                        " overflows local window of %" PRId64,
+                        incoming_frame_size, announced_window_)
+            .c_str());
   }
   return GRPC_ERROR_NONE;
 }
@@ -248,13 +245,11 @@ grpc_error* StreamFlowControl::RecvData(int64_t incoming_frame_size) {
               "See (for example) https://github.com/netty/netty/issues/6520.",
               incoming_frame_size, acked_stream_window, sent_stream_window);
     } else {
-      char* msg;
-      gpr_asprintf(
-          &msg, "frame of size %" PRId64 " overflows local window of %" PRId64,
-          incoming_frame_size, acked_stream_window);
-      grpc_error* err = GRPC_ERROR_CREATE_FROM_COPIED_STRING(msg);
-      gpr_free(msg);
-      return err;
+      return GRPC_ERROR_CREATE_FROM_COPIED_STRING(
+          absl::StrFormat("frame of size %" PRId64
+                          " overflows local window of %" PRId64,
+                          incoming_frame_size, acked_stream_window)
+              .c_str());
     }
   }
 

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

@@ -140,8 +140,7 @@ class FlowControlTrace {
 };
 
 // Fat interface with all methods a flow control implementation needs to
-// support. gRPC C Core does not support pure virtual functions, so instead
-// we abort in any methods which require implementation in the base class.
+// support.
 class TransportFlowControlBase {
  public:
   TransportFlowControlBase() {}
@@ -149,30 +148,30 @@ class TransportFlowControlBase {
 
   // Is flow control enabled? This is needed in other codepaths like the checks
   // in parsing and in writing.
-  virtual bool flow_control_enabled() const { abort(); }
+  virtual bool flow_control_enabled() const = 0;
 
   // Called to check if the transport needs to send a WINDOW_UPDATE frame
-  virtual uint32_t MaybeSendUpdate(bool /* writing_anyway */) { abort(); }
+  virtual uint32_t MaybeSendUpdate(bool /* writing_anyway */) = 0;
 
   // Using the protected members, returns and Action to be taken by the
   // tranport.
-  virtual FlowControlAction MakeAction() { abort(); }
+  virtual FlowControlAction MakeAction() = 0;
 
   // Using the protected members, returns and Action to be taken by the
   // tranport. Also checks for updates to our BDP estimate and acts
   // accordingly.
-  virtual FlowControlAction PeriodicUpdate() { abort(); }
+  virtual FlowControlAction PeriodicUpdate() = 0;
 
   // Called to do bookkeeping when a stream owned by this transport sends
   // data on the wire
-  virtual void StreamSentData(int64_t /* size */) { abort(); }
+  virtual void StreamSentData(int64_t /* size */) = 0;
 
   // Called to do bookkeeping when a stream owned by this transport receives
   // data from the wire. Also does error checking for frame size.
-  virtual grpc_error* RecvData(int64_t /* incoming_frame_size */) { abort(); }
+  virtual grpc_error* RecvData(int64_t /* incoming_frame_size */) = 0;
 
   // Called to do bookkeeping when we receive a WINDOW_UPDATE frame.
-  virtual void RecvUpdate(uint32_t /* size */) { abort(); }
+  virtual void RecvUpdate(uint32_t /* size */) = 0;
 
   // Returns the BdpEstimator held by this object. Caller is responsible for
   // checking for nullptr. TODO(ncteisen): consider fully encapsulating all
@@ -334,8 +333,7 @@ class TransportFlowControl final : public TransportFlowControlBase {
 };
 
 // Fat interface with all methods a stream flow control implementation needs
-// to support. gRPC C Core does not support pure virtual functions, so instead
-// we abort in any methods which require implementation in the base class.
+// to support.
 class StreamFlowControlBase {
  public:
   StreamFlowControlBase() {}
@@ -348,19 +346,19 @@ class StreamFlowControlBase {
 
   // Using the protected members, returns an Action for this stream to be
   // taken by the tranport.
-  virtual FlowControlAction MakeAction() { abort(); }
+  virtual FlowControlAction MakeAction() = 0;
 
   // Bookkeeping for when data is sent on this stream.
-  virtual void SentData(int64_t /* outgoing_frame_size */) { abort(); }
+  virtual void SentData(int64_t /* outgoing_frame_size */) = 0;
 
   // Bookkeeping and error checking for when data is received by this stream.
-  virtual grpc_error* RecvData(int64_t /* incoming_frame_size */) { abort(); }
+  virtual grpc_error* RecvData(int64_t /* incoming_frame_size */) = 0;
 
   // Called to check if this stream needs to send a WINDOW_UPDATE frame.
-  virtual uint32_t MaybeSendUpdate() { abort(); }
+  virtual uint32_t MaybeSendUpdate() = 0;
 
   // Bookkeeping for receiving a WINDOW_UPDATE from for this stream.
-  virtual void RecvUpdate(uint32_t /* size */) { abort(); }
+  virtual void RecvUpdate(uint32_t /* size */) = 0;
 
   // Bookkeeping for when a call pulls bytes out of the transport. At this
   // point we consider the data 'used' and can thus let out peer know we are

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

@@ -22,9 +22,10 @@
 
 #include <string.h>
 
+#include "absl/strings/str_format.h"
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
-#include <grpc/support/string_util.h>
 #include "src/core/ext/transport/chttp2/transport/internal.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gprpp/memory.h"
@@ -44,13 +45,10 @@ grpc_error* grpc_chttp2_data_parser_begin_frame(
     grpc_chttp2_data_parser* /*parser*/, uint8_t flags, uint32_t stream_id,
     grpc_chttp2_stream* s) {
   if (flags & ~GRPC_CHTTP2_DATA_FLAG_END_STREAM) {
-    char* msg;
-    gpr_asprintf(&msg, "unsupported data flags: 0x%02x", flags);
-    grpc_error* err = grpc_error_set_int(
-        GRPC_ERROR_CREATE_FROM_COPIED_STRING(msg), GRPC_ERROR_INT_STREAM_ID,
-        static_cast<intptr_t>(stream_id));
-    gpr_free(msg);
-    return err;
+    return grpc_error_set_int(
+        GRPC_ERROR_CREATE_FROM_COPIED_STRING(
+            absl::StrFormat("unsupported data flags: 0x%02x", flags).c_str()),
+        GRPC_ERROR_INT_STREAM_ID, static_cast<intptr_t>(stream_id));
   }
 
   if (flags & GRPC_CHTTP2_DATA_FLAG_END_STREAM) {
@@ -130,12 +128,11 @@ grpc_error* grpc_deframe_unprocessed_incoming_frames(
             p->is_frame_compressed = true; /* GPR_TRUE */
             break;
           default:
-            char* msg;
-            gpr_asprintf(&msg, "Bad GRPC frame type 0x%02x", p->frame_type);
-            p->error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(msg);
+            p->error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(
+                absl::StrFormat("Bad GRPC frame type 0x%02x", p->frame_type)
+                    .c_str());
             p->error = grpc_error_set_int(p->error, GRPC_ERROR_INT_STREAM_ID,
                                           static_cast<intptr_t>(s->id));
-            gpr_free(msg);
             p->error = grpc_error_set_str(
                 p->error, GRPC_ERROR_STR_RAW_BYTES,
                 grpc_slice_from_moved_string(grpc_core::UniquePtr<char>(

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

@@ -23,9 +23,10 @@
 
 #include <string.h>
 
+#include "absl/strings/str_format.h"
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
-#include <grpc/support/string_util.h>
 
 void grpc_chttp2_goaway_parser_init(grpc_chttp2_goaway_parser* p) {
   p->debug_data = nullptr;
@@ -39,11 +40,8 @@ grpc_error* grpc_chttp2_goaway_parser_begin_frame(grpc_chttp2_goaway_parser* p,
                                                   uint32_t length,
                                                   uint8_t /*flags*/) {
   if (length < 8) {
-    char* msg;
-    gpr_asprintf(&msg, "goaway frame too short (%d bytes)", length);
-    grpc_error* err = GRPC_ERROR_CREATE_FROM_COPIED_STRING(msg);
-    gpr_free(msg);
-    return err;
+    return GRPC_ERROR_CREATE_FROM_COPIED_STRING(
+        absl::StrFormat("goaway frame too short (%d bytes)", length).c_str());
   }
 
   gpr_free(p->debug_data);

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

@@ -23,9 +23,10 @@
 
 #include <string.h>
 
+#include "absl/strings/str_format.h"
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
-#include <grpc/support/string_util.h>
 
 static bool g_disable_ping_ack = false;
 
@@ -58,11 +59,9 @@ grpc_error* grpc_chttp2_ping_parser_begin_frame(grpc_chttp2_ping_parser* parser,
                                                 uint32_t length,
                                                 uint8_t flags) {
   if (flags & 0xfe || length != 8) {
-    char* msg;
-    gpr_asprintf(&msg, "invalid ping: length=%d, flags=%02x", length, flags);
-    grpc_error* error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(msg);
-    gpr_free(msg);
-    return error;
+    return GRPC_ERROR_CREATE_FROM_COPIED_STRING(
+        absl::StrFormat("invalid ping: length=%d, flags=%02x", length, flags)
+            .c_str());
   }
   parser->byte = 0;
   parser->is_ack = flags;