grpc 1.83.1 → 1.84.0

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

@@ -21,18 +21,15 @@
 #include <grpc/event_engine/event_engine.h>
 #include <grpc/grpc.h>
 #include <grpc/support/port_platform.h>
-#include <limits.h>
 
 #include <algorithm>
 #include <cstddef>
 #include <cstdint>
-#include <iterator>
 #include <memory>
 #include <optional>
 #include <string>
 #include <type_traits>
 #include <utility>
-#include <variant>
 #include <vector>
 
 #include "src/core/call/call_destination.h"
@@ -47,7 +44,6 @@
 #include "src/core/ext/transport/chttp2/transport/goaway.h"
 #include "src/core/ext/transport/chttp2/transport/header_assembler.h"
 #include "src/core/ext/transport/chttp2/transport/hpack_encoder.h"
-#include "src/core/ext/transport/chttp2/transport/hpack_parser.h"
 #include "src/core/ext/transport/chttp2/transport/http2_settings.h"
 #include "src/core/ext/transport/chttp2/transport/http2_settings_promises.h"
 #include "src/core/ext/transport/chttp2/transport/http2_status.h"
@@ -62,19 +58,19 @@
 #include "src/core/ext/transport/chttp2/transport/stream_data_queue.h"
 #include "src/core/ext/transport/chttp2/transport/transport_common.h"
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/debug/trace_impl.h"
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
+#include "src/core/lib/promise/all_ok.h"
 #include "src/core/lib/promise/for_each.h"
 #include "src/core/lib/promise/if.h"
 #include "src/core/lib/promise/loop.h"
 #include "src/core/lib/promise/map.h"
-#include "src/core/lib/promise/match_promise.h"
 #include "src/core/lib/promise/party.h"
 #include "src/core/lib/promise/poll.h"
 #include "src/core/lib/promise/promise.h"
 #include "src/core/lib/promise/race.h"
 #include "src/core/lib/promise/sleep.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/resource_quota/resource_quota.h"
@@ -95,10 +91,8 @@
 #include "absl/functional/any_invocable.h"
 #include "absl/log/log.h"
 #include "absl/status/status.h"
-#include "absl/strings/cord.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/span.h"
 
 namespace grpc_core {
 namespace http2 {
@@ -136,9 +130,10 @@ void Http2ServerTransport::AddData(channelz::DataSink sink) {
     RefCountedPtr<Party> party = nullptr;
     {
       MutexLock lock(&self->transport_mutex_);
-      if (GPR_LIKELY(!self->is_transport_closed_)) {
-        GRPC_DCHECK(self->general_party_ != nullptr);
-        party = self->general_party_;
+      if (GPR_LIKELY(!self->shutdown_tracker_.IsShutdownInitiated(
+              self->transport_mutex_))) {
+        GRPC_DCHECK(self->transport_party_ != nullptr);
+        party = self->transport_party_;
       } else {
         GRPC_HTTP2_SERVER_DLOG
             << "Http2ServerTransport::AddData Transport is closed.";
@@ -170,9 +165,10 @@ void Http2ServerTransport::SpawnAddChannelzData(RefCountedPtr<Party> party,
                      self->read_context_.max_new_streams_per_read_cycle())
                 .Set("settings", self->settings_->ChannelzProperties())
                 .Set("flow_control",
-                     self->flow_control_.stats().ChannelzProperties()));
-        self->general_party_->ExportToChannelz("Http2ServerTransport Party",
-                                               sink);
+                     self->flow_control_.stats().ChannelzProperties())
+                .Set("tarpit", self->tarpit_manager_.ChannelzProperties()));
+        self->transport_party_->ExportToChannelz("Http2ServerTransport Party",
+                                                 sink);
         GRPC_HTTP2_SERVER_DLOG
             << "Http2ServerTransport::SpawnAddChannelzData End";
         return Empty{};
@@ -186,7 +182,7 @@ void Http2ServerTransport::StartWatch(RefCountedPtr<StateWatcher> watcher) {
   MutexLock lock(&transport_mutex_);
   GRPC_CHECK(watcher_ == nullptr);
   watcher_ = std::move(watcher);
-  if (is_transport_closed_) {
+  if (shutdown_tracker_.IsShutdownInitiated(transport_mutex_)) {
     // TODO(tjagtap) : [PH2][P2] : Provide better status message and
     // disconnect info here.
     NotifyStateWatcherOnDisconnectLocked(
@@ -235,7 +231,7 @@ int64_t Http2ServerTransport::TestOnlyTransportFlowControlWindow() {
 
 int64_t Http2ServerTransport::TestOnlyGetStreamFlowControlWindow(
     const uint32_t stream_id) {
-  RefCountedPtr<Stream> stream = LookupStream(stream_id);
+  const RefCountedPtr<Stream> stream = LookupStream(stream_id);
   if (stream == nullptr) {
     return -1;
   }
@@ -246,7 +242,7 @@ int64_t Http2ServerTransport::TestOnlyGetStreamFlowControlWindow(
 // Endpoint Helpers
 
 auto Http2ServerTransport::EndpointWrite(SliceBuffer&& output_buf) {
-  size_t output_buf_length = output_buf.Length();
+  const size_t output_buf_length = output_buf.Length();
   GRPC_HTTP2_SERVER_DLOG << "Http2ServerTransport::EndpointWrite output_buf: "
                          << output_buf_length;
 
@@ -291,7 +287,7 @@ Http2Status Http2ServerTransport::ProcessIncomingFrame(Http2DataFrame&& frame) {
 
   ping_manager_->ReceivedDataFrame();
 
-  RefCountedPtr<Stream> stream = LookupStream(frame.stream_id);
+  const RefCountedPtr<Stream> stream = LookupStream(frame.stream_id);
 
   if (frame.payload.Length() > 0) {
     // DATA frames with empty payload are legitimate frames. CHTTP2 and PH2 send
@@ -408,6 +404,12 @@ Http2Status Http2ServerTransport::ProcessIncomingMetadata(T&& frame) {
           std::move(frame.payload), frame.end_headers, Http2Status::Ok(),
           settings_->acked().max_header_list_size());
     }
+    // TODO(tjagtap) : [PH2][P1] : Move this check as needed.
+    if (GPR_UNLIKELY(is_goaway_received_)) {
+      return Http2Status::Http2ConnectionError(
+          Http2ErrorCode::kProtocolError,
+          std::string(RFC9113::kReceivedStreamAfterGoaway));
+    }
 
     Http2Status append_result =
         read_context_.header_assembler().AppendFrame(frame);
@@ -459,20 +461,43 @@ Http2Status Http2ServerTransport::ProcessIncomingFrame(
       << "Http2ServerTransport::ProcessIncomingFrame(ResetStreamFrame) { "
          "stream_id="
       << frame.stream_id << ", error_code=" << frame.error_code << " }";
-  read_context_.OnResetFrameReceived();
+  const ShouldSendPing should_send_ping = read_context_.OnResetFrameReceived();
+  if (should_send_ping.should_send_ping_on_rst_stream) {
+    SpawnInfallibleTransportParty("PingOnResetStream",
+                                  UntilTransportClosed(PingOnResetStream()));
+  }
 
-  Http2ErrorCode error_code = FrameErrorCodeToHttp2ErrorCode(frame.error_code);
-  absl::Status status = absl::Status(ErrorCodeToAbslStatusCode(error_code),
-                                     "Reset stream frame received.");
+  const Http2ErrorCode error_code =
+      FrameErrorCodeToHttp2ErrorCode(frame.error_code);
+  absl::Status status =
+      error_code == Http2ErrorCode::kNoError
+          ? absl::UnavailableError("RST_STREAM frame received with no error.")
+          : absl::Status(ErrorCodeToAbslStatusCode(error_code),
+                         "Reset stream frame received.");
   RefCountedPtr<Stream> stream = LookupStream(frame.stream_id);
   if (stream != nullptr) {
-    if (status.ok()) {
-      status =
-          absl::UnavailableError("RST_STREAM frame received with no error.");
+    if (stream->IsTarpitted()) {
+      // If the stream is already in the Tarpit state, we do not want to process
+      // the RST_STREAM frame. The stream will be closed once the Tarpit timer
+      // expires.
+      GRPC_HTTP2_SERVER_DLOG
+          << "Http2ServerTransport::ProcessIncomingFrame(ResetStreamFrame) "
+             "ignoring RST_STREAM for already tarpitted stream_id="
+          << frame.stream_id;
+    } else if (tarpit_manager_.allow_tarpit()) {
+      // If tarpit is enabled, we will enqueue the RST_STREAM frame to the
+      // Tarpit manager and delay the stream reset.
+      StatusFlag tarpit_status = tarpit_manager_.RequestTarpitIncomingReset(
+          stream->GetStreamId(), std::move(status));
+      if (GPR_UNLIKELY(!tarpit_status.ok())) {
+        return Http2Status::Http2ConnectionError(
+            Http2ErrorCode::kInternalError, "Failed to enqueue tarpit entry");
+      }
+    } else {
+      // If tarpit is not enabled, we will process the RST_STREAM frame inline.
+      HandleStreamStateChange(*stream,
+                              stream->OnResetReceived(std::move(status)));
     }
-
-    HandleStreamStateChange(*stream,
-                            stream->OnResetReceived(std::move(status)));
   }
 
   // In case of stream error, we do not want the Read Loop to be broken. Hence
@@ -494,7 +519,7 @@ Http2Status Http2ServerTransport::ProcessIncomingFrame(
     if (!s.IsOk()) {
       return s;
     }
-    absl::Status trigger_write_status = TriggerWriteCycle();
+    const absl::Status trigger_write_status = TriggerWriteCycle();
     if (!trigger_write_status.ok()) {
       return ToHttpOkOrConnError(trigger_write_status);
     }
@@ -522,11 +547,18 @@ Http2Status Http2ServerTransport::ProcessIncomingFrame(Http2PingFrame&& frame) {
   // https://www.rfc-editor.org/rfc/rfc9113.html#name-ping
   GRPC_HTTP2_SERVER_DLOG
       << "Http2ServerTransport::ProcessIncomingFrame(PingFrame) { ack="
-      << frame.ack << ", opaque=" << frame.opaque << " }";
+      << frame.ack << ", opaque=" << frame.opaque << " }, "
+      << ping_manager_->GetDebugString(!IsPingWithoutCallsAllowed() &&
+                                       IsTransportIdle());
   if (frame.ack) {
     return ToHttpOkOrConnError(AckPing(frame.opaque));
   } else {
     read_context_.OnPingFrameReceived();
+    if (GPR_UNLIKELY(ping_manager_->NotifyPingAbusePolicy(
+            !IsPingWithoutCallsAllowed() && IsTransportIdle()))) {
+      return Http2Status::Http2ConnectionError(Http2ErrorCode::kEnhanceYourCalm,
+                                               "too_many_pings");
+    }
     if (test_only_ack_pings_) {
       ping_manager_->AddPendingPingAck(frame.opaque);
       return ToHttpOkOrConnError(TriggerWriteCycle());
@@ -550,87 +582,27 @@ Http2Status Http2ServerTransport::ProcessIncomingFrame(
          frame.error_code != static_cast<uint32_t>(Http2ErrorCode::kNoError))
       << "Received GOAWAY frame with error code: " << frame.error_code;
 
-  //   uint32_t last_stream_id = 0;
-  //   absl::Status status(ErrorCodeToAbslStatusCode(
-  //                           FrameErrorCodeToHttp2ErrorCode(frame.error_code)),
-  //                       frame.debug_data.empty()
-  //                           ? absl::string_view("GOAWAY received")
-  //                           : frame.debug_data.as_string_view());
-  //   if (GoawayManager::IsGracefulGoaway(frame)) {
-  //     const uint32_t next_stream_id = PeekNextStreamId();
-  //     last_stream_id = (next_stream_id > 1) ? next_stream_id - 2 : 0;
-  //   } else {
-  //     last_stream_id = frame.last_stream_id;
-  //   }
-  //   SetMaxAllowedStreamId(last_stream_id);
-
-  //   bool close_transport = false;
-  //   {
-  //     MutexLock lock(&transport_mutex_);
-  //     if (CanCloseTransportLocked()) {
-  //       close_transport = true;
-  //       GRPC_HTTP2_SERVER_DLOG <<
-  //       "Http2ServerTransport::ProcessIncomingFrame("
-  //                                 "GoawayFrame) "
-  //                                 "stream_list_ is empty";
-  //     }
-  //   }
-
-  //   StateWatcher::DisconnectInfo disconnect_info;
-  //   disconnect_info.reason = Transport::StateWatcher::kGoaway;
-  //   disconnect_info.http2_error_code =
-  //       static_cast<Http2ErrorCode>(frame.error_code);
-
-  //   // Throttle keepalive time if the server sends a GOAWAY with error code
-  //   // ENHANCE_YOUR_CALM and debug data equal to "too_many_pings". This
-  //   will
-  //   // apply to any new transport created on by any subchannel of this
-  //   channel. if (GPR_UNLIKELY(frame.error_code == static_cast<uint32_t>(
-  //                                            Http2ErrorCode::kEnhanceYourCalm)
-  //                                            &&
-  //                    frame.debug_data == "too_many_pings")) {
-  //     LOG(ERROR) << ": Received a GOAWAY with error code ENHANCE_YOUR_CALM
-  //     and
-  //     "
-  //                   "debug data equal to \"too_many_pings\". Current
-  //                   keepalive " "time (before throttling): "
-  //                << keepalive_time_.ToString();
-  //     constexpr int max_keepalive_time_millis =
-  //         INT_MAX / KEEPALIVE_TIME_BACKOFF_MULTIPLIER;
-  //     uint64_t throttled_keepalive_time =
-  //         keepalive_time_.millis() > max_keepalive_time_millis
-  //             ? INT_MAX
-  //             : keepalive_time_.millis() *
-  //             KEEPALIVE_TIME_BACKOFF_MULTIPLIER;
-  //     if (!IsSubchannelConnectionScalingEnabled()) {
-  //       status.SetPayload(kKeepaliveThrottlingKey,
-  //                         absl::Cord(std::to_string(throttled_keepalive_time)));
-  //     }
-  //     disconnect_info.keepalive_time =
-  //         Duration::Milliseconds(throttled_keepalive_time);
-  //   }
-
-  //   if (close_transport) {
-  //     // TODO(akshitpatel) : [PH2][P3] : Ideally the error here should be
-  //     // kNoError. However, Http2Status does not support kNoError. We
-  //     should
-  //     // revisit this and update the error code.
-  //     MaybeSpawnCloseTransport(Http2Status::Http2ConnectionError(
-  //         FrameErrorCodeToHttp2ErrorCode((
-  //             frame.error_code ==
-  //                     Http2ErrorCodeToFrameErrorCode(Http2ErrorCode::kNoError)
-  //                 ?
-  //                 Http2ErrorCodeToFrameErrorCode(Http2ErrorCode::kInternalError)
-  //                 : frame.error_code)),
-  //         frame.debug_data.empty()
-  //             ? std::string("GOAWAY received")
-  //             : std::string(frame.debug_data.as_string_view())));
-  //   }
-
-  //   // lie: use transient failure from the transport to indicate goaway has
-  //   been
-  //   // received.
-  //   ReportDisconnection(status, disconnect_info, "got_goaway");
+  is_goaway_received_ = true;
+
+  absl::Status status(ErrorCodeToAbslStatusCode(
+                          FrameErrorCodeToHttp2ErrorCode(frame.error_code)),
+                      frame.debug_data.empty()
+                          ? absl::string_view("GOAWAY received")
+                          : frame.debug_data.as_string_view());
+
+  StateWatcher::DisconnectInfo disconnect_info;
+  disconnect_info.reason = Transport::StateWatcher::kGoaway;
+  disconnect_info.http2_error_code =
+      FrameErrorCodeToHttp2ErrorCode(frame.error_code);
+
+  // We do not close the transport here. Instead we rely on the upper layers to
+  // call Orphan. Meanwhile, if the client closes the TCP connection, we will
+  // close transport anyway.
+  //
+  // lie: use transient failure from the transport to indicate goaway has
+  // been received.
+  ReportDisconnection(GRPC_CHANNEL_TRANSIENT_FAILURE, status, disconnect_info,
+                      "got_goaway");
   return Http2Status::Ok();
 }
 
@@ -953,7 +925,7 @@ absl::Status Http2ServerTransport::DequeueStreamFrames(
           stream->GetStreamFlowControl(), settings_->peer()));
   stream->GetStreamFlowControl().ReportIfStalled(
       /*is_client=*/kIsClient, stream->GetStreamId(), settings_->peer());
-  StreamDataQueue<ClientMetadataHandle>::DequeueResult result =
+  StreamDataQueue<ServerMetadataHandle>::DequeueResult result =
       stream->DequeueFrames(tokens, stream_flow_control_tokens,
                             settings_->peer().max_frame_size(), encoder_,
                             frame_sender);
@@ -1044,7 +1016,7 @@ auto Http2ServerTransport::MultiplexerLoop() {
                   writable_stream_list_.ImmediateNext(
                       AreTransportFlowControlTokensAvailable());
               if (!optional_stream.has_value()) {
-                GRPC_HTTP2_CLIENT_DLOG
+                GRPC_HTTP2_SERVER_DLOG
                     << "Http2ServerTransport::MultiplexerLoop "
                        "No writable streams available ";
                 break;
@@ -1089,8 +1061,8 @@ auto Http2ServerTransport::MultiplexerLoop() {
         },
         [this]() -> LoopCtl<absl::Status> {
           if (should_reset_ping_clock_) {
-            GRPC_HTTP2_CLIENT_DLOG
-                << "Http2ClientTransport::MultiplexerLoop ResetPingClock";
+            GRPC_HTTP2_SERVER_DLOG
+                << "Http2ServerTransport::MultiplexerLoop ResetPingClock";
             ping_manager_->ResetPingClock(/*is_client=*/kIsClient);
             should_reset_ping_clock_ = false;
           }
@@ -1198,8 +1170,10 @@ auto Http2ServerTransport::FlowControlPeriodicUpdateLoop() {
               GRPC_HTTP2_SERVER_DLOG
                   << "Http2ServerTransport::FlowControlPeriodicUpdateLoop "
                      "PeriodicUpdate()";
-              chttp2::FlowControlAction action = flow_control_.PeriodicUpdate();
-              bool is_action_empty = action == chttp2::FlowControlAction();
+              const chttp2::FlowControlAction action =
+                  flow_control_.PeriodicUpdate();
+              const bool is_action_empty =
+                  action == chttp2::FlowControlAction();
               // This may trigger a write cycle
               ActOnFlowControlAction(action, nullptr);
               if (is_action_empty) {
@@ -1221,7 +1195,8 @@ auto Http2ServerTransport::FlowControlPeriodicUpdateLoop() {
 //////////////////////////////////////////////////////////////////////////////
 // Stream List Operations
 
-RefCountedPtr<Stream> Http2ServerTransport::LookupStream(uint32_t stream_id) {
+RefCountedPtr<Stream> Http2ServerTransport::LookupStream(
+    const uint32_t stream_id) {
   MutexLock lock(&transport_mutex_);
   auto it = stream_list_.find(stream_id);
   if (it == stream_list_.end()) {
@@ -1256,6 +1231,23 @@ void Http2ServerTransport::AddToStreamList(RefCountedPtr<Stream> stream) {
   }
 }
 
+void Http2ServerTransport::EnqueueResetStreamFromTransportParty(
+    RefCountedPtr<Stream> stream, const uint32_t reset_stream_error_code) {
+  const absl::StatusOr<StreamWritabilityUpdate> enqueue_result =
+      stream->EnqueueResetStream(reset_stream_error_code);
+  GRPC_HTTP2_SERVER_DLOG << "Enqueued ResetStream with error code="
+                         << reset_stream_error_code
+                         << " status=" << enqueue_result.status();
+  if (GPR_LIKELY(enqueue_result.ok())) {
+    GRPC_UNUSED absl::Status status = MaybeAddStreamToWritableStreamList(
+        std::move(stream), enqueue_result.value());
+  }
+  // This function could be hit multiple times for the same stream. So there is
+  // a chance that we may overcount induced frames.
+  // It is a bug, but not worth fixing for now.
+  read_context_.OnResetFrameEnqueued(reset_stream_error_code);
+}
+
 absl::Status Http2ServerTransport::MaybeAddStreamToWritableStreamList(
     RefCountedPtr<Stream> stream,
     const StreamDataQueue<ServerMetadataHandle>::StreamWritabilityUpdate
@@ -1331,22 +1323,51 @@ auto Http2ServerTransport::CallOutboundLoop(RefCountedPtr<Stream> stream) {
   GRPC_HTTP2_SERVER_DLOG << "Http2ServerTransport::CallOutboundLoop";
   GRPC_DCHECK(stream != nullptr);
 
-  auto send_trailing_metadata =
-      [this, stream](ServerMetadataHandle&& metadata) mutable {
-        absl::StatusOr<StreamWritabilityUpdate> enqueue_result =
-            stream->EnqueueTrailingMetadata(std::move(metadata));
-        if (GPR_UNLIKELY(!enqueue_result.ok())) {
-          GRPC_HTTP2_SERVER_DLOG
-              << "Http2ServerTransport::CallOutboundLoop Failed to enqueue "
-                 "trailing metadata: "
-              << enqueue_result.status();
-          return enqueue_result.status();
-        }
-        GRPC_HTTP2_SERVER_DLOG << "Http2ServerTransport::CallOutboundLoop "
-                                  "Enqueued Trailing Metadata";
-        return MaybeAddStreamToWritableStreamList(std::move(stream),
-                                                  enqueue_result.value());
-      };
+  auto send_trailing_metadata = [this, stream](
+                                    ServerMetadataHandle&& metadata) mutable {
+    GRPC_DCHECK(metadata != nullptr);
+    // Barrier: If stream is closed for writes or actively tarpitted, drop
+    // trailing metadata.
+    if (GPR_UNLIKELY(stream->IsClosedForWrites() ||
+                     stream->IsTarpitTimerActive())) {
+      GRPC_HTTP2_SERVER_DLOG
+          << "Http2ServerTransport::CallOutboundLoop ignoring trailing "
+             "metadata for stream_id="
+          << stream->GetStreamId()
+          << " (writes_closed=" << stream->IsClosedForWrites()
+          << ", tarpit_active=" << stream->IsTarpitTimerActive() << ")";
+      return absl::OkStatus();
+    }
+
+    if (metadata->get(GrpcTarPit()).has_value() &&
+        tarpit_manager_.allow_tarpit()) {
+      GRPC_HTTP2_SERVER_DLOG
+          << "Http2ServerTransport::CallOutboundLoop Enqueuing Trailing "
+             "Metadata for tarpitting, stream_id="
+          << stream->GetStreamId();
+      StatusFlag tarpit_status = tarpit_manager_.StartTarpitTrailers(
+          stream->GetStreamId(), std::move(metadata));
+      if (GPR_UNLIKELY(!tarpit_status.ok())) {
+        MaybeSpawnCloseTransport(Http2Status::Http2ConnectionError(
+            Http2ErrorCode::kInternalError, "Failed to enqueue tarpit entry"));
+        return absl::InternalError("Failed to enqueue tarpit entry");
+      }
+      return absl::OkStatus();
+    }
+    const absl::StatusOr<StreamWritabilityUpdate> enqueue_result =
+        stream->EnqueueTrailingMetadata(std::move(metadata));
+    if (GPR_UNLIKELY(!enqueue_result.ok())) {
+      GRPC_HTTP2_SERVER_DLOG
+          << "Http2ServerTransport::CallOutboundLoop Failed to enqueue "
+             "trailing metadata: "
+          << enqueue_result.status();
+      return enqueue_result.status();
+    }
+    GRPC_HTTP2_SERVER_DLOG << "Http2ServerTransport::CallOutboundLoop "
+                              "Enqueued Trailing Metadata";
+    return MaybeAddStreamToWritableStreamList(std::move(stream),
+                                              enqueue_result.value());
+  };
 
   return GRPC_LATENT_SEE_PROMISE(
       "Ph2CallOutboundLoop",
@@ -1380,19 +1401,20 @@ absl::Status Http2ServerTransport::InitializeStream(
 
 std::optional<RefCountedPtr<Stream>> Http2ServerTransport::MakeStream(
     CallInitiator&& call_initiator, const uint32_t stream_id) {
-  RefCountedPtr<Stream> stream =
-      MakeRefCounted<Stream>(call_initiator, flow_control_, stream_id,
-                             settings_->peer().allow_true_binary_metadata());
-  const bool on_done_added = SetOnDone(stream);
-  if (!on_done_added) return std::nullopt;
-  return std::move(stream);
+  return MakeRefCounted<Stream>(call_initiator, flow_control_, stream_id,
+                                settings_->peer().allow_true_binary_metadata());
 }
 
 Http2Status Http2ServerTransport::IncomingStream(
     ClientMetadataHandle&& metadata, const uint32_t stream_id) {
+  if (shutdown_tracker_.IsPartyShutdownInitiated()) {
+    return Http2Status::Http2ConnectionError(
+        Http2ErrorCode::kRefusedStream,
+        "Transport shutdown initiated (party lockdown).");
+  }
   {
     MutexLock lock(&transport_mutex_);
-    if (is_transport_closed_) {
+    if (shutdown_tracker_.IsShutdownInitiated(transport_mutex_)) {
       return Http2Status::Http2ConnectionError(Http2ErrorCode::kRefusedStream,
                                                "Transport is closed.");
     }
@@ -1432,40 +1454,67 @@ Http2Status Http2ServerTransport::IncomingStream(
 }
 
 void Http2ServerTransport::BeginCloseStream(
-    RefCountedPtr<Stream> stream, uint32_t reset_stream_error_code,
-    absl::Status trailing_metadata_status, DebugLocation whence) {
+    RefCountedPtr<Stream> stream, const uint32_t reset_stream_error_code,
+    absl::Status trailing_metadata_status, const bool tarpit,
+    const bool override_tarpit, DebugLocation whence) {
   GRPC_DCHECK(!trailing_metadata_status.ok());
-  if (stream == nullptr) {
-    GRPC_HTTP2_SERVER_DLOG << "Http2ServerTransport::BeginCloseStream stream"
-                              "is null reset_stream_error_code="
-                           << reset_stream_error_code
-                           << " status=" << trailing_metadata_status;
+  GRPC_DCHECK(stream != nullptr);
+  // Early return if the stream is already fully closed, or currently active in
+  // the tarpit lifecycle (unless override_tarpit is true). If a stream is
+  // already actively being tarpitted (IsTarpitActive), subsequent close
+  // requests (e.g. concurrent cancellation or timeout) must be ignored so that
+  // the ongoing tarpit delay is not interrupted.
+  if (stream->IsStreamClosed() ||
+      (!override_tarpit && stream->IsTarpitTimerActive())) {
+    GRPC_HTTP2_SERVER_DLOG
+        << "Http2ServerTransport::BeginCloseStream early return for stream id: "
+        << stream->GetStreamId()
+        << " is_stream_closed=" << stream->IsStreamClosed()
+        << " is_tarpit_active=" << stream->IsTarpitTimerActive()
+        << " error_code=" << reset_stream_error_code
+        << " Status=" << trailing_metadata_status << " tarpit=" << tarpit
+        << " override_tarpit=" << override_tarpit
+        << " location=" << whence.file() << ":" << whence.line();
     return;
   }
 
   GRPC_HTTP2_SERVER_DLOG
       << "Http2ServerTransport::BeginCloseStream for stream id: "
       << stream->GetStreamId() << " error_code=" << reset_stream_error_code
-      << " Status=" << trailing_metadata_status << " location=" << whence.file()
+      << " Status=" << trailing_metadata_status << " tarpit=" << tarpit
+      << " override_tarpit=" << override_tarpit << " location=" << whence.file()
       << ":" << whence.line();
 
-  // Enqueue RST_STREAM.
-  absl::StatusOr<StreamWritabilityUpdate> enqueue_result =
-      stream->EnqueueResetStream(reset_stream_error_code);
-  GRPC_HTTP2_SERVER_DLOG << "Enqueued ResetStream with error code="
-                         << reset_stream_error_code
-                         << " status=" << enqueue_result.status();
-  if (enqueue_result.ok()) {
-    GRPC_UNUSED absl::Status status =
-        MaybeAddStreamToWritableStreamList(stream, enqueue_result.value());
+  // If tarpitting is requested and enabled (and not overridden), delegate
+  // stream close to the TarpitManager. Duplicate entries will be dropped by
+  // MakeTarpitDrainLoop.
+  if (!override_tarpit && tarpit && tarpit_manager_.allow_tarpit()) {
+    StatusFlag tarpit_status = tarpit_manager_.RequestCloseStream(
+        stream->GetStreamId(), reset_stream_error_code,
+        std::move(trailing_metadata_status));
+    if (GPR_UNLIKELY(!tarpit_status.ok())) {
+      GRPC_UNUSED const absl::Status unused = HandleError(
+          std::move(stream),
+          Http2Status::Http2ConnectionError(Http2ErrorCode::kInternalError,
+                                            "Failed to enqueue tarpit entry"),
+          whence);
+    }
+    return;
   }
+
+  // Non-tarpit path (or post-expiration reset or override): enqueue RST_STREAM
+  // frame to the peer immediately and transition call handler to
+  // cancelled/closed state.
+  EnqueueResetStreamFromTransportParty(stream, reset_stream_error_code);
   HandleStreamStateChange(
       *stream, stream->OnInitiateReset(std::move(trailing_metadata_status)));
-  read_context_.OnResetFrameEnqueued(reset_stream_error_code);
 }
 
-void Http2ServerTransport::HandleStreamStateChange(Stream& stream,
-                                                   StreamStateChange change) {
+void Http2ServerTransport::HandleStreamStateChange(
+    Stream& stream, const StreamStateChange change) {
+  GRPC_HTTP2_SERVER_DLOG
+      << "Http2ServerTransport::HandleStreamStateChange for stream id: "
+      << stream.GetStreamId() << " change: " << change.DebugString();
   if (change.reads_became_closed) {
     // If a stream is closing for reads and was actively waiting for a
     // continuation frame, parse the buffered HEADER/CONTINUATION frames
@@ -1503,6 +1552,10 @@ void Http2ServerTransport::CleanupStream(Stream& stream) {
       should_close = true;
     }
   }
+  // Subtract any positive announced window delta of closed stream from the
+  // transport flow control.
+  stream.GetStreamFlowControl().OnStreamClosed();
+
   if (should_close) {
     MaybeSpawnCloseTransport(Http2Status::AbslConnectionError(
         absl::StatusCode::kUnavailable, "Graceful shutdown complete."));
@@ -1560,7 +1613,7 @@ void Http2ServerTransport::MaybeSpawnDelayedPing(
   }
 }
 
-absl::Status Http2ServerTransport::AckPing(uint64_t opaque_data) {
+absl::Status Http2ServerTransport::AckPing(const uint64_t opaque_data) {
   // It is possible that the PingRatePolicy may decide to not send a ping
   // request (in cases like the number of inflight pings is too high).
   // When this happens, it becomes important to ensure that if a ping ack
@@ -1618,6 +1671,112 @@ auto Http2ServerTransport::SpawnGracefulGoawayPromise(Slice&& debug_data) {
       });
 }
 
+//////////////////////////////////////////////////////////////////////////////
+// Tarpit
+
+void Http2ServerTransport::ActOnTarpitEntries(
+    std::vector<TarpitEntry>&& entries) {
+  for (TarpitEntry& entry : entries) {
+    GRPC_HTTP2_SERVER_DLOG << "Http2ServerTransport::ActOnTarpitEntries "
+                           << " DebugString=" << entry.DebugString();
+    RefCountedPtr<Stream> stream = LookupStream(entry.GetStreamId());
+    if (stream == nullptr || stream->IsStreamClosed()) {
+      GRPC_HTTP2_SERVER_DLOG
+          << "Http2ServerTransport::ActOnTarpitEntries ignoring expired entry "
+             "for closed/reclaimed stream_id="
+          << entry.GetStreamId();
+      continue;
+    }
+    stream->SetTarpitCompleted();
+    if (entry.IsIncomingReset()) {
+      std::optional<TarpitEntry::IncomingResetPayload> reset =
+          entry.TakeIncomingResetPayload();
+      GRPC_DCHECK(reset.has_value());
+      HandleStreamStateChange(
+          *stream, stream->OnResetReceived(std::move(reset->status)));
+    } else if (entry.IsOutgoingReset()) {
+      std::optional<TarpitEntry::OutgoingResetPayload> reset =
+          entry.TakeOutgoingResetPayload();
+      GRPC_DCHECK(reset.has_value());
+      BeginCloseStream(std::move(stream), reset->http2_error_code,
+                       std::move(reset->trailing_metadata_status),
+                       /*tarpit=*/false);
+    } else if (entry.IsOutgoingTrailingMetadata()) {
+      std::optional<TarpitEntry::OutgoingTrailingMetadataPayload> trailers =
+          entry.TakeOutgoingTrailingMetadataPayload();
+      GRPC_DCHECK(trailers.has_value());
+      const absl::StatusOr<StreamWritabilityUpdate> enqueue_result =
+          stream->EnqueueTrailingMetadata(std::move(trailers->metadata));
+      if (GPR_LIKELY(enqueue_result.ok())) {
+        GRPC_UNUSED const absl::Status status =
+            MaybeAddStreamToWritableStreamList(std::move(stream),
+                                               *enqueue_result);
+      } else {
+        HandleStreamStateChange(*stream,
+                                stream->ForceClose(absl::InternalError(
+                                    "Failed to enqueue trailing metadata")));
+      }
+    } else {
+      GRPC_DCHECK(false)
+          << "Http2ServerTransport::ActOnTarpitEntries unhandled tarpit entry "
+             "type for stream_id="
+          << entry.GetStreamId() << " entry=" << entry.DebugString();
+    }
+  }
+}
+
+auto Http2ServerTransport::MakeTarpitTimerLoop() {
+  return Loop([this]() {
+    return TrySeq(
+        tarpit_manager_.WaitForTimerExpire(),
+        [this]() {
+          ActOnTarpitEntries(tarpit_manager_.OnTimerExpired());
+          return absl::OkStatus();
+        },
+        []() -> LoopCtl<absl::Status> { return Continue(); });
+  });
+}
+
+auto Http2ServerTransport::MakeTarpitDrainLoop() {
+  return AllOk<absl::Status>(
+      Loop([this]() {
+        return Map(
+            tarpit_manager_.NextMessage(),
+            [this](auto&& result) -> LoopCtl<absl::Status> {
+              if (GPR_UNLIKELY(!result.ok())) {
+                return absl::CancelledError("Tarpit drain loop cancelled");
+              }
+              TarpitEntry msg = std::move(*result.value());
+              const RefCountedPtr<Stream> stream =
+                  LookupStream(msg.GetStreamId());
+              if (GPR_UNLIKELY(stream == nullptr || stream->IsStreamClosed())) {
+                GRPC_HTTP2_SERVER_DLOG
+                    << "Http2ServerTransport::MakeTarpitDrainLoop ignoring "
+                       "tarpit entry for already closed stream_id="
+                    << msg.GetStreamId();
+                return Continue();
+              }
+              if (GPR_UNLIKELY(stream->IsTarpitted())) {
+                GRPC_HTTP2_SERVER_DLOG
+                    << "Http2ServerTransport::MakeTarpitDrainLoop ignoring "
+                       "duplicate tarpit entry for stream_id="
+                    << msg.GetStreamId();
+                return Continue();
+              }
+              GRPC_HTTP2_SERVER_DLOG
+                  << "Http2ServerTransport::MakeTarpitDrainLoop enqueuing "
+                     "tarpit entry for stream_id="
+                  << msg.GetStreamId();
+
+              HandleStreamStateChange(*stream,
+                                      tarpit_manager_.OnTarpit(*stream));
+              tarpit_manager_.AddToQueue(std::move(msg));
+              return Continue();
+            });
+      }),
+      MakeTarpitTimerLoop());
+}
+
 //////////////////////////////////////////////////////////////////////////////
 // Error Path and Close Path
 
@@ -1631,7 +1790,7 @@ absl::Status Http2ServerTransport::HandleError(RefCountedPtr<Stream> stream,
                          << " status=" << status.DebugString()
                          << " location=" << whence.file() << ":"
                          << whence.line();
-  Http2Status::Http2ErrorType error_type = status.GetType();
+  const Http2Status::Http2ErrorType error_type = status.GetType();
   GRPC_DCHECK(error_type != Http2Status::Http2ErrorType::kOk);
 
   if (error_type == Http2Status::Http2ErrorType::kConnectionError) {
@@ -1640,11 +1799,12 @@ absl::Status Http2ServerTransport::HandleError(RefCountedPtr<Stream> stream,
     MaybeSpawnCloseTransport(std::move(status), whence);
     return absl_status;
   } else if (error_type == Http2Status::Http2ErrorType::kStreamError) {
-    uint32_t reset_stream_error_code =
+    const uint32_t reset_stream_error_code =
         Http2ErrorCodeToFrameErrorCode(status.GetStreamErrorCode());
     if (stream != nullptr) {
       BeginCloseStream(std::move(stream), reset_stream_error_code,
-                       status.GetAbslStreamError(), whence);
+                       status.GetAbslStreamError(), /*tarpit=*/true,
+                       /*override_tarpit=*/false, whence);
     }
     return absl::OkStatus();
   }
@@ -1652,6 +1812,64 @@ absl::Status Http2ServerTransport::HandleError(RefCountedPtr<Stream> stream,
   GPR_UNREACHABLE_CODE(return absl::InternalError("Invalid error type"));
 }
 
+void Http2ServerTransport::CloseAllActiveStreams(
+    absl::flat_hash_map<uint32_t, RefCountedPtr<Stream>>&& stream_list,
+    const Http2Status& http2_status, DebugLocation whence) {
+  // Close all the streams that are still active on the transport.
+  absl::flat_hash_map<uint32_t, RefCountedPtr<Stream>> stream_list_2;
+  {
+    MutexLock lock(&transport_mutex_);
+    stream_list_2 = std::move(stream_list_);
+    stream_list_.clear();
+  }
+
+  GRPC_HTTP2_SERVER_DLOG << "Http2ServerTransport::CloseAllActiveStreams "
+                            "Cleaning up call stacks";
+
+  auto close_streams =
+      [&](const absl::flat_hash_map<uint32_t, RefCountedPtr<Stream>>& list) {
+        for (const auto& pair : list) {
+          RefCountedPtr<Stream> stream = pair.second;
+          BeginCloseStream(std::move(stream),
+                           Http2ErrorCodeToFrameErrorCode(
+                               http2_status.GetConnectionErrorCode()),
+                           http2_status.GetAbslConnectionError(),
+                           /*tarpit=*/false, /*override_tarpit=*/true, whence);
+        }
+      };
+
+  close_streams(stream_list);    // Snapshot 1
+  close_streams(stream_list_2);  // Snapshot 2
+}
+
+auto Http2ServerTransport::CloseTransportFactory(
+    absl::flat_hash_map<uint32_t, RefCountedPtr<Stream>> stream_list,
+    Http2Status http2_status, DebugLocation whence) {
+  return [self = RefAsSubclass<Http2ServerTransport>(),
+          stream_list = std::move(stream_list),
+          http2_status = std::move(http2_status), whence]() mutable {
+    self->shutdown_tracker_.InitiatePartyShutdown();
+    self->security_frame_handler_->OnTransportClosed();
+
+    self->tarpit_manager_.Shutdown();
+    self->CloseAllActiveStreams(std::move(stream_list), http2_status, whence);
+
+    // Sleep for kGoawaySendTimeoutSeconds before closing the transport to
+    // let write buffers drain.
+    return Map(
+        Race(AssertResultType<absl::Status>(self->goaway_manager_.RequestGoaway(
+                 http2_status.GetConnectionErrorCode(),
+                 Slice::FromCopiedString(std::string(
+                     http2_status.GetAbslConnectionError().message())),
+                 self->last_incoming_stream_id_, /*immediate=*/true)),
+             Sleep(Duration::Seconds(kGoawaySendTimeoutSeconds))),
+        [self](absl::Status) mutable {
+          self->CloseTransport();
+          return Empty{};
+        });
+  };
+}
+
 void Http2ServerTransport::MaybeSpawnCloseTransport(Http2Status http2_status,
                                                     DebugLocation whence) {
   GRPC_HTTP2_SERVER_DLOG << "Http2ServerTransport::MaybeSpawnCloseTransport "
@@ -1661,13 +1879,13 @@ void Http2ServerTransport::MaybeSpawnCloseTransport(Http2Status http2_status,
                          << whence.line();
 
   ReleasableMutexLock lock(&transport_mutex_);
-  if (is_transport_closed_) {
+  if (shutdown_tracker_.IsShutdownInitiated(transport_mutex_)) {
     lock.Release();
     return;
   }
   GRPC_HTTP2_SERVER_DLOG << "Http2ServerTransport::MaybeSpawnCloseTransport "
                             "Initiating transport close";
-  is_transport_closed_ = true;
+  shutdown_tracker_.InitiateShutdown(transport_mutex_);
   absl::flat_hash_map<uint32_t, RefCountedPtr<Stream>> stream_list =
       std::move(stream_list_);
   stream_list_.clear();
@@ -1677,44 +1895,14 @@ void Http2ServerTransport::MaybeSpawnCloseTransport(Http2Status http2_status,
   lock.Release();
 
   SpawnInfallibleTransportParty(
-      "CloseTransport",
-      [self = RefAsSubclass<Http2ServerTransport>(),
-       stream_list = std::move(stream_list),
-       http2_status = std::move(http2_status), whence]() mutable {
-        self->security_frame_handler_->OnTransportClosed();
-        GRPC_HTTP2_SERVER_DLOG
-            << "Http2ServerTransport::MaybeSpawnCloseTransport "
-               "Cleaning up call stacks";
-        // Clean up the call stacks for all active streams.
-        for (const auto& pair : stream_list) {
-          RefCountedPtr<Stream> stream = pair.second;
-          self->BeginCloseStream(std::move(stream),
-                                 Http2ErrorCodeToFrameErrorCode(
-                                     http2_status.GetConnectionErrorCode()),
-                                 http2_status.GetAbslConnectionError(), whence);
-        }
-
-        // Sleep for kGoawaySendTimeoutSeconds before closing the transport to
-        // let write buffers drain.
-        return Map(
-            Race(AssertResultType<absl::Status>(
-                     self->goaway_manager_.RequestGoaway(
-                         http2_status.GetConnectionErrorCode(),
-                         Slice::FromCopiedString(std::string(
-                             http2_status.GetAbslConnectionError().message())),
-                         self->last_incoming_stream_id_, /*immediate=*/true)),
-                 Sleep(Duration::Seconds(kGoawaySendTimeoutSeconds))),
-            [self](auto) mutable {
-              self->CloseTransport();
-              return Empty{};
-            });
-      });
+      "CloseTransport", CloseTransportFactory(std::move(stream_list),
+                                              std::move(http2_status), whence));
 }
 
 void Http2ServerTransport::CloseTransport() {
   GRPC_HTTP2_SERVER_DLOG << "Http2ServerTransport::CloseTransport";
 
-  transport_closed_latch_.Set();
+  shutdown_tracker_.MarkShutdownComplete();
   settings_->HandleTransportShutdown(event_engine_.get());
 
   if (on_close_callback_ != nullptr) {
@@ -1722,7 +1910,7 @@ void Http2ServerTransport::CloseTransport() {
     on_close_callback_ = nullptr;
   }
 
-  general_party_.reset();
+  transport_party_.reset();
 }
 
 //////////////////////////////////////////////////////////////////////////////
@@ -1745,65 +1933,6 @@ void Http2ServerTransport::ReportDisconnectionLocked(
   NotifyStateWatcherOnDisconnectLocked(status, disconnect_info);
 }
 
-bool Http2ServerTransport::SetOnDone(RefCountedPtr<Stream> stream) {
-  // TODO(akshitpatel) : [PH2][P0] : Implement this.
-  return stream->GetCallInitiator().OnDone(
-      [self = RefAsSubclass<Http2ServerTransport>(),
-       stream = std::move(stream)](GRPC_UNUSED bool cancelled) mutable {});
-}
-//   return call_handler.OnDone([self = RefAsSubclass<Http2ServerTransport>(),
-//                               stream =
-//                                   std::move(stream)](bool cancelled) mutable
-//                                   {
-//     GRPC_HTTP2_SERVER_DLOG << "PH2: Client call " << self.get()
-//                            << " id=" << stream->GetStreamId()
-//                            << " done: cancelled=" << cancelled;
-//     absl::StatusOr<StreamWritabilityUpdate> enqueue_result;
-//     GRPC_HTTP2_SERVER_DLOG << "PH2: Client call " << self.get()
-//                            << " id=" << stream->GetStreamId()
-//                            << " done: stream=" << stream.get()
-//                            << " cancelled=" << cancelled;
-
-//     // If the stream is already closed for writes, then we don't need to
-//     // enqueue the reset stream or the half closed frame.
-//     if (stream->IsClosedForWrites()) {
-//       GRPC_HTTP2_SERVER_DLOG << "PH2: Client call " << self.get()
-//                              << " id=" << stream->GetStreamId()
-//                              << " done: stream already closed for writes";
-//       return;
-//     }
-
-//     if (cancelled) {
-//       // In most of the cases, EnqueueResetStream would be a no-op as
-//       // BeginCloseStream would have already enqueued the reset stream.
-//       // Currently only Aborts from application will actually enqueue
-//       // the reset stream here.
-//       enqueue_result = stream->EnqueueResetStream(
-//           static_cast<uint32_t>(Http2ErrorCode::kCancel));
-//       GRPC_HTTP2_SERVER_DLOG << "Enqueued ResetStream with error code="
-//                              <<
-//                              static_cast<uint32_t>(Http2ErrorCode::kCancel)
-//                              << " status=" << enqueue_result.status();
-//     } else {
-//       enqueue_result = stream->EnqueueHalfClosed();
-//       GRPC_HTTP2_SERVER_DLOG << "Enqueued HalfClosed with result="
-//                              << enqueue_result.status();
-//     }
-
-//     if (GPR_LIKELY(enqueue_result.ok())) {
-//       GRPC_HTTP2_SERVER_DLOG
-//           << "Http2ServerTransport::SetOnDone "
-//              "MaybeAddStreamToWritableStreamList for stream= "
-//           << stream->GetStreamId() << " enqueue_result={became_writable="
-//           << enqueue_result.value().became_writable << ", priority="
-//           << static_cast<uint8_t>(enqueue_result.value().priority) << "}";
-//       GRPC_UNUSED absl::Status status =
-//           self->MaybeAddStreamToWritableStreamList(std::move(stream),
-//                                                    enqueue_result.value());
-//     }
-//   });
-// }
-
 void Http2ServerTransport::ReadChannelArgs(const ChannelArgs& channel_args,
                                            TransportChannelArgs& args) {
   http2::ReadChannelArgs(channel_args, args, settings_->mutable_local(),
@@ -1916,10 +2045,13 @@ Http2ServerTransport::Http2ServerTransport(
       settings_(MakeRefCounted<SettingsPromiseManager>(
           kIsClient, std::move(on_receive_settings))),
       on_close_callback_(on_close_callback),
+      is_goaway_received_(false),
       should_reset_ping_clock_(false),
       read_context_(MaxNewStreamsPerRead(channel_args), endpoint_, kIsClient,
-                    GetMaxSecurityFrameSize(channel_args)),
+                    GetMaxSecurityFrameSize(channel_args),
+                    GetPingOnRstStreamPercent(channel_args, kIsClient)),
       transport_write_context_(kIsClient),
+      last_incoming_stream_id_(0),
       ping_manager_(std::nullopt),
       keepalive_manager_(std::nullopt),
       goaway_manager_(GoawayInterfaceImpl::Make(this)),
@@ -1931,19 +2063,20 @@ Http2ServerTransport::Http2ServerTransport(
           channel_args.GetBool(GRPC_ARG_HTTP2_BDP_PROBE).value_or(true),
           &memory_owner_),
       security_frame_handler_(MakeRefCounted<SecurityFrameHandler>()),
-      ztrace_collector_(std::make_shared<PromiseHttp2ZTraceCollector>()) {
+      ztrace_collector_(std::make_shared<PromiseHttp2ZTraceCollector>()),
+      tarpit_manager_(channel_args) {
   GRPC_HTTP2_SERVER_DLOG << "Http2ServerTransport Constructor Begin";
 
   // Initialize the general party and write party.
   RefCountedPtr<Arena> party_arena = SimpleArenaAllocator(0)->MakeArena();
   party_arena->SetContext<EventEngine>(event_engine_.get());
-  general_party_ = Party::Make(std::move(party_arena));
+  transport_party_ = Party::Make(std::move(party_arena));
 
   InitLocalSettings(settings_->mutable_local(), /*is_client=*/kIsClient);
   TransportChannelArgs args;
   ReadChannelArgs(channel_args, args);
 
-  ping_manager_.emplace(channel_args, args.ping_timeout,
+  ping_manager_.emplace(channel_args, kIsClient, args.ping_timeout,
                         PingSystemInterfaceImpl::Make(this), event_engine_);
 
   // The keepalive loop is only spawned if the keepalive time is not infinity.
@@ -1963,7 +2096,7 @@ Http2ServerTransport::Http2ServerTransport(
 Http2ServerTransport::~Http2ServerTransport() {
   GRPC_HTTP2_SERVER_DLOG << "Http2ServerTransport Destructor Begin";
   // GRPC_DCHECK(stream_list_.empty());
-  // GRPC_DCHECK(general_party_ == nullptr);
+  // GRPC_DCHECK(transport_party_ == nullptr);
   // memory_owner_.Reset();
 
   // TODO(akshitpatel) : [PH2][P0][Close] : Remove call to
@@ -2036,10 +2169,6 @@ void Http2ServerTransport::SpawnTransportLoops() {
   GRPC_HTTP2_SERVER_DLOG << "Http2ServerTransport::SpawnTransportLoops Begin";
   MaybeSpawnKeepaliveLoop();
 
-  // SpawnGuardedTransportParty(
-  //     "FlowControlPeriodicUpdateLoop",
-  //     UntilTransportClosed(FlowControlPeriodicUpdateLoop()));
-
   if (!TriggerWriteCycleOrHandleError()) {
     return;
   }
@@ -2049,6 +2178,10 @@ void Http2ServerTransport::SpawnTransportLoops() {
   SpawnGuardedTransportParty("ReadLoop", UntilTransportClosed(ReadLoop()));
   SpawnGuardedTransportParty("MultiplexerLoop",
                              UntilTransportClosed(MultiplexerLoop()));
+  if (tarpit_manager_.allow_tarpit()) {
+    SpawnGuardedTransportParty("TarpitDrainLoop",
+                               UntilTransportClosed(MakeTarpitDrainLoop()));
+  }
 
   GRPC_HTTP2_SERVER_DLOG << "Http2ServerTransport::SpawnTransportLoops End";
 }