grpc 1.83.1 → 1.84.0

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

@@ -161,7 +161,7 @@ class Http2ServerTransport final : public ServerTransport,
 
   template <typename Factory>
   void TestOnlySpawnPromise(absl::string_view name, Factory&& factory) {
-    SpawnInfallible(general_party_, name, std::forward<Factory>(factory));
+    SpawnInfallible(transport_party_, name, std::forward<Factory>(factory));
   }
 
   absl::Status TestOnlyTriggerWriteCycle() { return TriggerWriteCycle(); }
@@ -172,12 +172,16 @@ class Http2ServerTransport final : public ServerTransport,
   }
 
   int64_t TestOnlyTransportFlowControlWindow();
-  int64_t TestOnlyGetStreamFlowControlWindow(const uint32_t stream_id);
+  int64_t TestOnlyGetStreamFlowControlWindow(uint32_t stream_id);
 
   uint32_t TestOnlyLastIncomingStreamId() const {
     return last_incoming_stream_id_;
   }
 
+  Duration TestOnlyNextAllowedPingInterval() {
+    return NextAllowedPingInterval();
+  }
+
  private:
   //////////////////////////////////////////////////////////////////////////////
   // Endpoint Helpers
@@ -361,7 +365,7 @@ class Http2ServerTransport final : public ServerTransport,
                                             Poll<absl::Status>>,
                              bool> = true>
   auto UntilTransportClosed(Promise&& promise) {
-    return Race(Map(transport_closed_latch_.Wait(),
+    return Race(Map(shutdown_tracker_.WaitShutdownComplete(),
                     [self = RefAsSubclass<Http2ServerTransport>()](Empty) {
                       GRPC_HTTP2_SERVER_DLOG << "Transport closed";
                       return absl::CancelledError("Transport closed");
@@ -374,7 +378,7 @@ class Http2ServerTransport final : public ServerTransport,
                                             Poll<Empty>>,
                              bool> = true>
   auto UntilTransportClosed(Promise&& promise) {
-    return Race(Map(transport_closed_latch_.Wait(),
+    return Race(Map(shutdown_tracker_.WaitShutdownComplete(),
                     [self = RefAsSubclass<Http2ServerTransport>()](Empty) {
                       GRPC_HTTP2_SERVER_DLOG << "Transport closed";
                       return Empty{};
@@ -393,7 +397,7 @@ class Http2ServerTransport final : public ServerTransport,
   template <typename Factory>
   void SpawnInfallibleTransportParty(absl::string_view name,
                                      Factory&& factory) {
-    SpawnInfallible(general_party_, name, std::forward<Factory>(factory));
+    SpawnInfallible(transport_party_, name, std::forward<Factory>(factory));
   }
 
   // Spawns a promise on the transport party. If the promise returns a non-ok
@@ -401,7 +405,7 @@ class Http2ServerTransport final : public ServerTransport,
   // status.
   template <typename Factory>
   void SpawnGuardedTransportParty(absl::string_view name, Factory&& factory) {
-    general_party_->Spawn(
+    transport_party_->Spawn(
         name, std::forward<Factory>(factory),
         [self = RefAsSubclass<Http2ServerTransport>()](absl::Status status) {
           if (!status.ok()) {
@@ -414,8 +418,8 @@ class Http2ServerTransport final : public ServerTransport,
   template <typename Factory, typename OnDone>
   void SpawnWithOnDoneTransportParty(absl::string_view name, Factory&& factory,
                                      OnDone&& on_done) {
-    general_party_->Spawn(name, std::forward<Factory>(factory),
-                          std::forward<OnDone>(on_done));
+    transport_party_->Spawn(name, std::forward<Factory>(factory),
+                            std::forward<OnDone>(on_done));
   }
 
   //////////////////////////////////////////////////////////////////////////////
@@ -461,35 +465,26 @@ class Http2ServerTransport final : public ServerTransport,
       RefCountedPtr<Stream> stream,
       StreamDataQueue<ServerMetadataHandle>::StreamWritabilityUpdate result);
 
-  // Returns the number of active streams. A stream is removed from the `active`
-  // list once both client and server agree to close the stream. The count of
-  // stream_list_(even though stream list represents streams open for reads)
-  // works here because of the following cases where the stream is closed:
-  // 1. Reading a RST_STREAM frame: In this case, the stream is immediately
-  //    closed for reads and writes and removed from the stream_list_
-  //    (effectively tracking the number of active streams).
-  // 2. Reading a Trailing Metadata frame: In this case, the stream MAY be
-  //    closed for reads and writes immediately which follows the above case. In
-  //    other cases, the transport either reads RST_STREAM frame from the server
-  //    (and follows case 1) or sends a half close frame and closes the stream
-  //    for reads and writes (in the multiplexer loop).
-  // 3. Hitting error condition in the transport: In this case, RST_STREAM is
-  //    is enqueued and the stream is closed for reads immediately. This means
-  //    we effectively reduce the number of active streams inline (because we
-  //    remove the stream from the stream_list_). This is fine because the
-  //    priority logic in list of writable streams ensures that the RST_STREAM
-  //    frame is given priority over any new streams being created by the
-  //    client.
-  // 4. Application abort: In this case, multiplexer loop will write RST_STREAM
-  //    frame to the endpoint and close the stream from reads and writes. This
-  //    then follows the same reasoning as case 1.
-  inline uint32_t GetActiveStreamCountLocked() const
+  // Returns the number of active streams.
+  // A stream is removed from the `active` list once both client and server
+  // agree to close the stream.
+  uint32_t GetActiveStreamCountLocked() const
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(transport_mutex_) {
-    // TODO(tjagtap) : [PH2][P1] : Check if impl needs to change for server.
-    // TODO(tjagtap) : [PH2][P1] : Check if comment needs to change for server.
     return stream_list_.size();
   }
 
+  bool IsPingWithoutCallsAllowed() const {
+    return keepalive_permit_without_calls_;
+  }
+
+  bool IsTransportIdle() {
+    MutexLock lock(&transport_mutex_);
+    return GetActiveStreamCountLocked() == 0;
+  }
+
+  void EnqueueResetStreamFromTransportParty(RefCountedPtr<Stream> stream,
+                                            uint32_t reset_stream_error_code);
+
   //////////////////////////////////////////////////////////////////////////////
   // Stream Operations
 
@@ -497,7 +492,7 @@ class Http2ServerTransport final : public ServerTransport,
 
   // Runs on the call party.
   std::optional<RefCountedPtr<Stream>> MakeStream(
-      CallInitiator&& call_initiator, const uint32_t stream_id);
+      CallInitiator&& call_initiator, uint32_t stream_id);
 
   Http2Status IncomingStream(ClientMetadataHandle&& metadata,
                              uint32_t stream_id);
@@ -508,15 +503,24 @@ class Http2ServerTransport final : public ServerTransport,
   // reads. Writes will be closed by the write loop after the RST_STREAM frame
   // is written to the wire.
   // Prefer calling HandleError over this API.
+  // Note: Use override_tarpit with caution. This would bypass the TarpitManager
+  // and would result in immediate stream closure. Currently the use of this
+  // parameter is limited to two places:
+  // 1. Transport closure path.
+  // 2. Stream reset triggered by reclaimer.
   // Parameters:
   //   stream: The stream to close.
   //   reset_stream_error_code: The error code to use for the RST_STREAM frame.
   //   trailing_metadata_status: The failure status to propagate to the
   //                             application.
+  //   tarpit: Whether stream closure should be delayed via TarpitManager.
+  //   override_tarpit: When true, bypasses any ongoing tarpit delay or check
+  //                    and forces immediate reset frame emission and cleanup.
   //   whence: The location of the caller.
   void BeginCloseStream(RefCountedPtr<Stream> stream,
                         uint32_t reset_stream_error_code,
-                        absl::Status trailing_metadata_status,
+                        absl::Status trailing_metadata_status, bool tarpit,
+                        bool override_tarpit = false,
                         DebugLocation whence = {});
 
   // Handles stream state changes by discarding pending header parsing if reads
@@ -543,23 +547,31 @@ class Http2ServerTransport final : public ServerTransport,
   auto WaitForPingAck() { return ping_manager_->WaitForPingAck(); }
 
   Duration NextAllowedPingInterval() {
-    // TODO(akshitpatel) : [PH2][P1] : Add server logic.
-    return Duration::Zero();
+    if (goaway_manager_.IsGracefulGoawayInProgress()) {
+      return Duration::Zero();
+    }
+    return keepalive_time_ == Duration::Infinity() ? Duration::Seconds(20)
+                                                   : keepalive_time_ / 2;
   }
 
   absl::Status AckPing(uint64_t opaque_data);
 
   void MaybeSpawnKeepaliveLoop();
 
-  // uint32_t GetMaxAllowedStreamId() const;
-  // void SetMaxAllowedStreamId(uint32_t max_allowed_stream_id);
-
   //////////////////////////////////////////////////////////////////////////////
   // Error Path and Close Path
 
   void MaybeSpawnCloseTransport(Http2Status http2_status,
                                 DebugLocation whence = {});
 
+  auto CloseTransportFactory(
+      absl::flat_hash_map<uint32_t, RefCountedPtr<Stream>> stream_list,
+      Http2Status http2_status, DebugLocation whence = {});
+
+  void CloseAllActiveStreams(
+      absl::flat_hash_map<uint32_t, RefCountedPtr<Stream>>&& stream_list,
+      const Http2Status& http2_status, DebugLocation whence);
+
   // bool CanCloseTransportLocked() const
   //     ABSL_EXCLUSIVE_LOCKS_REQUIRED(transport_mutex_);
 
@@ -577,6 +589,15 @@ class Http2ServerTransport final : public ServerTransport,
   absl::Status HandleError(RefCountedPtr<Stream> stream, Http2Status status,
                            DebugLocation whence = {});
 
+  auto PingOnResetStream() {
+    read_context_.SetPingOnRstStreamInProgress(true);
+    TriggerWriteCycleOrHandleError();
+    return Map(ping_manager_->WaitForPingAck(), [this](absl::Status status) {
+      read_context_.SetPingOnRstStreamInProgress(false);
+      return Empty{};
+    });
+  }
+
   //////////////////////////////////////////////////////////////////////////////
   // Misc Transport Stuff
 
@@ -591,8 +612,6 @@ class Http2ServerTransport final : public ServerTransport,
                                  const char* reason)
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(&transport_mutex_);
 
-  bool SetOnDone(RefCountedPtr<Stream> stream);
-
   void ReadChannelArgs(const ChannelArgs& channel_args,
                        TransportChannelArgs& args);
 
@@ -616,6 +635,19 @@ class Http2ServerTransport final : public ServerTransport,
 
   auto SpawnGracefulGoawayPromise(Slice&& debug_data);
 
+  //////////////////////////////////////////////////////////////////////////////
+  // Tarpit
+
+  // Returns a promise running the tarpit drain loop which receives incoming
+  // tarpit entries and enqueues them into TarpitManager.
+  auto MakeTarpitDrainLoop();
+  // Returns a promise running the tarpit timer loop which waits for timer
+  // expiration and performs final actions on expired tarpit entries.
+  auto MakeTarpitTimerLoop();
+  // Performs final actions on expired tarpit entries (sending reset, trailing
+  // metadata, or cleaning up stream state).
+  void ActOnTarpitEntries(std::vector<TarpitEntry>&& entries);
+
   //////////////////////////////////////////////////////////////////////////////
   // Inner Classes and Structs
 
@@ -680,7 +712,8 @@ class Http2ServerTransport final : public ServerTransport,
 
   RefCountedPtr<UnstartedCallDestination> call_destination_;
 
-  RefCountedPtr<Party> general_party_;  // Refer AGENTS.md for party slot usage
+  // Refer AGENTS.md for party slot usage
+  RefCountedPtr<Party> transport_party_;
   std::shared_ptr<grpc_event_engine::experimental::EventEngine> event_engine_;
 
   PromiseEndpoint endpoint_;
@@ -692,14 +725,14 @@ class Http2ServerTransport final : public ServerTransport,
       ABSL_GUARDED_BY(transport_mutex_);
 
   HPackCompressor encoder_;
-  bool is_transport_closed_ ABSL_GUARDED_BY(transport_mutex_) = false;
-  Latch<void> transport_closed_latch_;
+  TransportShutdownTracker shutdown_tracker_;
   grpc_closure* on_close_callback_;
 
   ConnectivityStateTracker state_tracker_ ABSL_GUARDED_BY(transport_mutex_){
       "http2_server", GRPC_CHANNEL_READY};
 
   RefCountedPtr<StateWatcher> watcher_ ABSL_GUARDED_BY(transport_mutex_);
+  bool is_goaway_received_;
 
   bool should_reset_ping_clock_;
   ReadContext read_context_;
@@ -708,11 +741,8 @@ class Http2ServerTransport final : public ServerTransport,
   // transport during write cycles.
   TransportWriteContext transport_write_context_;
 
-  // Tracks the max allowed stream id. Currently this is only set on receiving a
-  // graceful GOAWAY frame.
-  GRPC_UNUSED uint32_t max_allowed_stream_id_ = RFC9113::kMaxStreamId31Bit;
   // Tracks last stream id received by the transport.
-  uint32_t last_incoming_stream_id_ = 0;
+  uint32_t last_incoming_stream_id_;
 
   // Duration between two consecutive keepalive pings.
   Duration keepalive_time_;
@@ -733,6 +763,7 @@ class Http2ServerTransport final : public ServerTransport,
 
   // TODO(tjagtap) [PH2][P2][BDP] Remove this when the BDP code is done.
   Waker periodic_updates_waker_;
+  TarpitManager tarpit_manager_;
 };
 
 // TODO(tjagtap) : [PH2][P1] : Handle the case where a Server receives two

data/src/core/ext/transport/chttp2/transport/http2_settings_promises.h

@@ -71,8 +71,7 @@ struct ApplySettingsResult {
   bool should_spawn_security_frame_loop = false;
 };
 
-// This class can only be used only from a promise based HTTP2 transports
-// general_party_ .
+// This class can only be used only from a promise based HTTP2 transports party.
 // This class is designed with the assumption that only 1 SETTINGS frame will be
 // in flight at a time. And we do not send a second SETTINGS frame till we
 // receive and process the SETTINGS ACK and resolve the ACK promise.

data/src/core/ext/transport/chttp2/transport/http2_status.h

@@ -208,7 +208,8 @@ class GRPC_MUST_USE_RESULT Http2Status {
   bool IsOk() const { return (http2_code_ == Http2ErrorCode::kNoError); }
 
   std::string DebugString() const {
-    return absl::StrCat(DebugGetType(), ": {Error Code:", DebugGetCode(),
+    return absl::StrCat(DebugGetType(),
+                        ": {Error Code:", DebugGetCode(http2_code_),
                         ", Message:", message_, "}");
   }
 
@@ -227,6 +228,42 @@ class GRPC_MUST_USE_RESULT Http2Status {
   Http2Status(const Http2Status&) = delete;
   Http2Status& operator=(const Http2Status&) = delete;
 
+  static absl::string_view DebugGetCode(Http2ErrorCode code) {
+    switch (code) {
+      case Http2ErrorCode::kNoError:
+        return "NO_ERROR";
+      case Http2ErrorCode::kProtocolError:
+        return "PROTOCOL_ERROR";
+      case Http2ErrorCode::kInternalError:
+        return "INTERNAL_ERROR";
+      case Http2ErrorCode::kFlowControlError:
+        return "FLOW_CONTROL_ERROR";
+      case Http2ErrorCode::kSettingsTimeout:
+        return "SETTINGS_TIMEOUT";
+      case Http2ErrorCode::kStreamClosed:
+        return "STREAM_CLOSED";
+      case Http2ErrorCode::kFrameSizeError:
+        return "FRAME_SIZE_ERROR";
+      case Http2ErrorCode::kRefusedStream:
+        return "REFUSED_STREAM";
+      case Http2ErrorCode::kCancel:
+        return "CANCEL";
+      case Http2ErrorCode::kCompressionError:
+        return "COMPRESSION_ERROR";
+      case Http2ErrorCode::kConnectError:
+        return "CONNECT_ERROR";
+      case Http2ErrorCode::kEnhanceYourCalm:
+        return "ENHANCE_YOUR_CALM";
+      case Http2ErrorCode::kInadequateSecurity:
+        return "INADEQUATE_SECURITY";
+      case Http2ErrorCode::kDoNotUse:
+        return "HTTP_1_1_REQUIRED";
+      default:
+        DCHECK(false);
+    }
+    GPR_UNREACHABLE_CODE(return "Invalid");
+  }
+
  private:
   explicit Http2Status()
       : http2_code_(Http2ErrorCode::kNoError),
@@ -284,42 +321,6 @@ class GRPC_MUST_USE_RESULT Http2Status {
     GPR_UNREACHABLE_CODE(return "Invalid");
   }
 
-  std::string DebugGetCode() const {
-    switch (http2_code_) {
-      case Http2ErrorCode::kNoError:
-        return "NO_ERROR";
-      case Http2ErrorCode::kProtocolError:
-        return "PROTOCOL_ERROR";
-      case Http2ErrorCode::kInternalError:
-        return "INTERNAL_ERROR";
-      case Http2ErrorCode::kFlowControlError:
-        return "FLOW_CONTROL_ERROR";
-      case Http2ErrorCode::kSettingsTimeout:
-        return "SETTINGS_TIMEOUT";
-      case Http2ErrorCode::kStreamClosed:
-        return "STREAM_CLOSED";
-      case Http2ErrorCode::kFrameSizeError:
-        return "FRAME_SIZE_ERROR";
-      case Http2ErrorCode::kRefusedStream:
-        return "REFUSED_STREAM";
-      case Http2ErrorCode::kCancel:
-        return "CANCEL";
-      case Http2ErrorCode::kCompressionError:
-        return "COMPRESSION_ERROR";
-      case Http2ErrorCode::kConnectError:
-        return "CONNECT_ERROR";
-      case Http2ErrorCode::kEnhanceYourCalm:
-        return "ENHANCE_YOUR_CALM";
-      case Http2ErrorCode::kInadequateSecurity:
-        return "INADEQUATE_SECURITY";
-      case Http2ErrorCode::kDoNotUse:
-        return "HTTP_1_1_REQUIRED";
-      default:
-        DCHECK(false);
-    }
-    GPR_UNREACHABLE_CODE(return "Invalid");
-  }
-
   const Http2ErrorCode http2_code_;
   const Http2ErrorType error_type_;
   const absl::StatusCode absl_code_;

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

@@ -21,18 +21,24 @@
 #include <grpc/event_engine/event_engine.h>
 #include <grpc/grpc.h>
 #include <grpc/impl/channel_arg_names.h>
+#include <grpc/support/port_platform.h>
 
 #include <algorithm>
 #include <climits>
+#include <cstddef>
 #include <cstdint>
+#include <limits>
 #include <memory>
 #include <optional>
 #include <string>
 #include <utility>
+#include <variant>
 #include <vector>
 
+#include "src/core/call/metadata.h"
 #include "src/core/call/metadata_info.h"
 #include "src/core/channelz/channelz.h"
+#include "src/core/channelz/property_list.h"
 #include "src/core/ext/transport/chttp2/transport/flow_control.h"
 #include "src/core/ext/transport/chttp2/transport/frame.h"
 #include "src/core/ext/transport/chttp2/transport/header_assembler.h"
@@ -42,17 +48,23 @@
 #include "src/core/ext/transport/chttp2/transport/http2_status.h"
 #include "src/core/ext/transport/chttp2/transport/internal_channel_arg_names.h"
 #include "src/core/ext/transport/chttp2/transport/stream.h"
+#include "src/core/ext/transport/chttp2/transport/transport_common.h"
 #include "src/core/ext/transport/chttp2/transport/write_cycle.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/event_engine/tcp_socket_utils.h"
+#include "src/core/lib/promise/status_flag.h"
 #include "src/core/lib/slice/slice_buffer.h"
 #include "src/core/util/grpc_check.h"
 #include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/time.h"
+#include "src/core/util/useful.h"
 #include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 
+#define GRPC_ARG_HTTP2_PING_ON_RST_STREAM_PERCENT \
+  "grpc.http2.ping_on_rst_stream_percent"
+
 namespace grpc_core {
 namespace http2 {
 
@@ -144,7 +156,7 @@ std::string TransportChannelArgs::DebugString() const {
 void ReadChannelArgs(const ChannelArgs& channel_args,
                      TransportChannelArgs& args, Http2Settings& local_settings,
                      chttp2::TransportFlowControl& flow_control,
-                     bool is_client) {
+                     const bool is_client) {
   ReadSettingsFromChannelArgs(channel_args, local_settings, flow_control,
                               is_client);
 
@@ -279,6 +291,14 @@ uint32_t GetMaxSecurityFrameSize(const ChannelArgs& channel_args) {
             static_cast<int>(GrpcErrors::kMaxSecurityFrameSize)));
 }
 
+uint8_t GetPingOnRstStreamPercent(const ChannelArgs& channel_args,
+                                  const bool is_client) {
+  if (is_client) return 0;
+  return Clamp(channel_args.GetInt(GRPC_ARG_HTTP2_PING_ON_RST_STREAM_PERCENT)
+                   .value_or(1),
+               0, 100);
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 // ChannelZ helpers
 
@@ -288,10 +308,12 @@ RefCountedPtr<channelz::SocketNode> CreateChannelzSocketNode(
     const ChannelArgs& args) {
   if (args.GetBool(GRPC_ARG_ENABLE_CHANNELZ)
           .value_or(GRPC_ENABLE_CHANNELZ_DEFAULT)) {
-    auto local_addr = grpc_event_engine::experimental::ResolvedAddressToString(
-        event_engine_endpoint->GetLocalAddress());
-    auto peer_addr = grpc_event_engine::experimental::ResolvedAddressToString(
-        event_engine_endpoint->GetPeerAddress());
+    absl::StatusOr<std::string> local_addr =
+        grpc_event_engine::experimental::ResolvedAddressToString(
+            event_engine_endpoint->GetLocalAddress());
+    absl::StatusOr<std::string> peer_addr =
+        grpc_event_engine::experimental::ResolvedAddressToString(
+            event_engine_endpoint->GetPeerAddress());
     GRPC_HTTP2_COMMON_DLOG << "CreateChannelzSocketNode: local_addr: "
                            << local_addr.value_or("unknown")
                            << " peer_addr: " << peer_addr.value_or("unknown");
@@ -324,6 +346,7 @@ ProcessIncomingDataFrameFlowControl(const Http2FrameHeader& frame_header,
                                     Stream* stream) {
   GRPC_DCHECK_EQ(frame_header.type, 0u);
   if (frame_header.length > 0) {
+    flow_control.OnReceiveDataFrame(frame_header.length);
     if (stream == nullptr) {
       // This flow control bookkeeping needs to happen even though the stream is
       // gone because otherwise we will go out-of-sync with the peer.
@@ -457,5 +480,155 @@ void MaybeAddStreamWindowUpdateFrame(Stream& stream,
   }
 }
 
+///////////////////////////////////////////////////////////////////////////////
+// TarpitEntry implementation
+
+std::string TarpitEntry::DebugString() const {
+  std::string payload_str;
+  const OutgoingResetPayload* const reset =
+      std::get_if<OutgoingResetPayload>(&payload_);
+  const OutgoingTrailingMetadataPayload* const trailers =
+      std::get_if<OutgoingTrailingMetadataPayload>(&payload_);
+  const IncomingResetPayload* const incoming_reset =
+      std::get_if<IncomingResetPayload>(&payload_);
+  if (reset != nullptr) {
+    payload_str = absl::StrCat(
+        "OutgoingReset(error_code=", reset->http2_error_code,
+        ", status=", reset->trailing_metadata_status.ToString(), ")");
+  } else if (trailers != nullptr) {
+    payload_str = absl::StrCat("OutgoingTrailingMetadata(",
+                               trailers->metadata != nullptr
+                                   ? trailers->metadata->DebugString()
+                                   : "null",
+                               ")");
+  } else if (incoming_reset != nullptr) {
+    payload_str = absl::StrCat(
+        "IncomingReset(status=", incoming_reset->status.ToString(), ")");
+  } else {
+    payload_str = "unknown type";
+  }
+  return absl::StrCat("TarpitEntry{stream_id=", stream_id_,
+                      ", expire_time=", expire_time_.ToString(),
+                      ", payload=", payload_str, "}");
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// TarpitManager implementation
+
+TarpitManager::TarpitManager(const ChannelArgs& channel_args)
+    : allow_tarpit_(
+          channel_args.GetBool(GRPC_ARG_HTTP_ALLOW_TARPIT).value_or(true)),
+      min_tarpit_duration_(
+          channel_args
+              .GetDurationFromIntMillis(GRPC_ARG_HTTP_TARPIT_MIN_DURATION_MS)
+              .value_or(Duration::Milliseconds(100))),
+      max_tarpit_duration_(
+          channel_args
+              .GetDurationFromIntMillis(GRPC_ARG_HTTP_TARPIT_MAX_DURATION_MS)
+              .value_or(Duration::Seconds(1))),
+      receiver_(std::numeric_limits<size_t>::max()),
+      sender_(receiver_.MakeSender()) {
+  GRPC_CHECK_LE(min_tarpit_duration_, max_tarpit_duration_);
+}
+
+Duration TarpitManager::GetTarpitDuration() const {
+  return TarpitDuration(static_cast<int>(min_tarpit_duration_.millis()),
+                        static_cast<int>(max_tarpit_duration_.millis()));
+}
+
+StatusFlag TarpitManager::RequestCloseStream(
+    const uint32_t stream_id, const uint32_t reset_stream_error_code,
+    absl::Status trailing_metadata_status) {
+  GRPC_DCHECK(allow_tarpit_);
+  GRPC_DCHECK_NE(stream_id, kInvalidStreamId);
+  GRPC_HTTP2_COMMON_DLOG << "TarpitManager::RequestCloseStream Stream id: "
+                         << stream_id << " reset_stream_error_code: "
+                         << reset_stream_error_code
+                         << " trailing_metadata_status: "
+                         << trailing_metadata_status;
+  const Timestamp expire_time = Timestamp::Now() + GetTarpitDuration();
+  TarpitEntry entry = TarpitEntry::CreateOutgoingReset(
+      stream_id, reset_stream_error_code, std::move(trailing_metadata_status),
+      expire_time);
+  const StatusFlag status =
+      sender_.UnbufferedImmediateSend(std::move(entry), 1);
+  return status;
+}
+
+StatusFlag TarpitManager::StartTarpitTrailers(const uint32_t stream_id,
+                                              ServerMetadataHandle metadata) {
+  GRPC_DCHECK(allow_tarpit_);
+  GRPC_DCHECK_NE(stream_id, kInvalidStreamId);
+  GRPC_HTTP2_COMMON_DLOG << "TarpitManager::StartTarpitTrailers Stream id: "
+                         << stream_id;
+  const Timestamp expire_time = Timestamp::Now() + GetTarpitDuration();
+  TarpitEntry entry = TarpitEntry::CreateOutgoingTrailingMetadata(
+      stream_id, std::move(metadata), expire_time);
+  const StatusFlag status =
+      sender_.UnbufferedImmediateSend(std::move(entry), 1);
+  return status;
+}
+
+StatusFlag TarpitManager::RequestTarpitIncomingReset(const uint32_t stream_id,
+                                                     absl::Status status) {
+  GRPC_DCHECK(allow_tarpit_);
+  GRPC_DCHECK_NE(stream_id, kInvalidStreamId);
+  GRPC_HTTP2_COMMON_DLOG
+      << "TarpitManager::RequestTarpitIncomingReset Stream id: " << stream_id
+      << " status: " << status;
+
+  const Timestamp expire_time = Timestamp::Now() + GetTarpitDuration();
+  TarpitEntry entry = TarpitEntry::CreateIncomingReset(
+      stream_id, std::move(status), expire_time);
+  const StatusFlag send_status =
+      sender_.UnbufferedImmediateSend(std::move(entry), 1);
+  return send_status;
+}
+
+StreamStateChange TarpitManager::OnTarpit(Stream& stream) {
+  stream.SetTarpitActive();
+  return stream.OnInitiateReset(absl::CancelledError("Stream tarpitted"));
+}
+
+void TarpitManager::AddToQueue(TarpitEntry&& entry) {
+  if (GPR_UNLIKELY(shutdown_)) {
+    return;
+  }
+  tarpit_queue_.Push(std::forward<TarpitEntry>(entry));
+  empty_queue_waker_.Wakeup();
+}
+
+std::vector<TarpitEntry> TarpitManager::OnTimerExpired() {
+  const Timestamp now = Timestamp::Now();
+  std::vector<TarpitEntry> expired_entries;
+  while (!tarpit_queue_.IsEmpty() &&
+         tarpit_queue_.Top().GetExpireTime() <= now) {
+    expired_entries.push_back(tarpit_queue_.Pop());
+  }
+  return expired_entries;
+}
+
+void TarpitManager::Shutdown() {
+  shutdown_ = true;
+  tarpit_queue_.Clear();
+  receiver_.MarkClosed();
+  empty_queue_waker_.Wakeup();
+}
+
+channelz::PropertyList TarpitManager::ChannelzProperties() const {
+  channelz::PropertyList properties;
+  properties.Set("allow_tarpit", allow_tarpit_)
+      .Set("min_tarpit_duration", min_tarpit_duration_)
+      .Set("max_tarpit_duration", max_tarpit_duration_)
+      .Set("is_shutdown", shutdown_)
+      .Set("current_tarpitted_streams_count", tarpit_queue_.Size())
+      .Set("is_queue_empty", tarpit_queue_.IsEmpty());
+  if (!tarpit_queue_.IsEmpty()) {
+    properties.Set("earliest_expiration_time",
+                   tarpit_queue_.Top().GetExpireTime());
+  }
+  return properties;
+}
+
 }  // namespace http2
 }  // namespace grpc_core