grpc 1.43.1 → 1.44.0.pre2

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

@@ -26,7 +26,7 @@
 
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/channel/context.h"
-#include "src/core/lib/gprpp/arena.h"
+#include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/surface/api_trace.h"
 #include "src/core/lib/surface/server.h"
 
@@ -46,8 +46,8 @@ typedef struct grpc_call_create_args {
 
   const void* server_transport_data;
 
-  grpc_mdelem* add_initial_metadata;
-  size_t add_initial_metadata_count;
+  absl::optional<grpc_core::Slice> path;
+  absl::optional<grpc_core::Slice> authority;
 
   grpc_millis send_deadline;
 } grpc_call_create_args;
@@ -55,7 +55,7 @@ typedef struct grpc_call_create_args {
 /* Create a new call based on \a args.
    Regardless of success or failure, always returns a valid new call into *call
    */
-grpc_error_handle grpc_call_create(const grpc_call_create_args* args,
+grpc_error_handle grpc_call_create(grpc_call_create_args* args,
                                    grpc_call** call);
 
 void grpc_call_set_completion_queue(grpc_call* call, grpc_completion_queue* cq);

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

@@ -41,11 +41,12 @@
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/iomgr/iomgr.h"
+#include "src/core/lib/resource_quota/api.h"
 #include "src/core/lib/resource_quota/memory_quota.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/surface/api_trace.h"
 #include "src/core/lib/surface/call.h"
-#include "src/core/lib/transport/static_metadata.h"
+#include "src/core/lib/surface/channel_stack_type.h"
 
 /** Cache grpc-status: X mdelems for X = 0..NUM_CACHED_STATUS_ELEMS.
  *  Avoids needing to take a metadata context lock for sending status
@@ -59,7 +60,7 @@ static void destroy_channel(void* arg, grpc_error_handle error);
 grpc_channel* grpc_channel_create_with_builder(
     grpc_channel_stack_builder* builder,
     grpc_channel_stack_type channel_stack_type, grpc_error_handle* error) {
-  char* target = gpr_strdup(grpc_channel_stack_builder_get_target(builder));
+  std::string target = grpc_channel_stack_builder_get_target(builder);
   grpc_channel_args* args = grpc_channel_args_copy(
       grpc_channel_stack_builder_get_channel_arguments(builder));
   grpc_channel* channel;
@@ -68,6 +69,7 @@ grpc_channel* grpc_channel_create_with_builder(
   } else {
     GRPC_STATS_INC_CLIENT_CHANNELS_CREATED();
   }
+  std::string name = grpc_channel_stack_builder_get_target(builder);
   grpc_error_handle builder_error = grpc_channel_stack_builder_finish(
       builder, sizeof(grpc_channel), 1, destroy_channel, nullptr,
       reinterpret_cast<void**>(&channel));
@@ -80,13 +82,15 @@ grpc_channel* grpc_channel_create_with_builder(
     } else {
       GRPC_ERROR_UNREF(builder_error);
     }
-    gpr_free(target);
     grpc_channel_args_destroy(args);
     return nullptr;
   }
-  channel->target = target;
+  channel->target.Init(std::move(target));
   channel->is_client = grpc_channel_stack_type_is_client(channel_stack_type);
   channel->registration_table.Init();
+  channel->allocator.Init(grpc_core::ResourceQuotaFromChannelArgs(args)
+                              ->memory_quota()
+                              ->CreateMemoryOwner(name));
 
   gpr_atm_no_barrier_store(
       &channel->call_size_estimate,
@@ -197,11 +201,10 @@ void CreateChannelzNode(grpc_channel_stack_builder* builder) {
   const bool is_internal_channel = grpc_channel_args_find_bool(
       args, GRPC_ARG_CHANNELZ_IS_INTERNAL_CHANNEL, false);
   // Create the channelz node.
-  const char* target = grpc_channel_stack_builder_get_target(builder);
+  std::string target = grpc_channel_stack_builder_get_target(builder);
   grpc_core::RefCountedPtr<grpc_core::channelz::ChannelNode> channelz_node =
       grpc_core::MakeRefCounted<grpc_core::channelz::ChannelNode>(
-          target != nullptr ? target : "", channel_tracer_max_memory,
-          is_internal_channel);
+          target.c_str(), channel_tracer_max_memory, is_internal_channel);
   channelz_node->AddTraceEvent(
       grpc_core::channelz::ChannelTrace::Severity::Info,
       grpc_slice_from_static_string("Channel created"));
@@ -241,7 +244,8 @@ grpc_channel* grpc_channel_create(const char* target,
   // grpc_shutdown() when the channel is actually destroyed, thus
   // ensuring that shutdown is deferred until that point.
   grpc_init();
-  grpc_channel_stack_builder* builder = grpc_channel_stack_builder_create();
+  grpc_channel_stack_builder* builder = grpc_channel_stack_builder_create(
+      grpc_channel_stack_type_string(channel_stack_type));
   const grpc_core::UniquePtr<char> default_authority =
       get_default_authority(input_args);
   grpc_channel_args* args =
@@ -313,7 +317,7 @@ void grpc_channel_update_call_size_estimate(grpc_channel* channel,
 
 char* grpc_channel_get_target(grpc_channel* channel) {
   GRPC_API_TRACE("grpc_channel_get_target(channel=%p)", 1, (channel));
-  return gpr_strdup(channel->target);
+  return gpr_strdup(channel->target->c_str());
 }
 
 void grpc_channel_get_info(grpc_channel* channel,
@@ -340,19 +344,11 @@ void grpc_channel_reset_connect_backoff(grpc_channel* channel) {
 static grpc_call* grpc_channel_create_call_internal(
     grpc_channel* channel, grpc_call* parent_call, uint32_t propagation_mask,
     grpc_completion_queue* cq, grpc_pollset_set* pollset_set_alternative,
-    grpc_mdelem path_mdelem, grpc_mdelem authority_mdelem,
+    grpc_core::Slice path, absl::optional<grpc_core::Slice> authority,
     grpc_millis deadline) {
-  grpc_mdelem send_metadata[2];
-  size_t num_metadata = 0;
-
   GPR_ASSERT(channel->is_client);
   GPR_ASSERT(!(cq != nullptr && pollset_set_alternative != nullptr));
 
-  send_metadata[num_metadata++] = path_mdelem;
-  if (!GRPC_MDISNULL(authority_mdelem)) {
-    send_metadata[num_metadata++] = authority_mdelem;
-  }
-
   grpc_call_create_args args;
   args.channel = channel;
   args.server = nullptr;
@@ -361,8 +357,8 @@ static grpc_call* grpc_channel_create_call_internal(
   args.cq = cq;
   args.pollset_set_alternative = pollset_set_alternative;
   args.server_transport_data = nullptr;
-  args.add_initial_metadata = send_metadata;
-  args.add_initial_metadata_count = num_metadata;
+  args.path = std::move(path);
+  args.authority = std::move(authority);
   args.send_deadline = deadline;
 
   grpc_call* call;
@@ -381,9 +377,10 @@ grpc_call* grpc_channel_create_call(grpc_channel* channel,
   grpc_core::ExecCtx exec_ctx;
   grpc_call* call = grpc_channel_create_call_internal(
       channel, parent_call, propagation_mask, completion_queue, nullptr,
-      grpc_mdelem_create(GRPC_MDSTR_PATH, method, nullptr),
-      host != nullptr ? grpc_mdelem_create(GRPC_MDSTR_AUTHORITY, *host, nullptr)
-                      : GRPC_MDNULL,
+      grpc_core::Slice(grpc_slice_ref_internal(method)),
+      host != nullptr
+          ? absl::optional<grpc_core::Slice>(grpc_slice_ref_internal(*host))
+          : absl::nullopt,
       grpc_timespec_to_millis_round_up(deadline));
 
   return call;
@@ -396,34 +393,31 @@ grpc_call* grpc_channel_create_pollset_set_call(
   GPR_ASSERT(!reserved);
   return grpc_channel_create_call_internal(
       channel, parent_call, propagation_mask, nullptr, pollset_set,
-      grpc_mdelem_create(GRPC_MDSTR_PATH, method, nullptr),
-      host != nullptr ? grpc_mdelem_create(GRPC_MDSTR_AUTHORITY, *host, nullptr)
-                      : GRPC_MDNULL,
+      grpc_core::Slice(method),
+      host != nullptr
+          ? absl::optional<grpc_core::Slice>(grpc_slice_ref_internal(*host))
+          : absl::nullopt,
       deadline);
 }
 
 namespace grpc_core {
 
-RegisteredCall::RegisteredCall(const char* method_arg, const char* host_arg)
-    : path(method_arg != nullptr && method_arg[0] != 0
-               ? grpc_mdelem_from_slices(
-                     GRPC_MDSTR_PATH, grpc_slice_from_copied_string(method_arg))
-               : GRPC_MDNULL),
-      authority(
-          host_arg != nullptr && host_arg[0] != 0
-              ? grpc_mdelem_from_slices(GRPC_MDSTR_AUTHORITY,
-                                        grpc_slice_from_copied_string(host_arg))
-              : GRPC_MDNULL) {}
+RegisteredCall::RegisteredCall(const char* method_arg, const char* host_arg) {
+  path = Slice::FromCopiedString(method_arg);
+  if (host_arg != nullptr && host_arg[0] != 0) {
+    authority = Slice::FromCopiedString(host_arg);
+  }
+}
 
 RegisteredCall::RegisteredCall(const RegisteredCall& other)
-    : path(GRPC_MDELEM_REF(other.path)),
-      authority(GRPC_MDELEM_REF(other.authority)) {}
-
-RegisteredCall::~RegisteredCall() {
-  GRPC_MDELEM_UNREF(path);
-  GRPC_MDELEM_UNREF(authority);
+    : path(other.path.Ref()) {
+  if (other.authority.has_value()) {
+    authority = other.authority->Ref();
+  }
 }
 
+RegisteredCall::~RegisteredCall() {}
+
 }  // namespace grpc_core
 
 void* grpc_channel_register_call(grpc_channel* channel, const char* method,
@@ -470,7 +464,10 @@ grpc_call* grpc_channel_create_registered_call(
   grpc_core::ExecCtx exec_ctx;
   grpc_call* call = grpc_channel_create_call_internal(
       channel, parent_call, propagation_mask, completion_queue, nullptr,
-      GRPC_MDELEM_REF(rc->path), GRPC_MDELEM_REF(rc->authority),
+      rc->path.Ref(),
+      rc->authority.has_value()
+          ? absl::optional<grpc_core::Slice>(rc->authority->Ref())
+          : absl::nullopt,
       grpc_timespec_to_millis_round_up(deadline));
 
   return call;
@@ -486,7 +483,8 @@ static void destroy_channel(void* arg, grpc_error_handle /*error*/) {
   }
   grpc_channel_stack_destroy(CHANNEL_STACK_FROM_CHANNEL(channel));
   channel->registration_table.Destroy();
-  gpr_free(channel->target);
+  channel->allocator.Destroy();
+  channel->target.Destroy();
   gpr_free(channel);
   // See comment in grpc_channel_create() for why we do this.
   grpc_shutdown();

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

@@ -29,7 +29,6 @@
 #include "src/core/lib/gprpp/manual_constructor.h"
 #include "src/core/lib/resource_quota/memory_quota.h"
 #include "src/core/lib/surface/channel_stack_type.h"
-#include "src/core/lib/transport/metadata.h"
 
 /// Creates a grpc_channel.
 grpc_channel* grpc_channel_create(const char* target,
@@ -74,8 +73,8 @@ void grpc_channel_update_call_size_estimate(grpc_channel* channel, size_t size);
 namespace grpc_core {
 
 struct RegisteredCall {
-  grpc_mdelem path;
-  grpc_mdelem authority;
+  Slice path;
+  absl::optional<Slice> authority;
 
   explicit RegisteredCall(const char* method_arg, const char* host_arg);
   RegisteredCall(const RegisteredCall& other);
@@ -110,8 +109,9 @@ struct grpc_channel {
   grpc_core::ManualConstructor<grpc_core::CallRegistrationTable>
       registration_table;
   grpc_core::RefCountedPtr<grpc_core::channelz::ChannelNode> channelz_node;
+  grpc_core::ManualConstructor<grpc_core::MemoryAllocator> allocator;
 
-  char* target;
+  grpc_core::ManualConstructor<std::string> target;
 };
 #define CHANNEL_STACK_FROM_CHANNEL(c) ((grpc_channel_stack*)((c) + 1))
 

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

@@ -105,7 +105,6 @@ void grpc_init(void) {
     grpc_fork_handlers_auto_register();
     grpc_stats_init();
     grpc_slice_intern_init();
-    grpc_mdctx_global_init();
     grpc_core::channelz::ChannelzRegistry::Init();
     grpc_security_pre_init();
     grpc_core::ApplicationCallbackExecCtx::GlobalInit();
@@ -141,7 +140,6 @@ void grpc_shutdown_internal_locked(void)
     grpc_iomgr_shutdown();
     gpr_timers_global_destroy();
     grpc_tracer_shutdown();
-    grpc_mdctx_global_shutdown();
     grpc_slice_intern_shutdown();
     grpc_core::channelz::ChannelzRegistry::Shutdown();
     grpc_stats_shutdown();

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

@@ -35,7 +35,6 @@
 #include "src/core/lib/surface/call.h"
 #include "src/core/lib/surface/channel.h"
 #include "src/core/lib/transport/connectivity_state.h"
-#include "src/core/lib/transport/static_metadata.h"
 
 #define GRPC_ARG_LAME_FILTER_ERROR "grpc.lame_filter_error"
 

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

@@ -53,8 +53,6 @@
 #include "src/core/lib/surface/channel.h"
 #include "src/core/lib/surface/completion_queue.h"
 #include "src/core/lib/surface/init.h"
-#include "src/core/lib/transport/metadata.h"
-#include "src/core/lib/transport/static_metadata.h"
 
 namespace grpc_core {
 
@@ -1035,8 +1033,7 @@ void Server::ChannelData::InitTransport(RefCountedPtr<Server> server,
       if (has_host) {
         host = ExternallyManagedSlice(rm->host.c_str());
       }
-      uint32_t hash =
-          GRPC_MDSTR_KV_HASH(has_host ? host.Hash() : 0, method.Hash());
+      uint32_t hash = MixHash32(has_host ? host.Hash() : 0, method.Hash());
       uint32_t probes = 0;
       for (probes = 0; (*registered_methods_)[(hash + probes) % slots]
                            .server_registered_method != nullptr;
@@ -1080,8 +1077,8 @@ Server::ChannelRegisteredMethod* Server::ChannelData::GetRegisteredMethod(
   if (registered_methods_ == nullptr) return nullptr;
   /* TODO(ctiller): unify these two searches */
   /* check for an exact match with host */
-  uint32_t hash = GRPC_MDSTR_KV_HASH(grpc_slice_hash_internal(host),
-                                     grpc_slice_hash_internal(path));
+  uint32_t hash =
+      MixHash32(grpc_slice_hash_internal(host), grpc_slice_hash_internal(path));
   for (size_t i = 0; i <= registered_method_max_probes_; i++) {
     ChannelRegisteredMethod* rm =
         &(*registered_methods_)[(hash + i) % registered_methods_->size()];
@@ -1096,7 +1093,7 @@ Server::ChannelRegisteredMethod* Server::ChannelData::GetRegisteredMethod(
     return rm;
   }
   /* check for a wildcard method definition (no host set) */
-  hash = GRPC_MDSTR_KV_HASH(0, grpc_slice_hash_internal(path));
+  hash = MixHash32(0, grpc_slice_hash_internal(path));
   for (size_t i = 0; i <= registered_method_max_probes_; i++) {
     ChannelRegisteredMethod* rm =
         &(*registered_methods_)[(hash + i) % registered_methods_->size()];
@@ -1124,8 +1121,6 @@ void Server::ChannelData::AcceptStream(void* arg, grpc_transport* /*transport*/,
   args.cq = nullptr;
   args.pollset_set_alternative = nullptr;
   args.server_transport_data = transport_server_data;
-  args.add_initial_metadata = nullptr;
-  args.add_initial_metadata_count = 0;
   args.send_deadline = GRPC_MILLIS_INF_FUTURE;
   grpc_call* call;
   grpc_error_handle error = grpc_call_create(&args, &call);
@@ -1200,12 +1195,6 @@ Server::CallData::CallData(grpc_call_element* elem,
 Server::CallData::~CallData() {
   GPR_ASSERT(state_.load(std::memory_order_relaxed) != CallState::PENDING);
   GRPC_ERROR_UNREF(recv_initial_metadata_error_);
-  if (host_.has_value()) {
-    grpc_slice_unref_internal(*host_);
-  }
-  if (path_.has_value()) {
-    grpc_slice_unref_internal(*path_);
-  }
   grpc_metadata_array_destroy(&initial_metadata_);
   grpc_byte_buffer_destroy(payload_);
 }
@@ -1258,8 +1247,9 @@ void Server::CallData::Publish(size_t cq_idx, RequestedCall* rc) {
     case RequestedCall::Type::BATCH_CALL:
       GPR_ASSERT(host_.has_value());
       GPR_ASSERT(path_.has_value());
-      rc->data.batch.details->host = grpc_slice_ref_internal(*host_);
-      rc->data.batch.details->method = grpc_slice_ref_internal(*path_);
+      rc->data.batch.details->host = grpc_slice_ref_internal(host_->c_slice());
+      rc->data.batch.details->method =
+          grpc_slice_ref_internal(path_->c_slice());
       rc->data.batch.details->deadline =
           grpc_millis_to_timespec(deadline_, GPR_CLOCK_MONOTONIC);
       rc->data.batch.details->flags = recv_initial_metadata_flags_;
@@ -1320,7 +1310,7 @@ void Server::CallData::StartNewRpc(grpc_call_element* elem) {
       GRPC_SRM_PAYLOAD_NONE;
   if (path_.has_value() && host_.has_value()) {
     ChannelRegisteredMethod* rm =
-        chand->GetRegisteredMethod(*host_, *path_,
+        chand->GetRegisteredMethod(host_->c_slice(), path_->c_slice(),
                                    (recv_initial_metadata_flags_ &
                                     GRPC_INITIAL_METADATA_IDEMPOTENT_REQUEST));
     if (rm != nullptr) {
@@ -1352,6 +1342,8 @@ void Server::CallData::RecvInitialMetadataBatchComplete(
   grpc_call_element* elem = static_cast<grpc_call_element*>(arg);
   auto* calld = static_cast<Server::CallData*>(elem->call_data);
   if (error != GRPC_ERROR_NONE) {
+    gpr_log(GPR_DEBUG, "Failed call creation: %s",
+            grpc_error_std_string(error).c_str());
     calld->FailCallCreation();
     return;
   }
@@ -1385,17 +1377,8 @@ void Server::CallData::RecvInitialMetadataReady(void* arg,
   grpc_call_element* elem = static_cast<grpc_call_element*>(arg);
   CallData* calld = static_cast<CallData*>(elem->call_data);
   if (error == GRPC_ERROR_NONE) {
-    GPR_DEBUG_ASSERT(
-        calld->recv_initial_metadata_->legacy_index()->named.path != nullptr);
-    GPR_DEBUG_ASSERT(
-        calld->recv_initial_metadata_->legacy_index()->named.authority !=
-        nullptr);
-    calld->path_.emplace(grpc_slice_ref_internal(GRPC_MDVALUE(
-        calld->recv_initial_metadata_->legacy_index()->named.path->md)));
-    calld->host_.emplace(grpc_slice_ref_internal(GRPC_MDVALUE(
-        calld->recv_initial_metadata_->legacy_index()->named.authority->md)));
-    calld->recv_initial_metadata_->Remove(GRPC_BATCH_PATH);
-    calld->recv_initial_metadata_->Remove(GRPC_BATCH_AUTHORITY);
+    calld->path_ = calld->recv_initial_metadata_->Take(HttpPathMetadata());
+    calld->host_ = calld->recv_initial_metadata_->Take(HttpAuthorityMetadata());
   } else {
     (void)GRPC_ERROR_REF(error);
   }

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

@@ -293,8 +293,8 @@ class Server : public InternallyRefCounted<Server>,
 
     std::atomic<CallState> state_{CallState::NOT_STARTED};
 
-    absl::optional<grpc_slice> path_;
-    absl::optional<grpc_slice> host_;
+    absl::optional<Slice> path_;
+    absl::optional<Slice> host_;
     grpc_millis deadline_ = GRPC_MILLIS_INF_FUTURE;
 
     grpc_completion_queue* cq_new_ = nullptr;

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

@@ -23,6 +23,6 @@
 
 #include <grpc/grpc.h>
 
-const char* grpc_version_string(void) { return "21.0.0"; }
+const char* grpc_version_string(void) { return "22.0.0"; }
 
-const char* grpc_g_stands_for(void) { return "green"; }
+const char* grpc_g_stands_for(void) { return "great"; }

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

@@ -27,6 +27,20 @@
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/transport/http2_errors.h"
 
+namespace grpc_core {
+
+enum class StreamNetworkState {
+  // Stream was never sent on the wire (e.g., because the transport became
+  // disconnected by the time the call got down to it).
+  kNotSentOnWire,
+  // Stream was sent on the wire but was not seen by the server application
+  // code (e.g., client sent data but then received a GOAWAY with a lower
+  // stream ID).
+  kNotSeenByServer,
+};
+
+}  // namespace grpc_core
+
 /// A utility function to get the status code and message to be returned
 /// to the application.  If not set in the top-level message, looks
 /// through child errors until it finds the first one with these attributes.