grpc 1.28.0.pre2 → 1.31.0.pre1

data/src/core/lib/surface/server.h

@@ -32,14 +32,36 @@ extern const grpc_channel_filter grpc_server_top_filter;
 /** Lightweight tracing of server channel state */
 extern grpc_core::TraceFlag grpc_server_channel_trace;
 
-/* Add a listener to the server: when the server starts, it will call start,
-   and when it shuts down, it will call destroy */
+namespace grpc_core {
+
+/// Interface for listeners.
+/// Implementations must override the Orphan() method, which should stop
+/// listening and initiate destruction of the listener.
+class ServerListenerInterface : public Orphanable {
+ public:
+  virtual ~ServerListenerInterface() = default;
+
+  /// Starts listening. This listener may refer to the pollset object beyond
+  /// this call, so it is a pointer rather than a reference.
+  virtual void Start(grpc_server* server,
+                     const std::vector<grpc_pollset*>* pollsets) = 0;
+
+  /// Returns the channelz node for the listen socket, or null if not
+  /// supported.
+  virtual channelz::ListenSocketNode* channelz_listen_socket_node() const = 0;
+
+  /// Sets a closure to be invoked by the listener when its destruction
+  /// is complete.
+  virtual void SetOnDestroyDone(grpc_closure* on_destroy_done) = 0;
+};
+
+}  // namespace grpc_core
+
+/* Add a listener to the server: when the server starts, it will call Start(),
+   and when it shuts down, it will orphan the listener. */
 void grpc_server_add_listener(
-    grpc_server* server, void* listener_arg,
-    void (*start)(grpc_server* server, void* arg, grpc_pollset** pollsets,
-                  size_t npollsets),
-    void (*destroy)(grpc_server* server, void* arg, grpc_closure* on_done),
-    grpc_core::RefCountedPtr<grpc_core::channelz::ListenSocketNode> node);
+    grpc_server* server,
+    grpc_core::OrphanablePtr<grpc_core::ServerListenerInterface> listener);
 
 /* Setup a transport - creates a channel stack, binds the transport to the
    server */
@@ -57,11 +79,43 @@ const grpc_channel_args* grpc_server_get_channel_args(grpc_server* server);
 
 grpc_resource_user* grpc_server_get_default_resource_user(grpc_server* server);
 
-int grpc_server_has_open_connections(grpc_server* server);
+bool grpc_server_has_open_connections(grpc_server* server);
+
+// Do not call this before grpc_server_start. Returns the pollsets. The vector
+// itself is immutable, but the pollsets inside are mutable. The result is valid
+// for the lifetime of the server.
+const std::vector<grpc_pollset*>& grpc_server_get_pollsets(grpc_server* server);
+
+namespace grpc_core {
+
+// An object to represent the most relevant characteristics of a newly-allocated
+// call object when using an AllocatingRequestMatcherBatch
+struct ServerBatchCallAllocation {
+  grpc_experimental_completion_queue_functor* tag;
+  grpc_call** call;
+  grpc_metadata_array* initial_metadata;
+  grpc_call_details* details;
+};
+
+// An object to represent the most relevant characteristics of a newly-allocated
+// call object when using an AllocatingRequestMatcherRegistered
+struct ServerRegisteredCallAllocation {
+  grpc_experimental_completion_queue_functor* tag;
+  grpc_call** call;
+  grpc_metadata_array* initial_metadata;
+  gpr_timespec* deadline;
+  grpc_byte_buffer** optional_payload;
+};
+
+// Functions to specify that a specific registered method or the unregistered
+// collection should use a specific allocator for request matching.
+void SetServerRegisteredMethodAllocator(
+    grpc_server* server, grpc_completion_queue* cq, void* method_tag,
+    std::function<ServerRegisteredCallAllocation()> allocator);
+void SetServerBatchMethodAllocator(
+    grpc_server* server, grpc_completion_queue* cq,
+    std::function<ServerBatchCallAllocation()> allocator);
 
-/* Do not call this before grpc_server_start. Returns the pollsets and the
- * number of pollsets via 'pollsets' and 'pollset_count'. */
-void grpc_server_get_pollsets(grpc_server* server, grpc_pollset*** pollsets,
-                              size_t* pollset_count);
+}  // namespace grpc_core
 
 #endif /* GRPC_CORE_LIB_SURFACE_SERVER_H */

data/src/core/lib/surface/version.cc

@@ -23,6 +23,6 @@
 
 #include <grpc/grpc.h>
 
-const char* grpc_version_string(void) { return "9.0.0"; }
+const char* grpc_version_string(void) { return "11.0.0"; }
 
-const char* grpc_g_stands_for(void) { return "galactic"; }
+const char* grpc_g_stands_for(void) { return "galore"; }

data/src/core/lib/transport/byte_stream.h

@@ -26,10 +26,15 @@
 #include "src/core/lib/iomgr/closure.h"
 
 /** Internal bit flag for grpc_begin_message's \a flags signaling the use of
- * compression for the message */
+ * compression for the message. (Does not apply for stream compression.) */
 #define GRPC_WRITE_INTERNAL_COMPRESS (0x80000000u)
+/** Internal bit flag for determining whether the message was compressed and had
+ * to be decompressed by the message_decompress filter. (Does not apply for
+ * stream compression.) */
+#define GRPC_WRITE_INTERNAL_TEST_ONLY_WAS_COMPRESSED (0x40000000u)
 /** Mask of all valid internal flags. */
-#define GRPC_WRITE_INTERNAL_USED_MASK (GRPC_WRITE_INTERNAL_COMPRESS)
+#define GRPC_WRITE_INTERNAL_USED_MASK \
+  (GRPC_WRITE_INTERNAL_COMPRESS | GRPC_WRITE_INTERNAL_TEST_ONLY_WAS_COMPRESSED)
 
 namespace grpc_core {
 

data/src/core/lib/transport/connectivity_state.cc

@@ -58,12 +58,13 @@ const char* ConnectivityStateName(grpc_connectivity_state state) {
 class AsyncConnectivityStateWatcherInterface::Notifier {
  public:
   Notifier(RefCountedPtr<AsyncConnectivityStateWatcherInterface> watcher,
-           grpc_connectivity_state state, Combiner* combiner)
+           grpc_connectivity_state state,
+           const std::shared_ptr<WorkSerializer>& work_serializer)
       : watcher_(std::move(watcher)), state_(state) {
-    if (combiner != nullptr) {
-      combiner->Run(
-          GRPC_CLOSURE_INIT(&closure_, SendNotification, this, nullptr),
-          GRPC_ERROR_NONE);
+    if (work_serializer != nullptr) {
+      work_serializer->Run(
+          [this]() { SendNotification(this, GRPC_ERROR_NONE); },
+          DEBUG_LOCATION);
     } else {
       GRPC_CLOSURE_INIT(&closure_, SendNotification, this,
                         grpc_schedule_on_exec_ctx);
@@ -89,7 +90,7 @@ class AsyncConnectivityStateWatcherInterface::Notifier {
 
 void AsyncConnectivityStateWatcherInterface::Notify(
     grpc_connectivity_state state) {
-  new Notifier(Ref(), state, combiner_);  // Deletes itself when done.
+  new Notifier(Ref(), state, work_serializer_);  // Deletes itself when done.
 }
 
 //

data/src/core/lib/transport/connectivity_state.h

@@ -29,6 +29,7 @@
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
+#include "src/core/lib/iomgr/work_serializer.h"
 
 namespace grpc_core {
 
@@ -70,14 +71,15 @@ class AsyncConnectivityStateWatcherInterface
 
   // If \a combiner is nullptr, then the notification will be scheduled on the
   // ExecCtx.
-  explicit AsyncConnectivityStateWatcherInterface(Combiner* combiner = nullptr)
-      : combiner_(combiner) {}
+  explicit AsyncConnectivityStateWatcherInterface(
+      std::shared_ptr<WorkSerializer> work_serializer = nullptr)
+      : work_serializer_(std::move(work_serializer)) {}
 
   // Invoked asynchronously when Notify() is called.
   virtual void OnConnectivityStateChange(grpc_connectivity_state new_state) = 0;
 
  private:
-  Combiner* combiner_;
+  std::shared_ptr<WorkSerializer> work_serializer_;
 };
 
 // Tracks connectivity state.  Maintains a list of watchers that are

data/src/core/lib/transport/metadata.cc

@@ -256,9 +256,9 @@ void grpc_mdctx_global_shutdown() {
         abort();
       }
     }
-      // For ASAN builds, we don't want to crash here, because that will
-      // prevent ASAN from providing leak detection information, which is
-      // far more useful than this simple assertion.
+    // For ASAN builds, we don't want to crash here, because that will
+    // prevent ASAN from providing leak detection information, which is
+    // far more useful than this simple assertion.
 #ifndef GRPC_ASAN_ENABLED
     GPR_DEBUG_ASSERT(shard->count == 0);
 #endif

data/src/core/lib/transport/metadata_batch.h

@@ -154,11 +154,10 @@ inline grpc_error* GRPC_MUST_USE_RESULT grpc_metadata_batch_add_tail(
 
 grpc_error* grpc_attach_md_to_error(grpc_error* src, grpc_mdelem md);
 
-typedef struct {
+struct grpc_filtered_mdelem {
   grpc_error* error;
   grpc_mdelem md;
-} grpc_filtered_mdelem;
-
+};
 #define GRPC_FILTERED_ERROR(error) \
   { (error), GRPC_MDNULL }
 #define GRPC_FILTERED_MDELEM(md) \

data/src/core/lib/transport/static_metadata.h

@@ -46,7 +46,7 @@ constexpr uint64_t kGrpcStaticMetadataInitCanary = 0xCAFEF00DC0FFEE11L;
 uint64_t StaticMetadataInitCanary();
 #endif
 extern const StaticMetadataSlice* g_static_metadata_slice_table;
-}
+}  // namespace grpc_core
 inline const grpc_core::StaticMetadataSlice* grpc_static_slice_table() {
   GPR_DEBUG_ASSERT(grpc_core::StaticMetadataInitCanary() ==
                    grpc_core::kGrpcStaticMetadataInitCanary);

data/src/core/lib/transport/status_conversion.cc

@@ -68,29 +68,21 @@ grpc_status_code grpc_http2_status_to_grpc_status(int status) {
     case 200:
       return GRPC_STATUS_OK;
     case 400:
-      return GRPC_STATUS_INVALID_ARGUMENT;
+      return GRPC_STATUS_INTERNAL;
     case 401:
       return GRPC_STATUS_UNAUTHENTICATED;
     case 403:
       return GRPC_STATUS_PERMISSION_DENIED;
     case 404:
-      return GRPC_STATUS_NOT_FOUND;
-    case 409:
-      return GRPC_STATUS_ABORTED;
-    case 412:
-      return GRPC_STATUS_FAILED_PRECONDITION;
-    case 429:
-      return GRPC_STATUS_RESOURCE_EXHAUSTED;
-    case 499:
-      return GRPC_STATUS_CANCELLED;
-    case 500:
-      return GRPC_STATUS_UNKNOWN;
-    case 501:
       return GRPC_STATUS_UNIMPLEMENTED;
+    case 429:
+      return GRPC_STATUS_UNAVAILABLE;
+    case 502:
+      return GRPC_STATUS_UNAVAILABLE;
     case 503:
       return GRPC_STATUS_UNAVAILABLE;
     case 504:
-      return GRPC_STATUS_DEADLINE_EXCEEDED;
+      return GRPC_STATUS_UNAVAILABLE;
     /* everything else is unknown */
     default:
       return GRPC_STATUS_UNKNOWN;

data/src/core/lib/transport/transport.cc

@@ -233,13 +233,12 @@ grpc_transport_op* grpc_make_transport_op(grpc_closure* on_complete) {
   return &op->op;
 }
 
-typedef struct {
+struct made_transport_stream_op {
   grpc_closure outer_on_complete;
   grpc_closure* inner_on_complete;
   grpc_transport_stream_op_batch op;
   grpc_transport_stream_op_batch_payload payload;
-} made_transport_stream_op;
-
+};
 static void destroy_made_transport_stream_op(void* arg, grpc_error* error) {
   made_transport_stream_op* op = static_cast<made_transport_stream_op*>(arg);
   grpc_closure* c = op->inner_on_complete;

data/src/core/lib/transport/transport.h

@@ -242,6 +242,12 @@ struct grpc_transport_stream_op_batch_payload {
 
   struct {
     grpc_metadata_batch* send_trailing_metadata = nullptr;
+    // Set by the transport to true if the stream successfully wrote the
+    // trailing metadata. If this is not set but there was a send trailing
+    // metadata op present, this can indicate that a server call can be marked
+    // as  a cancellation (since the stream was write-closed before status could
+    // be delivered).
+    bool* sent = nullptr;
   } send_trailing_metadata;
 
   struct {
@@ -408,8 +414,9 @@ void grpc_transport_stream_op_batch_finish_with_failure(
     grpc_transport_stream_op_batch* op, grpc_error* error,
     grpc_core::CallCombiner* call_combiner);
 
-char* grpc_transport_stream_op_batch_string(grpc_transport_stream_op_batch* op);
-char* grpc_transport_op_string(grpc_transport_op* op);
+std::string grpc_transport_stream_op_batch_string(
+    grpc_transport_stream_op_batch* op);
+std::string grpc_transport_op_string(grpc_transport_op* op);
 
 /* Send a batch of operations on a transport
 

data/src/core/lib/transport/transport_op_string.cc

@@ -25,6 +25,12 @@
 #include <stdio.h>
 #include <string.h>
 
+#include <vector>
+
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_format.h"
+#include "absl/strings/str_join.h"
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/string_util.h>
 #include "src/core/lib/gpr/string.h"
@@ -34,177 +40,130 @@
 /* These routines are here to facilitate debugging - they produce string
    representations of various transport data structures */
 
-static void put_metadata(gpr_strvec* b, grpc_mdelem md) {
-  gpr_strvec_add(b, gpr_strdup("key="));
-  gpr_strvec_add(
-      b, grpc_dump_slice(GRPC_MDKEY(md), GPR_DUMP_HEX | GPR_DUMP_ASCII));
-
-  gpr_strvec_add(b, gpr_strdup(" value="));
-  gpr_strvec_add(
-      b, grpc_dump_slice(GRPC_MDVALUE(md), GPR_DUMP_HEX | GPR_DUMP_ASCII));
+static void put_metadata(grpc_mdelem md, std::vector<std::string>* out) {
+  out->push_back("key=");
+  char* dump = grpc_dump_slice(GRPC_MDKEY(md), GPR_DUMP_HEX | GPR_DUMP_ASCII);
+  out->push_back(dump);
+  gpr_free(dump);
+  out->push_back(" value=");
+  dump = grpc_dump_slice(GRPC_MDVALUE(md), GPR_DUMP_HEX | GPR_DUMP_ASCII);
+  out->push_back(dump);
+  gpr_free(dump);
 }
 
-static void put_metadata_list(gpr_strvec* b, grpc_metadata_batch md) {
+static void put_metadata_list(grpc_metadata_batch md,
+                              std::vector<std::string>* out) {
   grpc_linked_mdelem* m;
   for (m = md.list.head; m != nullptr; m = m->next) {
-    if (m != md.list.head) gpr_strvec_add(b, gpr_strdup(", "));
-    put_metadata(b, m->md);
+    if (m != md.list.head) out->push_back(", ");
+    put_metadata(m->md, out);
   }
   if (md.deadline != GRPC_MILLIS_INF_FUTURE) {
-    char* tmp;
-    gpr_asprintf(&tmp, " deadline=%" PRId64, md.deadline);
-    gpr_strvec_add(b, tmp);
+    out->push_back(absl::StrFormat(" deadline=%" PRId64, md.deadline));
   }
 }
 
-char* grpc_transport_stream_op_batch_string(
+std::string grpc_transport_stream_op_batch_string(
     grpc_transport_stream_op_batch* op) {
-  char* tmp;
-  char* out;
-
-  gpr_strvec b;
-  gpr_strvec_init(&b);
+  std::vector<std::string> out;
 
   if (op->send_initial_metadata) {
-    gpr_strvec_add(&b, gpr_strdup(" "));
-    gpr_strvec_add(&b, gpr_strdup("SEND_INITIAL_METADATA{"));
-    put_metadata_list(
-        &b, *op->payload->send_initial_metadata.send_initial_metadata);
-    gpr_strvec_add(&b, gpr_strdup("}"));
+    out.push_back(" SEND_INITIAL_METADATA{");
+    put_metadata_list(*op->payload->send_initial_metadata.send_initial_metadata,
+                      &out);
+    out.push_back("}");
   }
 
   if (op->send_message) {
-    gpr_strvec_add(&b, gpr_strdup(" "));
     if (op->payload->send_message.send_message != nullptr) {
-      gpr_asprintf(&tmp, "SEND_MESSAGE:flags=0x%08x:len=%d",
-                   op->payload->send_message.send_message->flags(),
-                   op->payload->send_message.send_message->length());
+      out.push_back(
+          absl::StrFormat(" SEND_MESSAGE:flags=0x%08x:len=%d",
+                          op->payload->send_message.send_message->flags(),
+                          op->payload->send_message.send_message->length()));
     } else {
       // This can happen when we check a batch after the transport has
       // processed and cleared the send_message op.
-      tmp =
-          gpr_strdup("SEND_MESSAGE(flag and length unknown, already orphaned)");
+      out.push_back(" SEND_MESSAGE(flag and length unknown, already orphaned)");
     }
-    gpr_strvec_add(&b, tmp);
   }
 
   if (op->send_trailing_metadata) {
-    gpr_strvec_add(&b, gpr_strdup(" "));
-    gpr_strvec_add(&b, gpr_strdup("SEND_TRAILING_METADATA{"));
+    out.push_back(" SEND_TRAILING_METADATA{");
     put_metadata_list(
-        &b, *op->payload->send_trailing_metadata.send_trailing_metadata);
-    gpr_strvec_add(&b, gpr_strdup("}"));
+        *op->payload->send_trailing_metadata.send_trailing_metadata, &out);
+    out.push_back("}");
   }
 
   if (op->recv_initial_metadata) {
-    gpr_strvec_add(&b, gpr_strdup(" "));
-    gpr_strvec_add(&b, gpr_strdup("RECV_INITIAL_METADATA"));
+    out.push_back(" RECV_INITIAL_METADATA");
   }
 
   if (op->recv_message) {
-    gpr_strvec_add(&b, gpr_strdup(" "));
-    gpr_strvec_add(&b, gpr_strdup("RECV_MESSAGE"));
+    out.push_back(" RECV_MESSAGE");
   }
 
   if (op->recv_trailing_metadata) {
-    gpr_strvec_add(&b, gpr_strdup(" "));
-    gpr_strvec_add(&b, gpr_strdup("RECV_TRAILING_METADATA"));
+    out.push_back(" RECV_TRAILING_METADATA");
   }
 
   if (op->cancel_stream) {
-    gpr_strvec_add(&b, gpr_strdup(" "));
-    const char* msg =
-        grpc_error_string(op->payload->cancel_stream.cancel_error);
-    gpr_asprintf(&tmp, "CANCEL:%s", msg);
-
-    gpr_strvec_add(&b, tmp);
+    out.push_back(absl::StrCat(
+        " CANCEL:",
+        grpc_error_string(op->payload->cancel_stream.cancel_error)));
   }
 
-  out = gpr_strvec_flatten(&b, nullptr);
-  gpr_strvec_destroy(&b);
-
-  return out;
+  return absl::StrJoin(out, "");
 }
 
-char* grpc_transport_op_string(grpc_transport_op* op) {
-  char* tmp;
-  char* out;
-  bool first = true;
-
-  gpr_strvec b;
-  gpr_strvec_init(&b);
+std::string grpc_transport_op_string(grpc_transport_op* op) {
+  std::vector<std::string> out;
 
   if (op->start_connectivity_watch != nullptr) {
-    if (!first) gpr_strvec_add(&b, gpr_strdup(" "));
-    first = false;
-    gpr_asprintf(
-        &tmp, "START_CONNECTIVITY_WATCH:watcher=%p:from=%s",
+    out.push_back(absl::StrFormat(
+        " START_CONNECTIVITY_WATCH:watcher=%p:from=%s",
         op->start_connectivity_watch.get(),
-        grpc_core::ConnectivityStateName(op->start_connectivity_watch_state));
-    gpr_strvec_add(&b, tmp);
+        grpc_core::ConnectivityStateName(op->start_connectivity_watch_state)));
   }
 
   if (op->stop_connectivity_watch != nullptr) {
-    if (!first) gpr_strvec_add(&b, gpr_strdup(" "));
-    first = false;
-    gpr_asprintf(&tmp, "STOP_CONNECTIVITY_WATCH:watcher=%p",
-                 op->stop_connectivity_watch);
-    gpr_strvec_add(&b, tmp);
+    out.push_back(absl::StrFormat(" STOP_CONNECTIVITY_WATCH:watcher=%p",
+                                  op->stop_connectivity_watch));
   }
 
   if (op->disconnect_with_error != GRPC_ERROR_NONE) {
-    if (!first) gpr_strvec_add(&b, gpr_strdup(" "));
-    first = false;
-    const char* err = grpc_error_string(op->disconnect_with_error);
-    gpr_asprintf(&tmp, "DISCONNECT:%s", err);
-    gpr_strvec_add(&b, tmp);
+    out.push_back(absl::StrCat(" DISCONNECT:",
+                               grpc_error_string(op->disconnect_with_error)));
   }
 
   if (op->goaway_error) {
-    if (!first) gpr_strvec_add(&b, gpr_strdup(" "));
-    first = false;
-    const char* msg = grpc_error_string(op->goaway_error);
-    gpr_asprintf(&tmp, "SEND_GOAWAY:%s", msg);
-
-    gpr_strvec_add(&b, tmp);
+    out.push_back(
+        absl::StrCat(" SEND_GOAWAY:%s", grpc_error_string(op->goaway_error)));
   }
 
   if (op->set_accept_stream) {
-    if (!first) gpr_strvec_add(&b, gpr_strdup(" "));
-    first = false;
-    gpr_asprintf(&tmp, "SET_ACCEPT_STREAM:%p(%p,...)", op->set_accept_stream_fn,
-                 op->set_accept_stream_user_data);
-    gpr_strvec_add(&b, tmp);
+    out.push_back(absl::StrFormat(" SET_ACCEPT_STREAM:%p(%p,...)",
+                                  op->set_accept_stream_fn,
+                                  op->set_accept_stream_user_data));
   }
 
   if (op->bind_pollset != nullptr) {
-    if (!first) gpr_strvec_add(&b, gpr_strdup(" "));
-    first = false;
-    gpr_strvec_add(&b, gpr_strdup("BIND_POLLSET"));
+    out.push_back(" BIND_POLLSET");
   }
 
   if (op->bind_pollset_set != nullptr) {
-    if (!first) gpr_strvec_add(&b, gpr_strdup(" "));
-    first = false;
-    gpr_strvec_add(&b, gpr_strdup("BIND_POLLSET_SET"));
+    out.push_back(" BIND_POLLSET_SET");
   }
 
   if (op->send_ping.on_initiate != nullptr || op->send_ping.on_ack != nullptr) {
-    if (!first) gpr_strvec_add(&b, gpr_strdup(" "));
-    // first = false;
-    gpr_strvec_add(&b, gpr_strdup("SEND_PING"));
+    out.push_back(" SEND_PING");
   }
 
-  out = gpr_strvec_flatten(&b, nullptr);
-  gpr_strvec_destroy(&b);
-
-  return out;
+  return absl::StrJoin(out, "");
 }
 
 void grpc_call_log_op(const char* file, int line, gpr_log_severity severity,
                       grpc_call_element* elem,
                       grpc_transport_stream_op_batch* op) {
-  char* str = grpc_transport_stream_op_batch_string(op);
-  gpr_log(file, line, severity, "OP[%s:%p]: %s", elem->filter->name, elem, str);
-  gpr_free(str);
+  gpr_log(file, line, severity, "OP[%s:%p]: %s", elem->filter->name, elem,
+          grpc_transport_stream_op_batch_string(op).c_str());
 }