grpc 1.63.0 → 1.66.0

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

@@ -16,11 +16,11 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/surface/legacy_channel.h"
 
 #include "absl/base/thread_annotations.h"
+#include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/types/optional.h"
 
@@ -28,18 +28,16 @@
 #include <grpc/grpc.h>
 #include <grpc/impl/connectivity_state.h>
 #include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 
+#include "src/core/channelz/channelz.h"
 #include "src/core/client_channel/client_channel_filter.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/channel/channel_stack_builder_impl.h"
-#include "src/core/lib/channel/channelz.h"
-#include "src/core/lib/channel/metrics.h"
 #include "src/core/lib/config/core_configuration.h"
-#include "src/core/lib/debug/stats.h"
-#include "src/core/lib/debug/stats_data.h"
+#include "src/core/lib/event_engine/channel_args_endpoint_config.h"
 #include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/gprpp/dual_ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
@@ -57,10 +55,13 @@
 #include "src/core/lib/surface/init_internally.h"
 #include "src/core/lib/surface/lame_client.h"
 #include "src/core/lib/transport/transport.h"
+#include "src/core/telemetry/metrics.h"
+#include "src/core/telemetry/stats.h"
+#include "src/core/telemetry/stats_data.h"
 
 namespace grpc_core {
 
-absl::StatusOr<OrphanablePtr<Channel>> LegacyChannel::Create(
+absl::StatusOr<RefCountedPtr<Channel>> LegacyChannel::Create(
     std::string target, ChannelArgs args,
     grpc_channel_stack_type channel_stack_type) {
   if (grpc_channel_stack_type_is_client(channel_stack_type)) {
@@ -85,38 +86,55 @@ absl::StatusOr<OrphanablePtr<Channel>> LegacyChannel::Create(
   absl::StatusOr<RefCountedPtr<grpc_channel_stack>> r = builder.Build();
   if (!r.ok()) {
     auto status = r.status();
-    gpr_log(GPR_ERROR, "channel stack builder failed: %s",
-            status.ToString().c_str());
+    LOG(ERROR) << "channel stack builder failed: " << status;
     return status;
   }
   if (channel_stack_type == GRPC_SERVER_CHANNEL) {
     *(*r)->stats_plugin_group =
         GlobalStatsPluginRegistry::GetStatsPluginsForServer(args);
+    // Add per-server stats plugins.
+    auto* stats_plugin_list = args.GetPointer<
+        std::shared_ptr<std::vector<std::shared_ptr<StatsPlugin>>>>(
+        GRPC_ARG_EXPERIMENTAL_STATS_PLUGINS);
+    if (stats_plugin_list != nullptr) {
+      for (const auto& plugin : **stats_plugin_list) {
+        (*r)->stats_plugin_group->AddStatsPlugin(
+            plugin, plugin->GetServerScopeConfig(args));
+      }
+    }
   } else {
-    experimental::StatsPluginChannelScope scope(
-        target, args.GetOwnedString(GRPC_ARG_DEFAULT_AUTHORITY)
-                    .value_or(CoreConfiguration::Get()
-                                  .resolver_registry()
-                                  .GetDefaultAuthority(target)));
+    std::string authority = args.GetOwnedString(GRPC_ARG_DEFAULT_AUTHORITY)
+                                .value_or(CoreConfiguration::Get()
+                                              .resolver_registry()
+                                              .GetDefaultAuthority(target));
+    grpc_event_engine::experimental::ChannelArgsEndpointConfig endpoint_config(
+        args);
+    experimental::StatsPluginChannelScope scope(target, authority,
+                                                endpoint_config);
     *(*r)->stats_plugin_group =
         GlobalStatsPluginRegistry::GetStatsPluginsForChannel(scope);
+    // Add per-channel stats plugins.
+    auto* stats_plugin_list = args.GetPointer<
+        std::shared_ptr<std::vector<std::shared_ptr<StatsPlugin>>>>(
+        GRPC_ARG_EXPERIMENTAL_STATS_PLUGINS);
+    if (stats_plugin_list != nullptr) {
+      for (const auto& plugin : **stats_plugin_list) {
+        (*r)->stats_plugin_group->AddStatsPlugin(
+            plugin, plugin->GetChannelScopeConfig(scope));
+      }
+    }
   }
-  return MakeOrphanable<LegacyChannel>(
+  return MakeRefCounted<LegacyChannel>(
       grpc_channel_stack_type_is_client(builder.channel_stack_type()),
-      builder.IsPromising(), std::move(target), args, std::move(*r));
+      std::move(target), args, std::move(*r));
 }
 
-LegacyChannel::LegacyChannel(bool is_client, bool is_promising,
-                             std::string target,
+LegacyChannel::LegacyChannel(bool is_client, std::string target,
                              const ChannelArgs& channel_args,
                              RefCountedPtr<grpc_channel_stack> channel_stack)
     : Channel(std::move(target), channel_args),
       is_client_(is_client),
-      is_promising_(is_promising),
-      channel_stack_(std::move(channel_stack)),
-      allocator_(channel_args.GetObject<ResourceQuota>()
-                     ->memory_quota()
-                     ->CreateMemoryOwner()) {
+      channel_stack_(std::move(channel_stack)) {
   // We need to make sure that grpc_shutdown() does not shut things down
   // until after the channel is destroyed.  However, the channel may not
   // actually be destroyed by the time grpc_channel_destroy() returns,
@@ -147,13 +165,12 @@ LegacyChannel::LegacyChannel(bool is_client, bool is_promising,
   };
 }
 
-void LegacyChannel::Orphan() {
+void LegacyChannel::Orphaned() {
   grpc_transport_op* op = grpc_make_transport_op(nullptr);
   op->disconnect_with_error = GRPC_ERROR_CREATE("Channel Destroyed");
   grpc_channel_element* elem =
       grpc_channel_stack_element(channel_stack_.get(), 0);
   elem->filter->start_transport_op(elem, op);
-  Unref();
 }
 
 bool LegacyChannel::IsLame() const {
@@ -167,10 +184,10 @@ grpc_call* LegacyChannel::CreateCall(
     grpc_completion_queue* cq, grpc_pollset_set* pollset_set_alternative,
     Slice path, absl::optional<Slice> authority, Timestamp deadline,
     bool registered_method) {
-  GPR_ASSERT(is_client_);
-  GPR_ASSERT(!(cq != nullptr && pollset_set_alternative != nullptr));
+  CHECK(is_client_);
+  CHECK(!(cq != nullptr && pollset_set_alternative != nullptr));
   grpc_call_create_args args;
-  args.channel = Ref();
+  args.channel = RefAsSubclass<LegacyChannel>();
   args.server = nullptr;
   args.parent = parent_call;
   args.propagation_mask = propagation_mask;
@@ -192,9 +209,8 @@ grpc_connectivity_state LegacyChannel::CheckConnectivityState(
   ClientChannelFilter* client_channel = GetClientChannelFilter();
   if (GPR_UNLIKELY(client_channel == nullptr)) {
     if (IsLame()) return GRPC_CHANNEL_TRANSIENT_FAILURE;
-    gpr_log(GPR_ERROR,
-            "grpc_channel_check_connectivity_state called on something that is "
-            "not a client channel");
+    LOG(ERROR) << "grpc_channel_check_connectivity_state called on something "
+                  "that is not a client channel";
     return GRPC_CHANNEL_SHUTDOWN;
   }
   return client_channel->CheckConnectivityState(try_to_connect);
@@ -207,14 +223,14 @@ bool LegacyChannel::SupportsConnectivityWatcher() const {
 // A fire-and-forget object to handle external connectivity state watches.
 class LegacyChannel::StateWatcher final : public DualRefCounted<StateWatcher> {
  public:
-  StateWatcher(RefCountedPtr<LegacyChannel> channel, grpc_completion_queue* cq,
-               void* tag, grpc_connectivity_state last_observed_state,
-               Timestamp deadline)
+  StateWatcher(WeakRefCountedPtr<LegacyChannel> channel,
+               grpc_completion_queue* cq, void* tag,
+               grpc_connectivity_state last_observed_state, Timestamp deadline)
       : channel_(std::move(channel)),
         cq_(cq),
         tag_(tag),
         state_(last_observed_state) {
-    GPR_ASSERT(grpc_cq_begin_op(cq, tag));
+    CHECK(grpc_cq_begin_op(cq, tag));
     GRPC_CLOSURE_INIT(&on_complete_, WatchComplete, this, nullptr);
     ClientChannelFilter* client_channel = channel_->GetClientChannelFilter();
     if (client_channel == nullptr) {
@@ -290,7 +306,7 @@ class LegacyChannel::StateWatcher final : public DualRefCounted<StateWatcher> {
 
   static void WatchComplete(void* arg, grpc_error_handle error) {
     RefCountedPtr<StateWatcher> self(static_cast<StateWatcher*>(arg));
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_operation_failures)) {
+    if (GRPC_TRACE_FLAG_ENABLED(op_failure)) {
       GRPC_LOG_IF_ERROR("watch_completion_error", error);
     }
     MutexLock lock(&self->mu_);
@@ -316,7 +332,7 @@ class LegacyChannel::StateWatcher final : public DualRefCounted<StateWatcher> {
     self->WeakUnref();
   }
 
-  RefCountedPtr<LegacyChannel> channel_;
+  WeakRefCountedPtr<LegacyChannel> channel_;
   grpc_completion_queue* cq_;
   void* tag_;
 
@@ -336,22 +352,22 @@ class LegacyChannel::StateWatcher final : public DualRefCounted<StateWatcher> {
 void LegacyChannel::WatchConnectivityState(
     grpc_connectivity_state last_observed_state, Timestamp deadline,
     grpc_completion_queue* cq, void* tag) {
-  new StateWatcher(RefAsSubclass<LegacyChannel>(), cq, tag, last_observed_state,
-                   deadline);
+  new StateWatcher(WeakRefAsSubclass<LegacyChannel>(), cq, tag,
+                   last_observed_state, deadline);
 }
 
 void LegacyChannel::AddConnectivityWatcher(
     grpc_connectivity_state initial_state,
     OrphanablePtr<AsyncConnectivityStateWatcherInterface> watcher) {
   auto* client_channel = GetClientChannelFilter();
-  GPR_ASSERT(client_channel != nullptr);
+  CHECK_NE(client_channel, nullptr);
   client_channel->AddConnectivityWatcher(initial_state, std::move(watcher));
 }
 
 void LegacyChannel::RemoveConnectivityWatcher(
     AsyncConnectivityStateWatcherInterface* watcher) {
   auto* client_channel = GetClientChannelFilter();
-  GPR_ASSERT(client_channel != nullptr);
+  CHECK_NE(client_channel, nullptr);
   client_channel->RemoveConnectivityWatcher(watcher);
 }
 
@@ -395,7 +411,7 @@ void LegacyChannel::Ping(grpc_completion_queue* cq, void* tag) {
   grpc_transport_op* op = grpc_make_transport_op(nullptr);
   op->send_ping.on_ack = &pr->closure;
   op->bind_pollset = grpc_cq_pollset(cq);
-  GPR_ASSERT(grpc_cq_begin_op(cq, tag));
+  CHECK(grpc_cq_begin_op(cq, tag));
   grpc_channel_element* top_elem =
       grpc_channel_stack_element(channel_stack_.get(), 0);
   top_elem->filter->start_transport_op(top_elem, op);
@@ -404,8 +420,7 @@ void LegacyChannel::Ping(grpc_completion_queue* cq, void* tag) {
 ClientChannelFilter* LegacyChannel::GetClientChannelFilter() const {
   grpc_channel_element* elem =
       grpc_channel_stack_last_element(channel_stack_.get());
-  if (elem->filter != &ClientChannelFilter::kFilterVtableWithPromises &&
-      elem->filter != &ClientChannelFilter::kFilterVtableWithoutPromises) {
+  if (elem->filter != &ClientChannelFilter::kFilter) {
     return nullptr;
   }
   return static_cast<ClientChannelFilter*>(elem->channel_data);

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

@@ -19,8 +19,6 @@
 #ifndef GRPC_SRC_CORE_LIB_SURFACE_LEGACY_CHANNEL_H
 #define GRPC_SRC_CORE_LIB_SURFACE_LEGACY_CHANNEL_H
 
-#include <grpc/support/port_platform.h>
-
 #include <string>
 
 #include "absl/status/statusor.h"
@@ -28,44 +26,36 @@
 
 #include <grpc/event_engine/event_engine.h>
 #include <grpc/grpc.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/client_channel/client_channel_filter.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/channel_stack.h"  // IWYU pragma: keep
-#include "src/core/lib/debug/stats.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/iomgr/iomgr_fwd.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/surface/channel.h"
 #include "src/core/lib/surface/channel_stack_type.h"
-#include "src/core/lib/transport/call_size_estimator.h"
+#include "src/core/lib/transport/call_arena_allocator.h"
+#include "src/core/lib/transport/transport.h"
+#include "src/core/telemetry/stats.h"
 
 namespace grpc_core {
 
 class LegacyChannel final : public Channel {
  public:
-  static absl::StatusOr<OrphanablePtr<Channel>> Create(
+  static absl::StatusOr<RefCountedPtr<Channel>> Create(
       std::string target, ChannelArgs args,
       grpc_channel_stack_type channel_stack_type);
 
   // Do not instantiate directly -- use Create() instead.
-  LegacyChannel(bool is_client, bool is_promising, std::string target,
+  LegacyChannel(bool is_client, std::string target,
                 const ChannelArgs& channel_args,
                 RefCountedPtr<grpc_channel_stack> channel_stack);
 
-  void Orphan() override;
-
-  Arena* CreateArena() override {
-    const size_t initial_size = call_size_estimator_.CallSizeEstimate();
-    global_stats().IncrementCallInitialSize(initial_size);
-    return Arena::Create(initial_size, &allocator_);
-  }
-  void DestroyArena(Arena* arena) override {
-    call_size_estimator_.UpdateCallSizeEstimate(arena->TotalUsedBytes());
-    arena->Destroy();
-  }
+  void Orphaned() override;
 
   bool IsLame() const override;
 
@@ -75,6 +65,10 @@ class LegacyChannel final : public Channel {
                         absl::optional<Slice> authority, Timestamp deadline,
                         bool registered_method) override;
 
+  void StartCall(UnstartedCallHandler) override {
+    Crash("StartCall() not supported on LegacyChannel");
+  }
+
   grpc_event_engine::experimental::EventEngine* event_engine() const override {
     return channel_stack_->EventEngine();
   }
@@ -100,7 +94,6 @@ class LegacyChannel final : public Channel {
   void Ping(grpc_completion_queue* cq, void* tag) override;
 
   bool is_client() const override { return is_client_; }
-  bool is_promising() const override { return is_promising_; }
   grpc_channel_stack* channel_stack() const override {
     return channel_stack_.get();
   }
@@ -113,10 +106,7 @@ class LegacyChannel final : public Channel {
   ClientChannelFilter* GetClientChannelFilter() const;
 
   const bool is_client_;
-  const bool is_promising_;
   RefCountedPtr<grpc_channel_stack> channel_stack_;
-  CallSizeEstimator call_size_estimator_{1024};
-  grpc_event_engine::experimental::MemoryAllocator allocator_;
 };
 
 }  // namespace grpc_core

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

@@ -16,22 +16,22 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
 #include <string.h>
 
 #include <grpc/grpc.h>
 #include <grpc/support/alloc.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/debug/trace.h"
-#include "src/core/lib/surface/api_trace.h"
 
 void grpc_metadata_array_init(grpc_metadata_array* array) {
-  GRPC_API_TRACE("grpc_metadata_array_init(array=%p)", 1, (array));
+  GRPC_TRACE_LOG(api, INFO)
+      << "grpc_metadata_array_init(array=" << array << ")";
   memset(array, 0, sizeof(*array));
 }
 
 void grpc_metadata_array_destroy(grpc_metadata_array* array) {
-  GRPC_API_TRACE("grpc_metadata_array_destroy(array=%p)", 1, (array));
+  GRPC_TRACE_LOG(api, INFO)
+      << "grpc_metadata_array_destroy(array=" << array << ")";
   gpr_free(array->metadata);
 }

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

@@ -0,0 +1,224 @@
+// Copyright 2024 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.
+
+#include "src/core/lib/surface/server_call.h"
+
+#include <inttypes.h>
+#include <limits.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <memory>
+#include <string>
+#include <utility>
+
+#include "absl/log/check.h"
+#include "absl/strings/string_view.h"
+
+#include <grpc/byte_buffer.h>
+#include <grpc/compression.h>
+#include <grpc/event_engine/event_engine.h>
+#include <grpc/grpc.h>
+#include <grpc/impl/call.h>
+#include <grpc/impl/propagation_bits.h>
+#include <grpc/slice.h>
+#include <grpc/slice_buffer.h>
+#include <grpc/status.h>
+#include <grpc/support/alloc.h>
+#include <grpc/support/atm.h>
+#include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
+#include <grpc/support/string_util.h>
+
+#include "src/core/lib/gprpp/bitset.h"
+#include "src/core/lib/promise/all_ok.h"
+#include "src/core/lib/promise/map.h"
+#include "src/core/lib/promise/poll.h"
+#include "src/core/lib/promise/status_flag.h"
+#include "src/core/lib/promise/try_seq.h"
+#include "src/core/lib/resource_quota/arena.h"
+#include "src/core/lib/slice/slice_buffer.h"
+#include "src/core/lib/surface/completion_queue.h"
+#include "src/core/lib/transport/metadata.h"
+#include "src/core/lib/transport/metadata_batch.h"
+#include "src/core/server/server_interface.h"
+
+namespace grpc_core {
+
+namespace {
+
+grpc_call_error ValidateServerBatch(const grpc_op* ops, size_t nops) {
+  BitSet<8> got_ops;
+  for (size_t op_idx = 0; op_idx < nops; op_idx++) {
+    const grpc_op& op = ops[op_idx];
+    switch (op.op) {
+      case GRPC_OP_SEND_INITIAL_METADATA:
+        if (!AreInitialMetadataFlagsValid(op.flags)) {
+          return GRPC_CALL_ERROR_INVALID_FLAGS;
+        }
+        if (!ValidateMetadata(op.data.send_initial_metadata.count,
+                              op.data.send_initial_metadata.metadata)) {
+          return GRPC_CALL_ERROR_INVALID_METADATA;
+        }
+        break;
+      case GRPC_OP_SEND_MESSAGE:
+        if (!AreWriteFlagsValid(op.flags)) {
+          return GRPC_CALL_ERROR_INVALID_FLAGS;
+        }
+        break;
+      case GRPC_OP_SEND_STATUS_FROM_SERVER:
+        if (op.flags != 0) return GRPC_CALL_ERROR_INVALID_FLAGS;
+        if (!ValidateMetadata(
+                op.data.send_status_from_server.trailing_metadata_count,
+                op.data.send_status_from_server.trailing_metadata)) {
+          return GRPC_CALL_ERROR_INVALID_METADATA;
+        }
+        break;
+      case GRPC_OP_RECV_MESSAGE:
+      case GRPC_OP_RECV_CLOSE_ON_SERVER:
+        if (op.flags != 0) return GRPC_CALL_ERROR_INVALID_FLAGS;
+        break;
+      case GRPC_OP_RECV_INITIAL_METADATA:
+      case GRPC_OP_SEND_CLOSE_FROM_CLIENT:
+      case GRPC_OP_RECV_STATUS_ON_CLIENT:
+        return GRPC_CALL_ERROR_NOT_ON_SERVER;
+    }
+    if (got_ops.is_set(op.op)) return GRPC_CALL_ERROR_TOO_MANY_OPERATIONS;
+    got_ops.set(op.op);
+  }
+  return GRPC_CALL_OK;
+}
+
+}  // namespace
+
+grpc_call_error ServerCall::StartBatch(const grpc_op* ops, size_t nops,
+                                       void* notify_tag,
+                                       bool is_notify_tag_closure) {
+  if (nops == 0) {
+    EndOpImmediately(cq_, notify_tag, is_notify_tag_closure);
+    return GRPC_CALL_OK;
+  }
+  const grpc_call_error validation_result = ValidateServerBatch(ops, nops);
+  if (validation_result != GRPC_CALL_OK) {
+    return validation_result;
+  }
+  CommitBatch(ops, nops, notify_tag, is_notify_tag_closure);
+  return GRPC_CALL_OK;
+}
+
+void ServerCall::CommitBatch(const grpc_op* ops, size_t nops, void* notify_tag,
+                             bool is_notify_tag_closure) {
+  BatchOpIndex op_index(ops, nops);
+  if (!is_notify_tag_closure) grpc_cq_begin_op(cq_, notify_tag);
+  auto send_initial_metadata =
+      op_index.OpHandler<GRPC_OP_SEND_INITIAL_METADATA>([this](
+                                                            const grpc_op& op) {
+        auto metadata = arena()->MakePooled<ServerMetadata>();
+        PrepareOutgoingInitialMetadata(op, *metadata);
+        CToMetadata(op.data.send_initial_metadata.metadata,
+                    op.data.send_initial_metadata.count, metadata.get());
+        GRPC_TRACE_LOG(call, INFO)
+            << DebugTag() << "[call] Send initial metadata";
+        return [this, metadata = std::move(metadata)]() mutable {
+          return call_handler_.PushServerInitialMetadata(std::move(metadata));
+        };
+      });
+  auto send_message =
+      op_index.OpHandler<GRPC_OP_SEND_MESSAGE>([this](const grpc_op& op) {
+        SliceBuffer send;
+        grpc_slice_buffer_swap(
+            &op.data.send_message.send_message->data.raw.slice_buffer,
+            send.c_slice_buffer());
+        auto msg = arena()->MakePooled<Message>(std::move(send), op.flags);
+        return [this, msg = std::move(msg)]() mutable {
+          return call_handler_.PushMessage(std::move(msg));
+        };
+      });
+  auto send_trailing_metadata =
+      op_index.OpHandler<GRPC_OP_SEND_STATUS_FROM_SERVER>(
+          [this](const grpc_op& op) {
+            auto metadata = arena()->MakePooled<ServerMetadata>();
+            CToMetadata(op.data.send_status_from_server.trailing_metadata,
+                        op.data.send_status_from_server.trailing_metadata_count,
+                        metadata.get());
+            metadata->Set(GrpcStatusMetadata(),
+                          op.data.send_status_from_server.status);
+            if (auto* details =
+                    op.data.send_status_from_server.status_details) {
+              // TODO(ctiller): this should not be a copy, but we have
+              // callers that allocate and pass in a slice created with
+              // grpc_slice_from_static_string and then delete the string
+              // after passing it in, which shouldn't be a supported API.
+              metadata->Set(GrpcMessageMetadata(),
+                            Slice(grpc_slice_copy(*details)));
+            }
+            CHECK(metadata != nullptr);
+            return [this, metadata = std::move(metadata)]() mutable {
+              CHECK(metadata != nullptr);
+              return [this, metadata = std::move(
+                                metadata)]() mutable -> Poll<Success> {
+                CHECK(metadata != nullptr);
+                call_handler_.PushServerTrailingMetadata(std::move(metadata));
+                return Success{};
+              };
+            };
+          });
+  auto recv_message =
+      op_index.OpHandler<GRPC_OP_RECV_MESSAGE>([this](const grpc_op& op) {
+        return message_receiver_.MakeBatchOp(op, &call_handler_);
+      });
+  auto primary_ops = AllOk<StatusFlag>(
+      TrySeq(AllOk<StatusFlag>(std::move(send_initial_metadata),
+                               std::move(send_message)),
+             std::move(send_trailing_metadata)),
+      std::move(recv_message));
+  if (auto* op = op_index.op(GRPC_OP_RECV_CLOSE_ON_SERVER)) {
+    auto recv_trailing_metadata = OpHandler<GRPC_OP_RECV_CLOSE_ON_SERVER>(
+        [this, cancelled = op->data.recv_close_on_server.cancelled]() {
+          return Map(call_handler_.WasCancelled(),
+                     [cancelled, this](bool result) -> Success {
+                       saw_was_cancelled_.store(true,
+                                                std::memory_order_relaxed);
+                       ResetDeadline();
+                       *cancelled = result ? 1 : 0;
+                       return Success{};
+                     });
+        });
+    call_handler_.SpawnInfallible(
+        "final-batch", InfallibleBatch(std::move(primary_ops),
+                                       std::move(recv_trailing_metadata),
+                                       is_notify_tag_closure, notify_tag, cq_));
+  } else {
+    call_handler_.SpawnInfallible(
+        "batch", FallibleBatch(std::move(primary_ops), is_notify_tag_closure,
+                               notify_tag, cq_));
+  }
+}
+
+grpc_call* MakeServerCall(CallHandler call_handler,
+                          ClientMetadataHandle client_initial_metadata,
+                          ServerInterface* server, grpc_completion_queue* cq,
+                          grpc_metadata_array* publish_initial_metadata) {
+  PublishMetadataArray(client_initial_metadata.get(), publish_initial_metadata,
+                       false);
+  // TODO(ctiller): ideally we'd put this in the arena with the CallHandler,
+  // but there's an ownership problem: CallHandler owns the arena, and so would
+  // get destroyed before the base class Call destructor runs, leading to
+  // UB/crash. Investigate another path.
+  return (new ServerCall(std::move(client_initial_metadata),
+                         std::move(call_handler), server, cq))
+      ->c_ptr();
+}
+
+}  // namespace grpc_core