grpc 1.75.0.pre1 → 1.76.0.pre1

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

@@ -17,7 +17,6 @@
 //
 #include "src/core/ext/transport/chttp2/transport/ping_promise.h"
 
-#include "src/core/lib/promise/if.h"
 #include "src/core/lib/promise/latch.h"
 #include "src/core/lib/promise/map.h"
 #include "src/core/lib/promise/party.h"
@@ -29,7 +28,6 @@
 
 namespace grpc_core {
 namespace http2 {
-using SendPingArgs = ::grpc_core::http2::PingInterface::SendPingArgs;
 using Callback = absl::AnyInvocable<void()>;
 using grpc_event_engine::experimental::EventEngine;
 
@@ -64,7 +62,7 @@ PingManager::PingManager(const ChannelArgs& channel_args,
       ping_rate_policy_(channel_args, /*is_client=*/true),
       ping_interface_(std::move(ping_interface)) {}
 
-void PingManager::TriggerDelayedPing(Duration wait) {
+void PingManager::TriggerDelayedPing(const Duration wait) {
   // Spawn at most once.
   if (delayed_ping_spawned_) {
     return;
@@ -72,8 +70,10 @@ void PingManager::TriggerDelayedPing(Duration wait) {
   delayed_ping_spawned_ = true;
   GetContext<Party>()->Spawn(
       "DelayedPing",
+      // TODO(akshitpatel) : [PH2][P2] : Verify if we need a RefCountedPtr for
+      // ping_manager.
       [this, wait]() mutable {
-        VLOG(2) << "Scheduling delayed ping after wait=" << wait;
+        GRPC_HTTP2_PING_LOG << "Scheduling delayed ping after wait=" << wait;
         return AssertResultType<absl::Status>(TrySeq(
             Sleep(wait),
             [this]() mutable { return ping_interface_->TriggerWrite(); }));
@@ -81,7 +81,7 @@ void PingManager::TriggerDelayedPing(Duration wait) {
       [this](auto) { delayed_ping_spawned_ = false; });
 }
 
-bool PingManager::NeedToPing(Duration next_allowed_ping_interval) {
+bool PingManager::NeedToPing(const Duration next_allowed_ping_interval) {
   if (!ping_callbacks_.PingRequested()) {
     return false;
   }
@@ -114,39 +114,75 @@ bool PingManager::NeedToPing(Duration next_allowed_ping_interval) {
       });
 }
 
-void PingManager::SpawnTimeout(Duration ping_timeout,
+void PingManager::SpawnTimeout(const Duration ping_timeout,
                                const uint64_t opaque_data) {
   GetContext<Party>()->Spawn(
       "PingTimeout",
+      // TODO(akshitpatel) : [PH2][P2] : Verify if we need a RefCountedPtr for
+      // ping_manager.
       [this, ping_timeout, opaque_data]() {
         return AssertResultType<absl::Status>(Race(
             TrySeq(ping_callbacks_.PingTimeout(ping_timeout),
-                   [this, opaque_data]() mutable {
-                     VLOG(2) << " Ping ack not received for id=" << opaque_data
-                             << ". Ping timeout triggered.";
-                     return ping_interface_->PingTimeout();
+                   [this, opaque_data](bool trigger_ping_timeout) mutable {
+                     return If(
+                         trigger_ping_timeout,
+                         [this, opaque_data]() {
+                           GRPC_HTTP2_PING_LOG
+                               << " Ping ack not received for id="
+                               << opaque_data << ". Ping timeout triggered.";
+                           return ping_interface_->PingTimeout();
+                         },
+                         []() { return absl::OkStatus(); });
                    }),
             ping_callbacks_.WaitForPingAck()));
       },
       [](auto) {});
 }
 
-Promise<absl::Status> PingManager::MaybeSendPing(
-    Duration next_allowed_ping_interval, Duration ping_timeout) {
-  return If(
-      NeedToPing(next_allowed_ping_interval),
-      [this, ping_timeout]() mutable {
-        const uint64_t opaque_data = ping_callbacks_.StartPing();
-        return AssertResultType<absl::Status>(
-            TrySeq(ping_interface_->SendPing(SendPingArgs{false, opaque_data}),
-                   [this, ping_timeout, opaque_data]() {
-                     VLOG(2) << "Ping Sent with id: " << opaque_data;
-                     SpawnTimeout(ping_timeout, opaque_data);
-                     SentPing();
-                     return absl::OkStatus();
-                   }));
-      },
-      []() { return Immediate(absl::OkStatus()); });
+void PingManager::MaybeGetSerializedPingFrames(
+    SliceBuffer& output_buffer, const Duration next_allowed_ping_interval) {
+  GRPC_HTTP2_PING_LOG << "PingManager MaybeGetSerializedPingFrames "
+                         "pending_ping_acks_ size: "
+                      << pending_ping_acks_.size()
+                      << " next_allowed_ping_interval: "
+                      << next_allowed_ping_interval;
+  DCHECK(!opaque_data_.has_value());
+  std::vector<Http2Frame> frames;
+  frames.reserve(pending_ping_acks_.size() + 1);  // +1 for the ping frame.
+
+  // Get the serialized ping acks if needed.
+  for (uint64_t opaque_data : pending_ping_acks_) {
+    frames.emplace_back(GetHttp2PingFrame(/*ack=*/true, opaque_data));
+  }
+  pending_ping_acks_.clear();
+
+  // Get the serialized ping frame if needed.
+  if (NeedToPing(next_allowed_ping_interval)) {
+    const uint64_t opaque_data = ping_callbacks_.StartPing();
+    frames.emplace_back(GetHttp2PingFrame(/*ack=*/false, opaque_data));
+    opaque_data_ = opaque_data;
+    GRPC_HTTP2_PING_LOG << "Created ping frame for id= " << opaque_data;
+  }
+
+  // Serialize the frames if any.
+  if (!frames.empty()) {
+    Serialize(absl::Span<Http2Frame>(frames), output_buffer);
+  }
 }
+
+void PingManager::NotifyPingSent(const Duration ping_timeout) {
+  if (opaque_data_.has_value()) {
+    SpawnTimeout(ping_timeout, opaque_data_.value());
+    SentPing();
+    opaque_data_.reset();
+  }
+}
+
+void PingManager::AddPendingPingAck(const uint64_t opaque_data) {
+  GRPC_HTTP2_PING_LOG << "Adding pending ping ack for id=" << opaque_data
+                      << " to the list of pending ping acks.";
+  pending_ping_acks_.push_back(opaque_data);
+}
+
 }  // namespace http2
 }  // namespace grpc_core

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

@@ -20,12 +20,15 @@
 
 #include <memory>
 
+#include "src/core/ext/transport/chttp2/transport/frame.h"
 #include "src/core/ext/transport/chttp2/transport/ping_abuse_policy.h"
 #include "src/core/ext/transport/chttp2/transport/ping_callbacks.h"
 #include "src/core/ext/transport/chttp2/transport/ping_rate_policy.h"
+#include "src/core/lib/promise/if.h"
 #include "src/core/lib/promise/inter_activity_latch.h"
 #include "src/core/lib/promise/map.h"
 #include "src/core/lib/promise/promise.h"
+#include "src/core/lib/slice/slice_buffer.h"
 #include "src/core/util/shared_bit_gen.h"
 #include "src/core/util/time.h"
 
@@ -55,17 +58,6 @@ namespace http2 {
 
 class PingInterface {
  public:
-  struct SendPingArgs {
-    bool ack = false;
-    // RFC9113: PING frames MUST contain 8 octets of opaque data in the frame
-    // payload. A sender can include any value it chooses and use those octets
-    // in any fashion.
-    uint64_t opaque_data = 0;
-  };
-
-  // Returns a promise that creates and sends a ping frame to the peer.
-  virtual Promise<absl::Status> SendPing(SendPingArgs args) = 0;
-
   // Returns a promise that triggers a write cycle on the transport.
   virtual Promise<absl::Status> TriggerWrite() = 0;
 
@@ -84,11 +76,14 @@ class PingManager {
               std::shared_ptr<grpc_event_engine::experimental::EventEngine>
                   event_engine);
 
-  // Returns a promise that determines if a ping frame should be sent to the
-  // peer. If a ping frame is sent, it also spawns a timeout promise that
-  // handles the ping timeout.
-  Promise<absl::Status> MaybeSendPing(Duration next_allowed_ping_interval,
-                                      Duration ping_timeout);
+  // If there are any pending ping requests or ping acks, populates the output
+  // buffer with the serialized ping frames.
+  void MaybeGetSerializedPingFrames(SliceBuffer& output_buf,
+                                    Duration next_allowed_ping_interval);
+
+  // Notify the ping system that a ping has been sent. This will spawn a ping
+  // timeout promise.
+  void NotifyPingSent(Duration ping_timeout);
 
   // Ping Rate policy wrapper
   void ReceivedDataFrame() { ping_rate_policy_.ReceivedDataFrame(); }
@@ -131,6 +126,26 @@ class PingManager {
   bool AckPing(uint64_t id) { return ping_callbacks_.AckPing(id); }
   size_t CountPingInflight() { return ping_callbacks_.CountPingInflight(); }
 
+  Http2Frame GetHttp2PingFrame(uint64_t opaque_data) {
+    return Http2PingFrame{/*ack=*/false, opaque_data};
+  }
+
+  std::optional<uint64_t> TestOnlyMaybeGetSerializedPingFrames(
+      SliceBuffer& output_buffer, Duration next_allowed_ping_interval) {
+    DCHECK(!opaque_data_.has_value());
+    if (NeedToPing(next_allowed_ping_interval)) {
+      uint64_t opaque_data = ping_callbacks_.StartPing();
+      Http2Frame frame = GetHttp2PingFrame(/*ack*/ false, opaque_data);
+      Serialize(absl::Span<Http2Frame>(&frame, 1), output_buffer);
+      opaque_data_ = opaque_data;
+      return opaque_data;
+    }
+
+    return std::nullopt;
+  }
+
+  void AddPendingPingAck(uint64_t opaque_data);
+
  private:
   class PingPromiseCallbacks {
    public:
@@ -160,12 +175,27 @@ class PingManager {
       std::shared_ptr<InterActivityLatch<void>> latch =
           std::make_shared<InterActivityLatch<void>>();
       auto timeout_cb = [latch]() { latch->Set(); };
-      auto id = ping_callbacks_.OnPingTimeout(ping_timeout, event_engine_.get(),
-                                              std::move(timeout_cb));
-      DCHECK(id.has_value());
-      VLOG(2) << "Ping timeout of duration: " << ping_timeout
-              << " initiated for ping id: " << *id;
-      return Map(latch->Wait(), [latch](Empty) { return absl::OkStatus(); });
+      std::optional<uint64_t> id = ping_callbacks_.OnPingTimeout(
+          ping_timeout, event_engine_.get(), std::move(timeout_cb));
+
+      return AssertResultType<bool>(If(
+          // The scenario where OnPingTimeout returns an invalid id is when
+          // the ping ack is received before spawning the ping timeout.
+          // In such a case, we don't wait for the ping timeout.
+          id.has_value(),
+          [latch, id, ping_timeout]() {
+            VLOG(2) << "Ping timeout of duration: " << ping_timeout
+                    << " initiated for ping id: " << *id;
+            return Map(latch->Wait(), [latch](Empty) {
+              return /*trigger_ping_timeout*/ true;
+            });
+          },
+          []() {
+            // This happens if for some reason the ping ack is received before
+            // the timeout timer is spawned.
+            VLOG(2) << "Ping ack received. Not waiting for ping timeout.";
+            return /*trigger_ping_timeout*/ false;
+          }));
     }
 
    private:
@@ -179,11 +209,17 @@ class PingManager {
     bool important_ping_requested_ = false;
   };
 
+  Http2Frame GetHttp2PingFrame(bool ack, uint64_t opaque_data) {
+    return Http2PingFrame{ack, opaque_data};
+  }
+
   PingPromiseCallbacks ping_callbacks_;
   Chttp2PingAbusePolicy ping_abuse_policy_;
   Chttp2PingRatePolicy ping_rate_policy_;
   bool delayed_ping_spawned_ = false;
+  std::optional<uint64_t> opaque_data_;
   std::unique_ptr<PingInterface> ping_interface_;
+  std::vector<uint64_t> pending_ping_acks_;
 
   void TriggerDelayedPing(Duration wait);
   bool NeedToPing(Duration next_allowed_ping_interval);

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

@@ -0,0 +1,207 @@
+//
+//
+// Copyright 2025 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
+
+#ifndef GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_STREAM_H
+#define GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_STREAM_H
+
+#include "src/core/call/call_spine.h"
+#include "src/core/ext/transport/chttp2/transport/flow_control.h"
+#include "src/core/ext/transport/chttp2/transport/http2_transport.h"
+#include "src/core/ext/transport/chttp2/transport/stream_data_queue.h"
+#include "src/core/util/ref_counted_ptr.h"
+
+namespace grpc_core {
+namespace http2 {
+
+// Managing the streams
+struct Stream : public RefCounted<Stream> {
+  explicit Stream(CallHandler call, const uint32_t stream_id1,
+                  bool allow_true_binary_metadata_peer,
+                  bool allow_true_binary_metadata_acked,
+                  chttp2::TransportFlowControl& transport_flow_control)
+      : call(std::move(call)),
+        is_write_closed(false),
+        stream_state(HttpStreamState::kIdle),
+        stream_id(stream_id1),
+        header_assembler(stream_id1, allow_true_binary_metadata_acked),
+        did_push_initial_metadata(false),
+        did_push_trailing_metadata(false),
+        data_queue(MakeRefCounted<StreamDataQueue<ClientMetadataHandle>>(
+            /*is_client*/ true, /*stream_id*/ stream_id1,
+            /*queue_size*/ kStreamQueueSize, allow_true_binary_metadata_peer)),
+        flow_control(&transport_flow_control) {}
+
+  ////////////////////////////////////////////////////////////////////////////
+  // Data Queue Helpers
+  // All enqueue methods are called from the call party.
+
+  auto EnqueueInitialMetadata(ClientMetadataHandle&& metadata) {
+    GRPC_HTTP2_CLIENT_DLOG
+        << "Http2ClientTransport::Stream::EnqueueInitialMetadata stream_id="
+        << stream_id;
+    return data_queue->EnqueueInitialMetadata(std::move(metadata));
+  }
+
+  auto EnqueueTrailingMetadata(ClientMetadataHandle&& metadata) {
+    GRPC_HTTP2_CLIENT_DLOG
+        << "Http2ClientTransport::Stream::EnqueueTrailingMetadata stream_id="
+        << stream_id;
+    return data_queue->EnqueueTrailingMetadata(std::move(metadata));
+  }
+
+  auto EnqueueMessage(MessageHandle&& message) {
+    GRPC_HTTP2_CLIENT_DLOG
+        << "Http2ClientTransport::Stream::EnqueueMessage stream_id="
+        << stream_id << " with payload size = " << message->payload()->Length();
+    return data_queue->EnqueueMessage(std::move(message));
+  }
+
+  auto EnqueueHalfClosed() {
+    GRPC_HTTP2_CLIENT_DLOG
+        << "Http2ClientTransport::Stream::EnqueueHalfClosed stream_id="
+        << stream_id;
+    return data_queue->EnqueueHalfClosed();
+  }
+
+  auto EnqueueResetStream(const uint32_t error_code) {
+    GRPC_HTTP2_CLIENT_DLOG
+        << "Http2ClientTransport::Stream::EnqueueResetStream stream_id="
+        << stream_id << " with error_code = " << error_code;
+    return data_queue->EnqueueResetStream(error_code);
+  }
+
+  // Called from the transport party
+  auto DequeueFrames(const uint32_t transport_tokens,
+                     const uint32_t max_frame_length,
+                     HPackCompressor& encoder) {
+    HttpStreamState state = GetStreamState();
+    // Reset stream MUST not be sent if the stream is idle or closed.
+    return data_queue->DequeueFrames(transport_tokens, max_frame_length,
+                                     encoder,
+                                     /*can_send_reset_stream=*/
+                                     !(state == HttpStreamState::kIdle ||
+                                       state == HttpStreamState::kClosed));
+  }
+
+  ////////////////////////////////////////////////////////////////////////////
+  // Stream State Management
+  // All state management helpers MUST be called from the transport party.
+
+  // Modify the stream state
+  // The possible stream transitions are as follows:
+  // kIdle -> kOpen
+  // kOpen -> kClosed/kHalfClosedLocal/kHalfClosedRemote
+  // kHalfClosedLocal/kHalfClosedRemote -> kClosed
+  // kClosed -> kClosed
+  void SentInitialMetadata() {
+    GRPC_DCHECK(stream_state == HttpStreamState::kIdle);
+    stream_state = HttpStreamState::kOpen;
+  }
+
+  void MarkHalfClosedLocal() {
+    switch (stream_state) {
+      case HttpStreamState::kIdle:
+        GRPC_DCHECK(false) << "MarkHalfClosedLocal called for an idle stream";
+        break;
+      case HttpStreamState::kOpen:
+        GRPC_HTTP2_CLIENT_DLOG
+            << "Http2ClientTransport::Stream::MarkHalfClosedLocal stream_id="
+            << stream_id << " transitioning to kHalfClosedLocal";
+        stream_state = HttpStreamState::kHalfClosedLocal;
+        break;
+      case HttpStreamState::kHalfClosedRemote:
+        GRPC_HTTP2_CLIENT_DLOG
+            << "Http2ClientTransport::Stream::MarkHalfClosedLocal stream_id="
+            << stream_id << " transitioning to kClosed";
+        stream_state = HttpStreamState::kClosed;
+        break;
+      case HttpStreamState::kHalfClosedLocal:
+        break;
+      case HttpStreamState::kClosed:
+        GRPC_HTTP2_CLIENT_DLOG
+            << "Http2ClientTransport::Stream::MarkHalfClosedLocal stream_id="
+            << stream_id << " already closed";
+        break;
+    }
+  }
+
+  void MarkHalfClosedRemote() {
+    switch (stream_state) {
+      case HttpStreamState::kIdle:
+        GRPC_DCHECK(false) << "MarkHalfClosedRemote called for an idle stream";
+        break;
+      case HttpStreamState::kOpen:
+        GRPC_HTTP2_CLIENT_DLOG
+            << "Http2ClientTransport::Stream::MarkHalfClosedRemote stream_id="
+            << stream_id << " transitioning to kHalfClosedRemote";
+        stream_state = HttpStreamState::kHalfClosedRemote;
+        break;
+      case HttpStreamState::kHalfClosedLocal:
+        GRPC_HTTP2_CLIENT_DLOG
+            << "Http2ClientTransport::Stream::MarkHalfClosedRemote stream_id="
+            << stream_id << " transitioning to kClosed";
+        stream_state = HttpStreamState::kClosed;
+        break;
+      case HttpStreamState::kHalfClosedRemote:
+        break;
+      case HttpStreamState::kClosed:
+        GRPC_HTTP2_CLIENT_DLOG
+            << "Http2ClientTransport::Stream::MarkHalfClosedRemote stream_id="
+            << stream_id << " already closed";
+        break;
+    }
+  }
+
+  inline HttpStreamState GetStreamState() const { return stream_state; }
+  inline uint32_t GetStreamId() const { return stream_id; }
+
+  inline bool IsClosedForWrites() const { return is_write_closed; }
+  inline void SetWriteClosed() { is_write_closed = true; }
+
+  CallHandler call;
+  // This flag is kept separate from the stream_state as the stream_state
+  // is inline with the HTTP2 spec, whereas this flag is an implementation
+  // detail of the PH2 transport. As far as PH2 is concerned, if a stream is
+  // closed for writes, it will not send any more frames on that stream.
+  // Similarly if a stream is closed for reads(this is achieved by removing the
+  // stream from the transport map), then all the frames read on that stream
+  // will be dropped.
+  bool is_write_closed;
+  // This MUST be accessed from the transport party.
+  HttpStreamState stream_state;
+  const uint32_t stream_id;
+  GrpcMessageAssembler assembler;
+  HeaderAssembler header_assembler;
+  // TODO(akshitpatel) : [PH2][P2] : StreamQ should maintain a flag that
+  // tracks if the half close has been sent for this stream. This flag is used
+  // to notify the mixer that this stream is closed for
+  // writes(HalfClosedLocal). When the mixer dequeues the last message for
+  // the streamQ, it will mark the stream as closed for writes and send a
+  // frame with end_stream or set the end_stream flag in the last data
+  // frame being sent out. This is done as the stream state should not
+  // transition to HalfClosedLocal till the end_stream frame is sent.
+  bool did_push_initial_metadata;
+  bool did_push_trailing_metadata;
+  RefCountedPtr<StreamDataQueue<ClientMetadataHandle>> data_queue;
+  chttp2::StreamFlowControl flow_control;
+};
+
+}  // namespace http2
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_STREAM_H