grpc 1.62.0 → 1.64.0.pre1

data/src/core/{lib/surface → server}/server.cc

@@ -14,9 +14,7 @@
 // limitations under the License.
 //
 
-#include <grpc/support/port_platform.h>
-
-#include "src/core/lib/surface/server.h"
+#include "src/core/server/server.h"
 
 #include <inttypes.h>
 #include <stdlib.h>
@@ -34,6 +32,7 @@
 
 #include "absl/cleanup/cleanup.h"
 #include "absl/container/flat_hash_map.h"
+#include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "absl/types/optional.h"
 
@@ -44,12 +43,13 @@
 #include <grpc/slice.h>
 #include <grpc/status.h>
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 #include <grpc/support/time.h>
 
+#include "src/core/channelz/channel_trace.h"
+#include "src/core/channelz/channelz.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_args_preconditioning.h"
-#include "src/core/lib/channel/channel_trace.h"
-#include "src/core/lib/channel/channelz.h"
 #include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/debug/stats.h"
 #include "src/core/lib/experiments/experiments.h"
@@ -77,6 +77,7 @@
 #include "src/core/lib/surface/channel.h"
 #include "src/core/lib/surface/channel_stack_type.h"
 #include "src/core/lib/surface/completion_queue.h"
+#include "src/core/lib/surface/legacy_channel.h"
 #include "src/core/lib/surface/wait_for_cq_end_op.h"
 #include "src/core/lib/transport/connectivity_state.h"
 #include "src/core/lib/transport/error_utils.h"
@@ -232,11 +233,12 @@ struct Server::RequestedCall {
     data.registered.optional_payload = optional_payload;
   }
 
-  void Complete(NextResult<MessageHandle> payload, ClientMetadata& md) {
-    Timestamp deadline = GetContext<CallContext>()->deadline();
+  template <typename OptionalPayload>
+  void Complete(OptionalPayload payload, ClientMetadata& md) {
+    Timestamp deadline = GetContext<Call>()->deadline();
     switch (type) {
       case RequestedCall::Type::BATCH_CALL:
-        GPR_ASSERT(!payload.has_value());
+        CHECK(!payload.has_value());
         data.batch.details->host =
             CSliceRef(md.get_pointer(HttpAuthorityMetadata())->c_slice());
         data.batch.details->method =
@@ -293,9 +295,9 @@ class Server::RealRequestMatcherFilterStack : public RequestMatcherInterface {
 
   ~RealRequestMatcherFilterStack() override {
     for (LockedMultiProducerSingleConsumerQueue& queue : requests_per_cq_) {
-      GPR_ASSERT(queue.Pop() == nullptr);
+      CHECK_EQ(queue.Pop(), nullptr);
     }
-    GPR_ASSERT(pending_.empty());
+    CHECK(pending_.empty());
   }
 
   void ZombifyPending() override {
@@ -425,7 +427,7 @@ class Server::RealRequestMatcherPromises : public RequestMatcherInterface {
 
   ~RealRequestMatcherPromises() override {
     for (LockedMultiProducerSingleConsumerQueue& queue : requests_per_cq_) {
-      GPR_ASSERT(queue.Pop() == nullptr);
+      CHECK_EQ(queue.Pop(), nullptr);
     }
   }
 
@@ -562,7 +564,7 @@ class Server::RealRequestMatcherPromises : public RequestMatcherInterface {
       if (!result.compare_exchange_strong(expected, new_value,
                                           std::memory_order_acq_rel,
                                           std::memory_order_acquire)) {
-        GPR_ASSERT(new_value->value().TakeCall() == requested_call);
+        CHECK(new_value->value().TakeCall() == requested_call);
         delete new_value;
         return false;
       }
@@ -599,7 +601,7 @@ class Server::AllocatingRequestMatcherBase : public RequestMatcherInterface {
         break;
       }
     }
-    GPR_ASSERT(idx < server->cqs_.size());
+    CHECK(idx < server->cqs_.size());
     cq_idx_ = idx;
   }
 
@@ -645,9 +647,9 @@ class Server::AllocatingRequestMatcherBatch
         absl::MakeCleanup([this] { server()->ShutdownUnrefOnRequest(); });
     if (still_running) {
       BatchCallAllocation call_info = allocator_();
-      GPR_ASSERT(server()->ValidateServerRequest(
-                     cq(), static_cast<void*>(call_info.tag), nullptr,
-                     nullptr) == GRPC_CALL_OK);
+      CHECK(server()->ValidateServerRequest(cq(),
+                                            static_cast<void*>(call_info.tag),
+                                            nullptr, nullptr) == GRPC_CALL_OK);
       RequestedCall* rc = new RequestedCall(
           static_cast<void*>(call_info.tag), call_info.cq, call_info.call,
           call_info.initial_metadata, call_info.details);
@@ -661,9 +663,9 @@ class Server::AllocatingRequestMatcherBatch
   ArenaPromise<absl::StatusOr<MatchResult>> MatchRequest(
       size_t /*start_request_queue_index*/) override {
     BatchCallAllocation call_info = allocator_();
-    GPR_ASSERT(server()->ValidateServerRequest(
-                   cq(), static_cast<void*>(call_info.tag), nullptr, nullptr) ==
-               GRPC_CALL_OK);
+    CHECK(server()->ValidateServerRequest(cq(),
+                                          static_cast<void*>(call_info.tag),
+                                          nullptr, nullptr) == GRPC_CALL_OK);
     RequestedCall* rc = new RequestedCall(
         static_cast<void*>(call_info.tag), call_info.cq, call_info.call,
         call_info.initial_metadata, call_info.details);
@@ -691,9 +693,9 @@ class Server::AllocatingRequestMatcherRegistered
         absl::MakeCleanup([this] { server()->ShutdownUnrefOnRequest(); });
     if (server()->ShutdownRefOnRequest()) {
       RegisteredCallAllocation call_info = allocator_();
-      GPR_ASSERT(server()->ValidateServerRequest(
-                     cq(), call_info.tag, call_info.optional_payload,
-                     registered_method_) == GRPC_CALL_OK);
+      CHECK(server()->ValidateServerRequest(
+                cq(), call_info.tag, call_info.optional_payload,
+                registered_method_) == GRPC_CALL_OK);
       RequestedCall* rc =
           new RequestedCall(call_info.tag, call_info.cq, call_info.call,
                             call_info.initial_metadata, registered_method_,
@@ -708,9 +710,9 @@ class Server::AllocatingRequestMatcherRegistered
   ArenaPromise<absl::StatusOr<MatchResult>> MatchRequest(
       size_t /*start_request_queue_index*/) override {
     RegisteredCallAllocation call_info = allocator_();
-    GPR_ASSERT(server()->ValidateServerRequest(
-                   cq(), call_info.tag, call_info.optional_payload,
-                   registered_method_) == GRPC_CALL_OK);
+    CHECK(server()->ValidateServerRequest(cq(), call_info.tag,
+                                          call_info.optional_payload,
+                                          registered_method_) == GRPC_CALL_OK);
     RequestedCall* rc = new RequestedCall(
         call_info.tag, call_info.cq, call_info.call, call_info.initial_metadata,
         registered_method_, call_info.deadline, call_info.optional_payload);
@@ -735,14 +737,14 @@ class ChannelBroadcaster {
 
   // Copies over the channels from the locked server.
   void FillChannelsLocked(std::vector<RefCountedPtr<Channel>> channels) {
-    GPR_DEBUG_ASSERT(channels_.empty());
+    DCHECK(channels_.empty());
     channels_ = std::move(channels);
   }
 
   // Broadcasts a shutdown on each channel.
   void BroadcastShutdown(bool send_goaway, grpc_error_handle force_disconnect) {
     for (const RefCountedPtr<Channel>& channel : channels_) {
-      SendShutdown(channel->c_ptr(), send_goaway, force_disconnect);
+      SendShutdown(channel.get(), send_goaway, force_disconnect);
     }
     channels_.clear();  // just for safety against double broadcast
   }
@@ -759,7 +761,7 @@ class ChannelBroadcaster {
     delete a;
   }
 
-  static void SendShutdown(grpc_channel* channel, bool send_goaway,
+  static void SendShutdown(Channel* channel, bool send_goaway,
                            grpc_error_handle send_disconnect) {
     ShutdownCleanupArgs* sc = new ShutdownCleanupArgs;
     GRPC_CLOSURE_INIT(&sc->closure, ShutdownCleanup, sc,
@@ -773,8 +775,7 @@ class ChannelBroadcaster {
             : absl::OkStatus();
     sc->slice = grpc_slice_from_copied_string("Server shutdown");
     op->disconnect_with_error = send_disconnect;
-    elem =
-        grpc_channel_stack_element(grpc_channel_get_channel_stack(channel), 0);
+    elem = grpc_channel_stack_element(channel->channel_stack(), 0);
     elem->filter->start_transport_op(elem, op);
   }
 
@@ -911,8 +912,9 @@ grpc_error_handle Server::SetupTransport(
     const ChannelArgs& args,
     const RefCountedPtr<channelz::SocketNode>& socket_node) {
   // Create channel.
-  absl::StatusOr<RefCountedPtr<Channel>> channel =
-      Channel::Create(nullptr, args, GRPC_SERVER_CHANNEL, transport);
+  global_stats().IncrementServerChannelsCreated();
+  absl::StatusOr<OrphanablePtr<Channel>> channel =
+      LegacyChannel::Create("", args.SetObject(transport), GRPC_SERVER_CHANNEL);
   if (!channel.ok()) {
     return absl_status_to_grpc_error(channel.status());
   }
@@ -954,7 +956,7 @@ void Server::SetRegisteredMethodAllocator(
 
 void Server::SetBatchMethodAllocator(
     grpc_completion_queue* cq, std::function<BatchCallAllocation()> allocator) {
-  GPR_DEBUG_ASSERT(unregistered_request_matcher_ == nullptr);
+  DCHECK(unregistered_request_matcher_ == nullptr);
   unregistered_request_matcher_ =
       std::make_unique<AllocatingRequestMatcherBatch>(this, cq,
                                                       std::move(allocator));
@@ -1006,7 +1008,7 @@ void Server::FailCall(size_t cq_idx, RequestedCall* rc,
                       grpc_error_handle error) {
   *rc->call = nullptr;
   rc->initial_metadata->count = 0;
-  GPR_ASSERT(!error.ok());
+  CHECK(!error.ok());
   grpc_cq_end_op(cqs_[cq_idx], rc->tag, error, DoneRequestEvent, rc,
                  &rc->completion);
 }
@@ -1100,7 +1102,7 @@ void Server::ShutdownAndNotify(grpc_completion_queue* cq, void* tag) {
       starting_cv_.Wait(&mu_global_);
     }
     // Stay locked, and gather up some stuff to do.
-    GPR_ASSERT(grpc_cq_begin_op(cq, tag));
+    CHECK(grpc_cq_begin_op(cq, tag));
     if (shutdown_published_) {
       grpc_cq_end_op(cq, tag, absl::OkStatus(), DonePublishedShutdown, nullptr,
                      new grpc_cq_completion);
@@ -1161,8 +1163,8 @@ void Server::SendGoaways() {
 void Server::Orphan() {
   {
     MutexLock lock(&mu_global_);
-    GPR_ASSERT(ShutdownCalled() || listeners_.empty());
-    GPR_ASSERT(listeners_destroyed_ == listeners_.size());
+    CHECK(ShutdownCalled() || listeners_.empty());
+    CHECK(listeners_destroyed_ == listeners_.size());
   }
   Unref();
 }
@@ -1301,19 +1303,20 @@ Server::ChannelData::~ChannelData() {
 Arena* Server::ChannelData::CreateArena() { return channel_->CreateArena(); }
 
 absl::StatusOr<CallInitiator> Server::ChannelData::CreateCall(
-    ClientMetadata& client_initial_metadata, Arena* arena) {
-  SetRegisteredMethodOnMetadata(client_initial_metadata);
-  auto call = MakeServerCall(server_.get(), channel_.get(), arena);
+    ClientMetadataHandle client_initial_metadata, Arena* arena) {
+  SetRegisteredMethodOnMetadata(*client_initial_metadata);
+  auto call = MakeServerCall(std::move(client_initial_metadata), server_.get(),
+                             channel_.get(), arena);
   InitCall(call);
   return CallInitiator(std::move(call));
 }
 
 void Server::ChannelData::InitTransport(RefCountedPtr<Server> server,
-                                        RefCountedPtr<Channel> channel,
+                                        OrphanablePtr<Channel> channel,
                                         size_t cq_idx, Transport* transport,
                                         intptr_t channelz_socket_uuid) {
   server_ = std::move(server);
-  channel_ = channel;
+  channel_ = std::move(channel);
   cq_idx_ = cq_idx;
   channelz_socket_uuid_ = channelz_socket_uuid;
   // Publish channel.
@@ -1329,20 +1332,17 @@ void Server::ChannelData::InitTransport(RefCountedPtr<Server> server,
     ++accept_stream_types;
     op->set_accept_stream = true;
     op->set_accept_stream_fn = AcceptStream;
-    if (IsRegisteredMethodLookupInTransportEnabled()) {
-      op->set_registered_method_matcher_fn = [](void* arg,
-                                                ClientMetadata* metadata) {
-        static_cast<ChannelData*>(arg)->SetRegisteredMethodOnMetadata(
-            *metadata);
-      };
-    }
+    op->set_registered_method_matcher_fn = [](void* arg,
+                                              ClientMetadata* metadata) {
+      static_cast<ChannelData*>(arg)->SetRegisteredMethodOnMetadata(*metadata);
+    };
     op->set_accept_stream_user_data = this;
   }
   if (transport->server_transport() != nullptr) {
     ++accept_stream_types;
     transport->server_transport()->SetAcceptor(this);
   }
-  GPR_ASSERT(accept_stream_types == 1);
+  CHECK_EQ(accept_stream_types, 1);
   op->start_connectivity_watch = MakeOrphanable<ConnectivityWatcher>(this);
   if (server_->ShutdownCalled()) {
     op->disconnect_with_error = GRPC_ERROR_CREATE("Server shutdown");
@@ -1392,7 +1392,7 @@ void Server::ChannelData::AcceptStream(void* arg, Transport* /*transport*/,
   auto* chand = static_cast<Server::ChannelData*>(arg);
   // create a call
   grpc_call_create_args args;
-  args.channel = chand->channel_;
+  args.channel = chand->channel_->Ref();
   args.server = chand->server_.get();
   args.parent = nullptr;
   args.propagation_mask = 0;
@@ -1404,8 +1404,8 @@ void Server::ChannelData::AcceptStream(void* arg, Transport* /*transport*/,
   grpc_error_handle error = grpc_call_create(&args, &call);
   grpc_call_stack* call_stack = grpc_call_get_call_stack(call);
   if (call_stack == nullptr) {  // Promise based calls do not have a call stack
-    GPR_ASSERT(error.ok());
-    GPR_ASSERT(IsPromiseBasedServerCallEnabled());
+    CHECK(error.ok());
+    CHECK(IsPromiseBasedServerCallEnabled());
     return;
   } else {
     grpc_call_element* elem = grpc_call_stack_element(call_stack, 0);
@@ -1430,10 +1430,10 @@ void Server::ChannelData::InitCall(RefCountedPtr<CallSpineInterface> call) {
   call->SpawnGuarded("request_matcher", [this, call]() {
     return TrySeq(
         // Wait for initial metadata to pass through all filters
-        Map(call->client_initial_metadata().receiver.Next(),
-            [](NextResult<ClientMetadataHandle> md)
+        Map(call->PullClientInitialMetadata(),
+            [](ValueOrFailure<ClientMetadataHandle> md)
                 -> absl::StatusOr<ClientMetadataHandle> {
-              if (!md.has_value()) {
+              if (!md.ok()) {
                 return absl::InternalError("Missing metadata");
               }
               if (!md.value()->get_pointer(HttpPathMetadata())) {
@@ -1454,28 +1454,24 @@ void Server::ChannelData::InitCall(RefCountedPtr<CallSpineInterface> call) {
           if (registered_method == nullptr) {
             rm = server_->unregistered_request_matcher_.get();
           } else {
+            payload_handling = registered_method->payload_handling;
             rm = registered_method->matcher.get();
           }
           auto maybe_read_first_message = If(
               payload_handling == GRPC_SRM_PAYLOAD_READ_INITIAL_BYTE_BUFFER,
-              [call]() {
-                return call->client_to_server_messages().receiver.Next();
-              },
-              []() -> NextResult<MessageHandle> {
-                return NextResult<MessageHandle>();
+              [call]() { return call->PullClientToServerMessage(); },
+              []() -> ValueOrFailure<absl::optional<MessageHandle>> {
+                return ValueOrFailure<absl::optional<MessageHandle>>(
+                    absl::nullopt);
               });
           return TryJoin<absl::StatusOr>(
-              Map(std::move(maybe_read_first_message),
-                  [](NextResult<MessageHandle> n) {
-                    return ValueOrFailure<NextResult<MessageHandle>>{
-                        std::move(n)};
-                  }),
-              rm->MatchRequest(cq_idx()), [md = std::move(md)]() mutable {
+              std::move(maybe_read_first_message), rm->MatchRequest(cq_idx()),
+              [md = std::move(md)]() mutable {
                 return ValueOrFailure<ClientMetadataHandle>(std::move(md));
               });
         },
         // Publish call to cq
-        [](std::tuple<NextResult<MessageHandle>,
+        [](std::tuple<absl::optional<MessageHandle>,
                       RequestMatcherInterface::MatchResult,
                       ClientMetadataHandle>
                r) {
@@ -1484,6 +1480,10 @@ void Server::ChannelData::InitCall(RefCountedPtr<CallSpineInterface> call) {
           auto* rc = mr.TakeCall();
           rc->Complete(std::move(std::get<0>(r)), *md);
           auto* call_context = GetContext<CallContext>();
+          const auto* deadline = md->get_pointer(GrpcTimeoutMetadata());
+          if (deadline != nullptr) {
+            GetContext<Call>()->UpdateDeadline(*deadline);
+          }
           *rc->call = call_context->c_call();
           grpc_call_ref(*rc->call);
           grpc_call_set_completion_queue(call_context->c_call(),
@@ -1525,15 +1525,9 @@ ArenaPromise<ServerMetadataHandle> Server::ChannelData::MakeCallPromise(
   }
   // Find request matcher.
   RequestMatcherInterface* matcher;
-  RegisteredMethod* rm = nullptr;
-  if (IsRegisteredMethodLookupInTransportEnabled()) {
-    rm = static_cast<RegisteredMethod*>(
-        call_args.client_initial_metadata->get(GrpcRegisteredMethod())
-            .value_or(nullptr));
-  } else {
-    rm = chand->GetRegisteredMethod(host_ptr->as_string_view(),
-                                    path_ptr->as_string_view());
-  }
+  RegisteredMethod* rm = static_cast<RegisteredMethod*>(
+      call_args.client_initial_metadata->get(GrpcRegisteredMethod())
+          .value_or(nullptr));
   ArenaPromise<absl::StatusOr<NextResult<MessageHandle>>>
       maybe_read_first_message([] { return NextResult<MessageHandle>(); });
   if (rm != nullptr) {
@@ -1605,7 +1599,7 @@ void Server::ChannelData::FinishDestroy(void* arg,
 
 void Server::ChannelData::Destroy() {
   if (!list_position_.has_value()) return;
-  GPR_ASSERT(server_ != nullptr);
+  CHECK(server_ != nullptr);
   server_->channels_.erase(*list_position_);
   list_position_.reset();
   server_->Ref().release();
@@ -1627,8 +1621,8 @@ void Server::ChannelData::Destroy() {
 
 grpc_error_handle Server::ChannelData::InitChannelElement(
     grpc_channel_element* elem, grpc_channel_element_args* args) {
-  GPR_ASSERT(args->is_first);
-  GPR_ASSERT(!args->is_last);
+  CHECK(args->is_first);
+  CHECK(!args->is_last);
   new (elem->channel_data) ChannelData();
   return absl::OkStatus();
 }
@@ -1655,7 +1649,7 @@ Server::CallData::CallData(grpc_call_element* elem,
 }
 
 Server::CallData::~CallData() {
-  GPR_ASSERT(state_.load(std::memory_order_relaxed) != CallState::PENDING);
+  CHECK(state_.load(std::memory_order_relaxed) != CallState::PENDING);
   grpc_metadata_array_destroy(&initial_metadata_);
   grpc_byte_buffer_destroy(payload_);
 }
@@ -1706,8 +1700,8 @@ void Server::CallData::Publish(size_t cq_idx, RequestedCall* rc) {
   std::swap(*rc->initial_metadata, initial_metadata_);
   switch (rc->type) {
     case RequestedCall::Type::BATCH_CALL:
-      GPR_ASSERT(host_.has_value());
-      GPR_ASSERT(path_.has_value());
+      CHECK(host_.has_value());
+      CHECK(path_.has_value());
       rc->data.batch.details->host = CSliceRef(host_->c_slice());
       rc->data.batch.details->method = CSliceRef(path_->c_slice());
       rc->data.batch.details->deadline =
@@ -1758,7 +1752,6 @@ void Server::CallData::KillZombie() {
 
 // If this changes, change MakeCallPromise too.
 void Server::CallData::StartNewRpc(grpc_call_element* elem) {
-  auto* chand = static_cast<ChannelData*>(elem->channel_data);
   if (server_->ShutdownCalled()) {
     state_.store(CallState::ZOMBIED, std::memory_order_relaxed);
     KillZombie();
@@ -1769,15 +1762,8 @@ void Server::CallData::StartNewRpc(grpc_call_element* elem) {
   grpc_server_register_method_payload_handling payload_handling =
       GRPC_SRM_PAYLOAD_NONE;
   if (path_.has_value() && host_.has_value()) {
-    RegisteredMethod* rm;
-    if (IsRegisteredMethodLookupInTransportEnabled()) {
-      rm = static_cast<RegisteredMethod*>(
-          recv_initial_metadata_->get(GrpcRegisteredMethod())
-              .value_or(nullptr));
-    } else {
-      rm = chand->GetRegisteredMethod(host_->as_string_view(),
-                                      path_->as_string_view());
-    }
+    RegisteredMethod* rm = static_cast<RegisteredMethod*>(
+        recv_initial_metadata_->get(GrpcRegisteredMethod()).value_or(nullptr));
     if (rm != nullptr) {
       matcher_ = rm->matcher.get();
       payload_handling = rm->payload_handling;
@@ -1847,6 +1833,7 @@ void Server::CallData::RecvInitialMetadataReady(void* arg,
   auto op_deadline = calld->recv_initial_metadata_->get(GrpcTimeoutMetadata());
   if (op_deadline.has_value()) {
     calld->deadline_ = *op_deadline;
+    Call::FromC(calld->call_)->UpdateDeadline(*op_deadline);
   }
   if (calld->host_.has_value() && calld->path_.has_value()) {
     // do nothing
@@ -1928,7 +1915,7 @@ void grpc_server_register_completion_queue(grpc_server* server,
   GRPC_API_TRACE(
       "grpc_server_register_completion_queue(server=%p, cq=%p, reserved=%p)", 3,
       (server, cq, reserved));
-  GPR_ASSERT(!reserved);
+  CHECK(!reserved);
   auto cq_type = grpc_get_cq_completion_type(cq);
   if (cq_type != GRPC_CQ_NEXT && cq_type != GRPC_CQ_CALLBACK) {
     gpr_log(GPR_INFO,

data/src/core/{lib/surface → server}/server.h

@@ -14,10 +14,8 @@
 // limitations under the License.
 //
 
-#ifndef GRPC_SRC_CORE_LIB_SURFACE_SERVER_H
-#define GRPC_SRC_CORE_LIB_SURFACE_SERVER_H
-
-#include <grpc/support/port_platform.h>
+#ifndef GRPC_SRC_CORE_SERVER_SERVER_H
+#define GRPC_SRC_CORE_SERVER_SERVER_H
 
 #include <stddef.h>
 #include <stdint.h>
@@ -42,14 +40,15 @@
 
 #include <grpc/grpc.h>
 #include <grpc/slice.h>
+#include <grpc/support/port_platform.h>
 #include <grpc/support/time.h>
 
+#include "src/core/channelz/channelz.h"
 #include "src/core/lib/backoff/random_early_detection.h"
 #include "src/core/lib/channel/call_tracer.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/channelz.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/cpp_impl_of.h"
 #include "src/core/lib/gprpp/dual_ref_counted.h"
@@ -68,6 +67,7 @@
 #include "src/core/lib/surface/completion_queue.h"
 #include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/lib/transport/transport.h"
+#include "src/core/server/server_interface.h"
 
 #define GRPC_ARG_SERVER_MAX_PENDING_REQUESTS "grpc.server.max_pending_requests"
 #define GRPC_ARG_SERVER_MAX_PENDING_REQUESTS_HARD_LIMIT \
@@ -77,7 +77,8 @@ namespace grpc_core {
 
 extern TraceFlag grpc_server_channel_trace;
 
-class Server : public InternallyRefCounted<Server>,
+class Server : public ServerInterface,
+               public InternallyRefCounted<Server>,
                public CppImplOf<Server, grpc_server> {
  public:
   // Filter vtable.
@@ -134,8 +135,10 @@ class Server : public InternallyRefCounted<Server>,
 
   void Orphan() ABSL_LOCKS_EXCLUDED(mu_global_) override;
 
-  const ChannelArgs& channel_args() const { return channel_args_; }
-  channelz::ServerNode* channelz_node() const { return channelz_node_.get(); }
+  const ChannelArgs& channel_args() const override { return channel_args_; }
+  channelz::ServerNode* channelz_node() const override {
+    return channelz_node_.get();
+  }
 
   // Do not call this before Start(). Returns the pollsets. The
   // vector itself is immutable, but the pollsets inside are mutable. The
@@ -146,7 +149,7 @@ class Server : public InternallyRefCounted<Server>,
     return config_fetcher_.get();
   }
 
-  ServerCallTracerFactory* server_call_tracer_factory() const {
+  ServerCallTracerFactory* server_call_tracer_factory() const override {
     return server_call_tracer_factory_;
   }
 
@@ -224,7 +227,7 @@ class Server : public InternallyRefCounted<Server>,
     ~ChannelData();
 
     void InitTransport(RefCountedPtr<Server> server,
-                       RefCountedPtr<Channel> channel, size_t cq_idx,
+                       OrphanablePtr<Channel> channel, size_t cq_idx,
                        Transport* transport, intptr_t channelz_socket_uuid);
 
     RefCountedPtr<Server> server() const { return server_; }
@@ -243,7 +246,7 @@ class Server : public InternallyRefCounted<Server>,
 
     Arena* CreateArena() override;
     absl::StatusOr<CallInitiator> CreateCall(
-        ClientMetadata& client_initial_metadata, Arena* arena) override;
+        ClientMetadataHandle client_initial_metadata, Arena* arena) override;
 
    private:
     class ConnectivityWatcher;
@@ -257,7 +260,7 @@ class Server : public InternallyRefCounted<Server>,
     static void FinishDestroy(void* arg, grpc_error_handle error);
 
     RefCountedPtr<Server> server_;
-    RefCountedPtr<Channel> channel_;
+    OrphanablePtr<Channel> channel_;
     // The index into Server::cqs_ of the CQ used as a starting point for
     // where to publish new incoming calls.
     size_t cq_idx_;
@@ -548,4 +551,4 @@ inline void Server::set_config_fetcher(
 
 }  // namespace grpc_core
 
-#endif  // GRPC_SRC_CORE_LIB_SURFACE_SERVER_H
+#endif  // GRPC_SRC_CORE_SERVER_SERVER_H

data/src/core/{lib/channel → server}/server_call_tracer_filter.cc

@@ -14,14 +14,17 @@
 // limitations under the License.
 //
 
-#include <grpc/support/port_platform.h>
+#include "src/core/server/server_call_tracer_filter.h"
 
 #include <functional>
+#include <memory>
 #include <utility>
 
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 
+#include <grpc/support/port_platform.h>
+
 #include "src/core/lib/channel/call_finalization.h"
 #include "src/core/lib/channel/call_tracer.h"
 #include "src/core/lib/channel/channel_args.h"
@@ -47,7 +50,7 @@ class ServerCallTracerFilter
  public:
   static const grpc_channel_filter kFilter;
 
-  static absl::StatusOr<ServerCallTracerFilter> Create(
+  static absl::StatusOr<std::unique_ptr<ServerCallTracerFilter>> Create(
       const ChannelArgs& /*args*/, ChannelFilter::Args /*filter_args*/);
 
   class Call {
@@ -96,14 +99,16 @@ const grpc_channel_filter ServerCallTracerFilter::kFilter =
                            kFilterExaminesServerInitialMetadata>(
         "server_call_tracer");
 
-absl::StatusOr<ServerCallTracerFilter> ServerCallTracerFilter::Create(
-    const ChannelArgs& /*args*/, ChannelFilter::Args /*filter_args*/) {
-  return ServerCallTracerFilter();
+absl::StatusOr<std::unique_ptr<ServerCallTracerFilter>>
+ServerCallTracerFilter::Create(const ChannelArgs& /*args*/,
+                               ChannelFilter::Args /*filter_args*/) {
+  return std::make_unique<ServerCallTracerFilter>();
 }
 
 }  // namespace
 
 void RegisterServerCallTracerFilter(CoreConfiguration::Builder* builder) {
+  if (IsChaoticGoodEnabled()) return;
   builder->channel_init()->RegisterFilter<ServerCallTracerFilter>(
       GRPC_SERVER_CHANNEL);
 }

data/src/core/{lib/surface/builtins.h → server/server_call_tracer_filter.h}

@@ -1,4 +1,4 @@
-// Copyright 2021 gRPC authors.
+// Copyright 2024 The gRPC Authors.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -12,15 +12,17 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef GRPC_SRC_CORE_LIB_SURFACE_BUILTINS_H
-#define GRPC_SRC_CORE_LIB_SURFACE_BUILTINS_H
+#ifndef GRPC_SRC_CORE_SERVER_SERVER_CALL_TRACER_FILTER_H
+#define GRPC_SRC_CORE_SERVER_SERVER_CALL_TRACER_FILTER_H
 
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/config/core_configuration.h"
 
 namespace grpc_core {
-void RegisterBuiltins(CoreConfiguration::Builder* builder);
+
+void RegisterServerCallTracerFilter(CoreConfiguration::Builder* builder);
+
 }  // namespace grpc_core
 
-#endif  // GRPC_SRC_CORE_LIB_SURFACE_BUILTINS_H
+#endif  // GRPC_SRC_CORE_SERVER_SERVER_CALL_TRACER_FILTER_H

data/src/core/{ext/filters/server_config_selector → server}/server_config_selector.h

@@ -14,16 +14,16 @@
 // limitations under the License.
 //
 
-#ifndef GRPC_SRC_CORE_EXT_FILTERS_SERVER_CONFIG_SELECTOR_SERVER_CONFIG_SELECTOR_H
-#define GRPC_SRC_CORE_EXT_FILTERS_SERVER_CONFIG_SELECTOR_SERVER_CONFIG_SELECTOR_H
-
-#include <grpc/support/port_platform.h>
+#ifndef GRPC_SRC_CORE_SERVER_SERVER_CONFIG_SELECTOR_H
+#define GRPC_SRC_CORE_SERVER_SERVER_CONFIG_SELECTOR_H
 
 #include <memory>
 
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 
+#include <grpc/support/port_platform.h>
+
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/dual_ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted.h"
@@ -80,4 +80,4 @@ class ServerConfigSelectorProvider
 
 }  // namespace grpc_core
 
-#endif  // GRPC_SRC_CORE_EXT_FILTERS_SERVER_CONFIG_SELECTOR_SERVER_CONFIG_SELECTOR_H
+#endif  // GRPC_SRC_CORE_SERVER_SERVER_CONFIG_SELECTOR_H