grpc 1.75.0 → 1.78.1

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

@@ -18,7 +18,7 @@
 
 #include <utility>
 
-#include "absl/log/check.h"
+#include "src/core/util/grpc_check.h"
 #include "absl/meta/type_traits.h"
 #include "absl/random/distributions.h"
 
@@ -93,7 +93,7 @@ std::optional<uint64_t> Chttp2PingCallbacks::OnPingTimeout(
     Duration ping_timeout,
     grpc_event_engine::experimental::EventEngine* event_engine,
     Callback callback) {
-  CHECK(started_new_ping_without_setting_timeout_);
+  GRPC_CHECK(started_new_ping_without_setting_timeout_);
   started_new_ping_without_setting_timeout_ = false;
   auto it = inflight_.find(most_recent_inflight_);
   if (it == inflight_.end()) return std::nullopt;

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

@@ -24,13 +24,13 @@
 #include <optional>
 #include <vector>
 
+#include "src/core/channelz/property_list.h"
+#include "src/core/lib/debug/trace.h"
+#include "src/core/util/time.h"
 #include "absl/container/flat_hash_map.h"
 #include "absl/functional/any_invocable.h"
 #include "absl/hash/hash.h"
 #include "absl/random/bit_gen_ref.h"
-#include "src/core/channelz/property_list.h"
-#include "src/core/lib/debug/trace.h"
-#include "src/core/util/time.h"
 
 namespace grpc_core {
 

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

@@ -17,19 +17,22 @@
 //
 #include "src/core/ext/transport/chttp2/transport/ping_promise.h"
 
-#include "src/core/lib/promise/if.h"
+#include <memory>
+#include <utility>
+
+#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/promise/latch.h"
 #include "src/core/lib/promise/map.h"
 #include "src/core/lib/promise/party.h"
 #include "src/core/lib/promise/race.h"
 #include "src/core/lib/promise/sleep.h"
 #include "src/core/lib/promise/try_seq.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/match.h"
 #include "src/core/util/time.h"
 
 namespace grpc_core {
 namespace http2 {
-using SendPingArgs = ::grpc_core::http2::PingInterface::SendPingArgs;
 using Callback = absl::AnyInvocable<void()>;
 using grpc_event_engine::experimental::EventEngine;
 
@@ -56,15 +59,16 @@ Promise<absl::Status> PingManager::PingPromiseCallbacks::WaitForPingAck() {
 }
 
 // Ping System implementation
-PingManager::PingManager(const ChannelArgs& channel_args,
+PingManager::PingManager(const ChannelArgs& channel_args, 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_interface_(std::move(ping_interface)) {}
+      ping_interface_(std::move(ping_interface)),
+      ping_timeout_(ping_timeout) {}
 
-void PingManager::TriggerDelayedPing(Duration wait) {
+void PingManager::TriggerDelayedPing(const Duration wait) {
   // Spawn at most once.
   if (delayed_ping_spawned_) {
     return;
@@ -72,8 +76,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 +87,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 +120,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;
+  GRPC_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() {
+  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,16 @@
 
 #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/grpc_check.h"
 #include "src/core/util/shared_bit_gen.h"
 #include "src/core/util/time.h"
 
@@ -55,17 +59,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;
 
@@ -79,16 +72,19 @@ class PingInterface {
 // returned by this class on the same transport party.
 class PingManager {
  public:
-  PingManager(const ChannelArgs& channel_args,
+  PingManager(const ChannelArgs& channel_args, Duration ping_timeout,
               std::unique_ptr<PingInterface> ping_interface,
               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();
 
   // Ping Rate policy wrapper
   void ReceivedDataFrame() { ping_rate_policy_.ReceivedDataFrame(); }
@@ -131,6 +127,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) {
+    GRPC_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:
@@ -138,6 +154,7 @@ class PingManager {
         std::shared_ptr<grpc_event_engine::experimental::EventEngine>
             event_engine)
         : event_engine_(event_engine) {}
+    ~PingPromiseCallbacks() { CancelCallbacks(); }
     Promise<absl::Status> RequestPing(absl::AnyInvocable<void()> on_initiate,
                                       bool important);
     Promise<absl::Status> WaitForPingAck();
@@ -160,12 +177,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 +211,19 @@ 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_;
+  // Duration to wait before triggering a ping timeout.
+  Duration ping_timeout_;
 
   void TriggerDelayedPing(Duration wait);
   bool NeedToPing(Duration next_allowed_ping_interval);

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

@@ -21,9 +21,9 @@
 #include <optional>
 #include <ostream>
 
-#include "absl/strings/str_cat.h"
 #include "src/core/lib/experiments/experiments.h"
 #include "src/core/util/match.h"
+#include "absl/strings/str_cat.h"
 
 namespace grpc_core {
 

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

@@ -0,0 +1,31 @@
+//
+// 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.
+//
+
+#include "src/core/ext/transport/chttp2/transport/security_frame.h"
+
+#include <cstddef>
+#include <cstdint>
+
+#include "src/core/lib/slice/slice.h"
+#include "src/core/lib/slice/slice_buffer.h"
+#include "src/core/lib/transport/transport_framing_endpoint_extension.h"
+#include "absl/status/status.h"
+
+namespace grpc_core {
+
+// TODO(tjagtap) [PH2][P1] Implement
+
+}  // namespace grpc_core

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

@@ -0,0 +1,32 @@
+//
+// 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_SECURITY_FRAME_H
+#define GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_SECURITY_FRAME_H
+
+#include <grpc/slice.h>
+#include <stdint.h>
+
+#include "src/core/lib/slice/slice_buffer.h"
+#include "src/core/lib/transport/transport_framing_endpoint_extension.h"
+
+namespace grpc_core {
+
+// TODO(tjagtap) [PH2][P1] Implement
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_SECURITY_FRAME_H