grpc 1.83.1 → 1.84.0

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

@@ -19,24 +19,45 @@
 #ifndef GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HTTP2_TRANSPORT_H
 #define GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HTTP2_TRANSPORT_H
 
+#include <grpc/event_engine/event_engine.h>
+
+#include <algorithm>
 #include <cstdint>
+#include <functional>
+#include <memory>
+#include <optional>
+#include <queue>
 #include <string>
 #include <type_traits>
+#include <utility>
+#include <variant>
+#include <vector>
 
+#include "src/core/call/metadata.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/hpack_parser.h"
 #include "src/core/ext/transport/chttp2/transport/http2_settings.h"
 #include "src/core/ext/transport/chttp2/transport/http2_status.h"
 #include "src/core/ext/transport/chttp2/transport/stream.h"
 #include "src/core/ext/transport/chttp2/transport/write_cycle.h"
+#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/promise/activity.h"
-#include "src/core/lib/promise/poll.h"
+#include "src/core/lib/promise/context.h"
+#include "src/core/lib/promise/for_each.h"
+#include "src/core/lib/promise/if.h"
+#include "src/core/lib/promise/latch.h"
+#include "src/core/lib/promise/loop.h"
+#include "src/core/lib/promise/mpsc.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/slice/slice.h"
 #include "src/core/util/ref_counted_ptr.h"
+#include "src/core/util/sync.h"
+#include "src/core/util/time.h"
 #include "absl/log/log.h"
-#include "absl/status/status.h"
 
 namespace grpc_core {
 namespace http2 {
@@ -75,7 +96,7 @@ inline bool ShouldEnablePh2Server() {
   return IsPh2ServerEnabled() || IsPh2ClientServerEnabled();
 }
 
-// TODO(akshitpatel) [PH2][P3] : Write a way to measure the total size of a
+// TODO(akshitpatel) [PH2][P5] : Write a way to measure the total size of a
 // transport object. Reference :
 // https://github.com/grpc/grpc/pull/41294/files#diff-c685cc4847f228327938326e2a45083a2d0845bacff0ac004bd802027a670c4e
 
@@ -91,7 +112,7 @@ template <typename T, typename Tracker>
 inline Http2Status ValidateMetadataFrameState(
     T& frame, Stream& stream, Tracker& incoming_headers,
     const uint32_t max_header_list_size) {
-  if (stream.IsStreamHalfClosedRemote()) {
+  if (stream.IsClosedForReads()) {
     return incoming_headers.ParseAndDiscardHeaders(
         std::move(frame.payload), frame.end_headers,
         Http2Status::Http2StreamError(
@@ -153,6 +174,11 @@ uint32_t MaxNewStreamsPerRead(const ChannelArgs& channel_args);
 
 uint32_t GetMaxSecurityFrameSize(const ChannelArgs& channel_args);
 
+// Returns the percentage of RST streams on which we should send a ping.
+// Always returns 0 for client transport.
+uint8_t GetPingOnRstStreamPercent(const ChannelArgs& channel_args,
+                                  bool is_client);
+
 ///////////////////////////////////////////////////////////////////////////////
 // ChannelZ helpers
 
@@ -183,7 +209,321 @@ void MaybeAddTransportWindowUpdateFrame(
 
 void MaybeAddStreamWindowUpdateFrame(Stream& stream, FrameSender& frame_sender);
 
+// ===========================================================================
+// 3-Stage Transport Shutdown State Machine
+// ===========================================================================
+// Transport shutdown progresses through three distinct stages to ensure
+// thread-safe, lock-free (where possible), and protocol-compliant cleanup.
+//
+// Stage 1: Shutdown Initiated
+//   Triggered by MaybeSpawnCloseTransport(). Rejects new external watches
+//   and immediately clears stream_list_ (Snapshot 1) to stop read/write
+//   processing for active streams.
+//   Note: MaybeSpawnCloseTransport is invoked from both transport party and
+//   other threads (Orphan flow).
+//
+// Stage 2: Party Shutdown Initiated (Party Lockdown)
+//   Triggered when the CloseTransport promise starts running on the transport
+//   party. Thread-confined to the party (no locks/atomics needed).
+//   Clears stream_list_ again (Snapshot 2) to capture raced streams, and
+//   causes the transport to immediately reject any new or queued streams
+//   (via InitializeStream() on client, or IncomingStream() on server).
 //
+// Stage 3: Shutdown Completed (Final Termination)
+//   Triggered when CloseTransport() finishes (GOAWAY sent or timed out on
+//   client). Wakes up and cancels all remaining promises on the transport
+//   party.
+// ===========================================================================
+class TransportShutdownTracker {
+ public:
+  TransportShutdownTracker() = default;
+
+  // Transport shutdown is not copyable or movable.
+  TransportShutdownTracker(const TransportShutdownTracker&) = delete;
+  TransportShutdownTracker& operator=(const TransportShutdownTracker&) = delete;
+  TransportShutdownTracker(TransportShutdownTracker&&) = delete;
+  TransportShutdownTracker& operator=(TransportShutdownTracker&&) = delete;
+
+  // Stage 1: Shutdown Initiated
+  void InitiateShutdown(const Mutex& mu) ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu) {
+    shutdown_initiated_ = true;
+  }
+  bool IsShutdownInitiated(const Mutex& mu) const
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu) {
+    return shutdown_initiated_;
+  }
+
+  // Stage 2: Party Shutdown Initiated (Party Lockdown)
+  void InitiatePartyShutdown() { party_shutdown_initiated_ = true; }
+  bool IsPartyShutdownInitiated() const { return party_shutdown_initiated_; }
+
+  // Stage 3: Shutdown Completed (Final Termination)
+  void MarkShutdownComplete() { shutdown_completed_latch_.Set(); }
+  auto WaitShutdownComplete() { return shutdown_completed_latch_.Wait(); }
+
+ private:
+  bool shutdown_initiated_ = false;
+  bool party_shutdown_initiated_ = false;
+  Latch<void> shutdown_completed_latch_;
+};
+
+// Represents a stream queued for tarpitting and its scheduled expiration time.
+// The payload variant defines the terminal action to perform once the tarpit
+// duration elapses:
+// - OutgoingResetPayload: sends a delayed RST_STREAM.
+// - OutgoingTrailingMetadataPayload: sends delayed server trailing metadata.
+// - IncomingResetPayload: Stream closure triggered by Client sending an
+//   RST_STREAM.
+// The functions in this class are not thread-safe.
+class TarpitEntry {
+ public:
+  struct OutgoingResetPayload {
+    absl::Status trailing_metadata_status;
+    uint32_t http2_error_code = 0;
+  };
+
+  struct OutgoingTrailingMetadataPayload {
+    ServerMetadataHandle metadata;
+  };
+
+  struct IncomingResetPayload {
+    absl::Status status;
+  };
+
+  TarpitEntry(TarpitEntry&&) = default;
+  TarpitEntry& operator=(TarpitEntry&&) = default;
+  TarpitEntry(const TarpitEntry&) = delete;
+  TarpitEntry& operator=(const TarpitEntry&) = delete;
+
+  // Factory methods for constructing tarpit entries from producers across
+  // different parties.
+  static TarpitEntry CreateOutgoingReset(const uint32_t stream_id,
+                                         const uint32_t http2_error_code,
+                                         absl::Status trailing_metadata_status,
+                                         const Timestamp expire_time) {
+    return TarpitEntry(stream_id,
+                       OutgoingResetPayload{std::move(trailing_metadata_status),
+                                            http2_error_code},
+                       expire_time);
+  }
+  static TarpitEntry CreateOutgoingTrailingMetadata(
+      const uint32_t stream_id, ServerMetadataHandle metadata,
+      const Timestamp expire_time) {
+    return TarpitEntry(stream_id,
+                       OutgoingTrailingMetadataPayload{std::move(metadata)},
+                       expire_time);
+  }
+  static TarpitEntry CreateIncomingReset(const uint32_t stream_id,
+                                         absl::Status status,
+                                         const Timestamp expire_time) {
+    return TarpitEntry(stream_id, IncomingResetPayload{std::move(status)},
+                       expire_time);
+  }
+
+  Timestamp GetExpireTime() const { return expire_time_; }
+  uint32_t GetStreamId() const { return stream_id_; }
+
+  bool IsOutgoingReset() const {
+    return std::holds_alternative<OutgoingResetPayload>(payload_);
+  }
+  bool IsOutgoingTrailingMetadata() const {
+    return std::holds_alternative<OutgoingTrailingMetadataPayload>(payload_);
+  }
+  bool IsIncomingReset() const {
+    return std::holds_alternative<IncomingResetPayload>(payload_);
+  }
+
+  // Consumes and extracts the payload when executing the post-tarpit action.
+  // Returns std::nullopt if the payload type does not match.
+  std::optional<OutgoingResetPayload> TakeOutgoingResetPayload() {
+    OutgoingResetPayload* const p =
+        std::get_if<OutgoingResetPayload>(&payload_);
+    if (p != nullptr) {
+      return std::move(*p);
+    }
+    return std::nullopt;
+  }
+  std::optional<OutgoingTrailingMetadataPayload>
+  TakeOutgoingTrailingMetadataPayload() {
+    OutgoingTrailingMetadataPayload* const p =
+        std::get_if<OutgoingTrailingMetadataPayload>(&payload_);
+    if (p != nullptr) {
+      return std::move(*p);
+    }
+    return std::nullopt;
+  }
+  std::optional<IncomingResetPayload> TakeIncomingResetPayload() {
+    IncomingResetPayload* const p =
+        std::get_if<IncomingResetPayload>(&payload_);
+    if (p != nullptr) {
+      return std::move(*p);
+    }
+    return std::nullopt;
+  }
+
+  std::string DebugString() const;
+
+  bool operator>(const TarpitEntry& other) const {
+    return expire_time_ > other.expire_time_;
+  }
+
+ private:
+  using Payload =
+      std::variant<OutgoingResetPayload, OutgoingTrailingMetadataPayload,
+                   IncomingResetPayload>;
+
+  TarpitEntry(const uint32_t stream_id, Payload payload,
+              const Timestamp expire_time)
+      : stream_id_(stream_id),
+        expire_time_(expire_time),
+        payload_(std::move(payload)) {}
+
+  uint32_t stream_id_ = 0;
+  Timestamp expire_time_ = Timestamp::InfPast();
+  Payload payload_;
+};
+
+class TarpitQueue {
+ public:
+  TarpitQueue() = default;
+  TarpitQueue(const TarpitQueue&) = delete;
+  TarpitQueue& operator=(const TarpitQueue&) = delete;
+  TarpitQueue(TarpitQueue&&) = default;
+  TarpitQueue& operator=(TarpitQueue&&) = default;
+
+  bool IsEmpty() const { return entries_.empty(); }
+  size_t Size() const { return entries_.size(); }
+
+  const TarpitEntry& Top() const {
+    GRPC_DCHECK(!entries_.empty());
+    return entries_.front();
+  }
+
+  void Push(TarpitEntry entry) {
+    entries_.push_back(std::move(entry));
+    std::push_heap(entries_.begin(), entries_.end(), std::greater<>());
+  }
+
+  TarpitEntry Pop() {
+    GRPC_DCHECK(!entries_.empty());
+    std::pop_heap(entries_.begin(), entries_.end(), std::greater<>());
+    TarpitEntry top_entry = std::move(entries_.back());
+    entries_.pop_back();
+    return top_entry;
+  }
+
+  void Clear() { entries_.clear(); }
+
+ private:
+  std::vector<TarpitEntry> entries_;
+};
+
+class TarpitManager {
+ public:
+  explicit TarpitManager(const ChannelArgs& channel_args);
+
+  ~TarpitManager() = default;
+
+  // TarpitManager is neither copyable nor movable.
+  TarpitManager(const TarpitManager&) = delete;
+  TarpitManager& operator=(const TarpitManager&) = delete;
+  TarpitManager(TarpitManager&&) = delete;
+  TarpitManager& operator=(TarpitManager&&) = delete;
+
+  //----------------------------------------------------------------------------
+  // Off-Party Producer Methods (Can be called from any thread/party)
+  //----------------------------------------------------------------------------
+
+  // Producer APIs called by the transport to enqueue delayed stream actions.
+  //
+  // Note:
+  // - Callers MUST verify allow_tarpit() is true before invoking these APIs.
+  // - Returns StatusFlag::kFailure if the MPSC channel is closed or full, in
+  //   which case the caller MUST initiate transport teardown (connection
+  //   error). In theory the MPSC queue can never be full , because it cannot
+  //   have more than MAX_CONCURRENT_STREAMS number of streams in it.
+
+  // Sends a delayed RST_STREAM.
+  StatusFlag RequestCloseStream(uint32_t stream_id,
+                                uint32_t reset_stream_error_code,
+                                absl::Status trailing_metadata_status);
+
+  // Sends delayed server trailing metadata.
+  StatusFlag StartTarpitTrailers(uint32_t stream_id,
+                                 ServerMetadataHandle metadata);
+
+  // Performs delayed stream closure following an incoming RST_STREAM.
+  StatusFlag RequestTarpitIncomingReset(uint32_t stream_id,
+                                        absl::Status status);
+
+  //----------------------------------------------------------------------------
+  // Transport-Party Confined Methods (Must be run on TransportParty)
+  //----------------------------------------------------------------------------
+
+  // Prepares an incoming Stream on the transport party by marking the stream
+  // tarpitted and initiating read-silencing. Returns the StreamStateChange to
+  // be handled by the server transport.
+  StreamStateChange OnTarpit(Stream& stream);
+
+  void AddToQueue(TarpitEntry&& entry);
+  std::vector<TarpitEntry> OnTimerExpired();
+  void Shutdown();
+
+  channelz::PropertyList ChannelzProperties() const;
+
+  bool allow_tarpit() const { return allow_tarpit_; }
+
+  auto NextMessage() { return receiver_.Next(); }
+
+  // Returns a promise that waits for the earliest expiration time of tarpitted
+  // streams, or suspends if the queue is empty.
+  auto WaitForTimerExpire() {
+    return If(
+        [this]() -> Poll<bool> {
+          if (GPR_UNLIKELY(shutdown_)) {
+            return false;
+          }
+          if (tarpit_queue_.IsEmpty()) {
+            empty_queue_waker_ = GetContext<Activity>()->MakeNonOwningWaker();
+            return Pending{};
+          }
+          return true;
+        },
+        [this]() {
+          // Sleep at least for kMinTarpitSleepDuration to avoid potential
+          // busy-looping if there are lot of entries with expiration time in
+          // near future. This works for the tarpit use case as this guarantees
+          // we would close stream strictly after the expiration time.
+          return Sleep(std::max(tarpit_queue_.Top().GetExpireTime(),
+                                Timestamp::Now() + kMinTarpitSleepDuration));
+        },
+        []() -> Poll<absl::Status> {
+          return absl::CancelledError("TarpitManager shutdown");
+        });
+  }
+
+ private:
+  static constexpr Duration kMinTarpitSleepDuration =
+      Duration::Milliseconds(10);
+
+  Duration GetTarpitDuration() const;
+
+  const bool allow_tarpit_ = true;
+  const Duration min_tarpit_duration_;
+  const Duration max_tarpit_duration_;
+  bool shutdown_ = false;
+
+  MpscReceiver<TarpitEntry> receiver_;
+  MpscSender<TarpitEntry> sender_;
+
+  // Queue ordered by earliest expiration time for pending tarpitted streams.
+  TarpitQueue tarpit_queue_;
+
+  // Waker for resuming WaitForTimerExpire when transitioning from an empty
+  // queue to a non-empty queue.
+  Waker empty_queue_waker_;
+};
+
 }  // namespace http2
 }  // namespace grpc_core
 

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

@@ -544,7 +544,7 @@ static grpc_error_handle init_header_skip_frame_parser(
       t->settings.acked().max_header_list_size(),
       hpack_boundary_type(t, is_eoh), priority_type,
       hpack_parser_log_info(t, HPackParser::LogInfo::kDontKnow),
-      t->mitigation_engine.get());
+      t->mitigation_engine.get(), t->peer_string.as_string_view());
   return absl::OkStatus();
 }
 
@@ -631,8 +631,7 @@ error_handler:
     return absl::OkStatus();
   } else if (s != nullptr) {
     // handle stream errors by closing the stream
-    grpc_chttp2_mark_stream_closed(t, s, true, false,
-                                   absl_status_to_grpc_error(status));
+    grpc_chttp2_mark_stream_closed(t, s, true, false, status);
     grpc_error_handle rst_error = grpc_chttp2_add_rst_stream_to_next_write(
         t, t->incoming_stream_id,
         static_cast<uint32_t>(Http2ErrorCode::kProtocolError),
@@ -640,7 +639,7 @@ error_handler:
     if (GPR_UNLIKELY(!rst_error.ok())) return rst_error;
     return init_non_header_skip_frame_parser(t);
   } else {
-    return absl_status_to_grpc_error(status);
+    return status;
   }
 }
 
@@ -895,7 +894,8 @@ static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
                              t->settings.acked().max_header_list_size(),
                              hpack_boundary_type(t, is_eoh), priority_type,
                              hpack_parser_log_info(t, frame_type),
-                             t->mitigation_engine.get());
+                             t->mitigation_engine.get(),
+                             t->peer_string.as_string_view());
   return absl::OkStatus();
 }
 

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

@@ -61,12 +61,13 @@ Promise<absl::Status> PingManager::PingPromiseCallbacks::WaitForPingAck() {
 }
 
 // Ping System implementation
-PingManager::PingManager(const ChannelArgs& channel_args, Duration ping_timeout,
+PingManager::PingManager(const ChannelArgs& channel_args, const bool is_client,
+                         Duration ping_timeout,
                          std::unique_ptr<PingInterface> ping_interface,
                          std::shared_ptr<EventEngine> event_engine)
     : ping_callbacks_(event_engine),
       ping_abuse_policy_(channel_args),
-      ping_rate_policy_(channel_args, /*is_client=*/true),
+      ping_rate_policy_(channel_args, is_client),
       ping_interface_(std::move(ping_interface)),
       ping_timeout_(ping_timeout) {}
 

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

@@ -22,6 +22,7 @@
 #include <cstdint>
 #include <memory>
 #include <optional>
+#include <string>
 #include <utility>
 #include <vector>
 
@@ -46,6 +47,7 @@
 #include "absl/functional/any_invocable.h"
 #include "absl/log/log.h"
 #include "absl/status/status.h"
+#include "absl/strings/str_cat.h"
 
 namespace grpc_core {
 namespace http2 {
@@ -120,12 +122,14 @@ class PingManager {
       important_ping_requested_ = false;
       return ping_callbacks_.StartPing(SharedBitGen());
     }
-    bool PingRequested() { return ping_callbacks_.ping_requested(); }
+    bool PingRequested() const { return ping_callbacks_.ping_requested(); }
     bool ImportantPingRequested() const { return important_ping_requested_; }
     bool AckPing(uint64_t id) {
       return ping_callbacks_.AckPing(id, event_engine_.get());
     }
-    size_t CountPingInflight() { return ping_callbacks_.pings_inflight(); }
+    size_t CountPingInflight() const {
+      return ping_callbacks_.pings_inflight();
+    }
 
     auto PingTimeout(Duration ping_timeout) {
       std::shared_ptr<InterActivityLatch<void>> latch =
@@ -184,7 +188,8 @@ class PingManager {
   void SentPing() { ping_rate_policy_.SentPing(); }
 
  public:
-  PingManager(const ChannelArgs& channel_args, Duration ping_timeout,
+  PingManager(const ChannelArgs& channel_args, bool is_client,
+              Duration ping_timeout,
               std::unique_ptr<PingInterface> ping_interface,
               std::shared_ptr<grpc_event_engine::experimental::EventEngine>
                   event_engine);
@@ -209,6 +214,19 @@ class PingManager {
     return ping_abuse_policy_.ReceivedOnePing(transport_idle);
   }
 
+  std::string GetDebugString(const bool transport_idle) const {
+    return absl::StrCat(
+        "delayed_ping_spawned: ", delayed_ping_spawned_, ", opaque_data: ",
+        opaque_data_.has_value() ? absl::StrCat(opaque_data_.value()) : "none",
+        ", pending_ping_acks: ", pending_ping_acks_.size(),
+        ", ping_timeout: ", ping_timeout_.ToString(),
+        ", ping_requested: ", PingRequested(),
+        ", important_ping_requested: ", ImportantPingRequested(),
+        ", pings_inflight: ", CountPingInflight(), ", ping_rate_policy: { ",
+        ping_rate_policy_.GetDebugString(), " }, ping_abuse_policy: { ",
+        ping_abuse_policy_.GetDebugString(transport_idle), " }");
+  }
+
   void ResetPingClock(bool is_client) {
     if (!is_client) {
       ping_abuse_policy_.ResetPingStrikes();
@@ -235,12 +253,14 @@ class PingManager {
   void CancelCallbacks() { ping_callbacks_.CancelCallbacks(); }
 
   uint64_t StartPing() { return ping_callbacks_.StartPing(); }
-  bool PingRequested() { return ping_callbacks_.PingRequested(); }
+  bool PingRequested() const { return ping_callbacks_.PingRequested(); }
   bool ImportantPingRequested() const {
     return ping_callbacks_.ImportantPingRequested();
   }
   bool AckPing(uint64_t id) { return ping_callbacks_.AckPing(id); }
-  size_t CountPingInflight() { return ping_callbacks_.CountPingInflight(); }
+  size_t CountPingInflight() const {
+    return ping_callbacks_.CountPingInflight();
+  }
 
   Http2Frame GetHttp2PingFrame(uint64_t opaque_data) {
     return Http2PingFrame{/*ack=*/false, opaque_data};

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

@@ -43,10 +43,9 @@ Chttp2PingRatePolicy::Chttp2PingRatePolicy(const ChannelArgs& args,
               : 0),
       // Configuration via channel arg dominates, otherwise if the multiping
       // experiment is enabled we use 100, otherwise 1.
-      max_inflight_pings_(
-          std::max(0, args.GetInt(GRPC_ARG_HTTP2_MAX_INFLIGHT_PINGS)
-                          .value_or(g_default_max_inflight_pings.value_or(
-                              IsMultipingEnabled() ? 100 : 1)))) {}
+      max_inflight_pings_(std::max(
+          0, args.GetInt(GRPC_ARG_HTTP2_MAX_INFLIGHT_PINGS)
+                 .value_or(g_default_max_inflight_pings.value_or(1)))) {}
 
 void Chttp2PingRatePolicy::SetDefaults(const ChannelArgs& args) {
   g_default_max_pings_without_data_sent =

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

@@ -37,14 +37,20 @@
 #include "src/core/lib/transport/promise_endpoint.h"
 #include "src/core/util/debug_location.h"
 #include "src/core/util/grpc_check.h"
+#include "src/core/util/shared_bit_gen.h"
 #include "absl/log/log.h"
-#include "absl/status/statusor.h"
+#include "absl/random/distributions.h"
 #include "absl/strings/str_cat.h"
 
 namespace grpc_core {
 namespace http2 {
 constexpr uint32_t kCurrentCycleMaxResetStreams = 1024u;
 
+inline bool ShouldSendPingOnRstStream(
+    const uint8_t ping_on_rst_stream_percent) {
+  return absl::Bernoulli(SharedBitGen(), ping_on_rst_stream_percent / 100.0);
+}
+
 class ReadLoopPauseRestart {
  public:
   ReadLoopPauseRestart() = default;
@@ -166,14 +172,20 @@ class IncomingMetadataState {
   uint32_t stream_id_ = 0;
 };
 
+struct ShouldSendPing {
+  bool should_send_ping_on_rst_stream = false;
+};
+
 class ReadContext {
  public:
   explicit ReadContext(const uint32_t max_new_streams_per_read_cycle,
                        const PromiseEndpoint& endpoint, const bool is_client,
-                       const uint32_t max_security_frame_size)
+                       const uint32_t max_security_frame_size,
+                       const uint8_t ping_on_rst_stream_percent)
       : max_new_streams_per_read_cycle_(max_new_streams_per_read_cycle),
         peer_string_(GetPeerString(endpoint)),
         is_client_(is_client),
+        ping_on_rst_stream_percent_(ping_on_rst_stream_percent),
         max_security_frame_size_(max_security_frame_size),
         header_assembler_(is_client) {
     GRPC_DCHECK(max_new_streams_per_read_cycle > 0u)
@@ -296,7 +308,20 @@ class ReadContext {
   void OnPingFrameReceived() { IncrementInducedFrames(); }
 
   // Called when we read a RST_STREAM frame from the peer.
-  void OnResetFrameReceived() { IncrementResetStreamFrames(); }
+  // Returns true if a ping should be sent in response.
+  ShouldSendPing OnResetFrameReceived() {
+    IncrementResetStreamFrames();
+    if (ping_on_rst_stream_percent_ > 0 && !ping_on_rst_stream_in_progress_ &&
+        ShouldSendPingOnRstStream(ping_on_rst_stream_percent_)) {
+      IncrementInducedFrames();
+      return ShouldSendPing{true};
+    }
+    return ShouldSendPing{false};
+  }
+  void SetPingOnRstStreamInProgress(bool value) {
+    GRPC_DCHECK(!is_client_);
+    ping_on_rst_stream_in_progress_ = value;
+  }
 
   // Called when a HEADER frame is received.
   void UpdateState(const Http2HeaderFrame& frame,
@@ -477,6 +502,8 @@ class ReadContext {
   const Slice peer_string_;
   const bool is_client_;
 
+  const uint8_t ping_on_rst_stream_percent_;
+  bool ping_on_rst_stream_in_progress_ = false;
   const uint32_t max_security_frame_size_;
   uint32_t max_header_list_size_soft_limit_ =
       DEFAULT_MAX_HEADER_LIST_SIZE_SOFT_LIMIT;