grpc 1.78.0 → 1.80.0.pre1

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

@@ -100,6 +100,7 @@ Http2ErrorCode Http2Settings::Apply(uint16_t key, uint32_t value) {
       enable_push_ = value != 0;
       break;
     case kMaxConcurrentStreamsWireId:
+      initial_max_concurrent_streams_ = value;
       max_concurrent_streams_ = value;
       break;
     case kInitialWindowSizeWireId:

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

@@ -67,7 +67,13 @@ class Http2Settings {
   bool allow_security_frame() const { return allow_security_frame_; }
 
   void SetHeaderTableSize(uint32_t x) { header_table_size_ = x; }
-  void SetMaxConcurrentStreams(uint32_t x) { max_concurrent_streams_ = x; }
+  void SetMaxConcurrentStreams(uint32_t x) {
+    initial_max_concurrent_streams_ = x;
+    max_concurrent_streams_ = x;
+  }
+  void UpdateMaxConcurrentStreams(uint32_t x) {
+    max_concurrent_streams_ = std::min(x, initial_max_concurrent_streams_);
+  }
   void SetInitialWindowSize(uint32_t x) {
     initial_window_size_ = std::min(x, max_initial_window_size());
   }
@@ -161,6 +167,7 @@ class Http2Settings {
   // to 0 for client.
   // SERVER : This setting can change for the server. This is usually changed to
   // handle memory pressure.
+  uint32_t initial_max_concurrent_streams_ = 4294967295u;
   uint32_t max_concurrent_streams_ = 4294967295u;
 
   // RFC9113 states the default for SETTINGS_INITIAL_WINDOW_SIZE

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

@@ -35,6 +35,7 @@
 #include "src/core/ext/transport/chttp2/transport/http2_settings.h"
 #include "src/core/ext/transport/chttp2/transport/http2_settings_manager.h"
 #include "src/core/ext/transport/chttp2/transport/http2_status.h"
+#include "src/core/ext/transport/chttp2/transport/write_cycle.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/promise/activity.h"
@@ -208,12 +209,14 @@ class SettingsPromiseManager final : public RefCounted<SettingsPromiseManager> {
   // written to apply the settings. If the first settings frame is received from
   // the peer that that needs some special handling too.
   http2::Http2ErrorCode MaybeReportAndApplyBufferedPeerSettings(
-      grpc_event_engine::experimental::EventEngine* event_engine) {
+      grpc_event_engine::experimental::EventEngine* event_engine,
+      bool& should_spawn_security_frame_loop) {
     http2::Http2ErrorCode status = settings_.ApplyIncomingSettings(
         std::exchange(pending_peer_settings_, {}));
     if (state_ == SettingsState::kFirstPeerSettingsReceived) {
       MaybeReportInitialSettings(event_engine);
       state_ = SettingsState::kReady;
+      should_spawn_security_frame_loop = IsSecurityFrameExpected();
     }
     return status;
   }
@@ -227,15 +230,15 @@ class SettingsPromiseManager final : public RefCounted<SettingsPromiseManager> {
   // acknowledgment. This MUST be called only after the
   // MaybeReportAndApplyBufferedPeerSettings function.
   void MaybeGetSettingsAndSettingsAckFrames(
-      chttp2::TransportFlowControl& flow_control, SliceBuffer& output_buf) {
+      chttp2::TransportFlowControl& flow_control,
+      http2::FrameSender& frame_sender) {
     GRPC_SETTINGS_TIMEOUT_DLOG << "MaybeGetSettingsAndSettingsAckFrames";
     if (did_previous_settings_promise_resolve_) {
       std::optional<Http2Frame> settings_frame = settings_.MaybeSendUpdate();
       if (settings_frame.has_value()) {
         GRPC_SETTINGS_TIMEOUT_DLOG
             << "MaybeGetSettingsAndSettingsAckFrames Frame Settings ";
-        Serialize(absl::Span<Http2Frame>(&settings_frame.value(), 1),
-                  output_buf);
+        frame_sender.AddRegularFrame(std::move(*settings_frame));
         flow_control.FlushedSettings();
         WillSendSettings();
       }
@@ -243,11 +246,11 @@ class SettingsPromiseManager final : public RefCounted<SettingsPromiseManager> {
     if (num_acks_to_send_ > 0) {
       GRPC_SETTINGS_TIMEOUT_DLOG << "Sending " << num_acks_to_send_
                                  << " settings ACK frames";
-      std::vector<Http2Frame> ack_frames(num_acks_to_send_);
+      frame_sender.ReserveRegularFrames(num_acks_to_send_);
       for (uint32_t i = 0; i < num_acks_to_send_; ++i) {
-        ack_frames[i] = Http2SettingsFrame{true, {}};
+        frame_sender.AddRegularFrame(Http2SettingsFrame{true, {}});
       }
-      Serialize(absl::MakeSpan(ack_frames), output_buf);
+
       num_acks_to_send_ = 0;
     }
   }
@@ -259,6 +262,9 @@ class SettingsPromiseManager final : public RefCounted<SettingsPromiseManager> {
   const Http2Settings& acked() const { return settings_.acked(); }
   const Http2Settings& peer() const { return settings_.peer(); }
 
+  //////////////////////////////////////////////////////////////////////////////
+  // ChannelZ and Security Frame Stuff
+
   channelz::PropertyGrid ChannelzProperties() const {
     return settings_.ChannelzProperties();
   }
@@ -268,8 +274,7 @@ class SettingsPromiseManager final : public RefCounted<SettingsPromiseManager> {
         << "Security frame must not be received before SETTINGS frame";
     // TODO(tjagtap) : [PH2][P3] : Evaluate when to accept the frame and when to
     // reject it. Compare it with the requirement and with CHTTP2.
-    return (settings_.acked().allow_security_frame() ||
-            settings_.local().allow_security_frame()) &&
+    return (settings_.local().allow_security_frame()) &&
            settings_.peer().allow_security_frame();
   };
 
@@ -291,7 +296,11 @@ class SettingsPromiseManager final : public RefCounted<SettingsPromiseManager> {
            peer_max_concurrent_streams =
                settings_.peer().max_concurrent_streams()]() mutable {
             ExecCtx exec_ctx;
-            std::move(on_receive_settings)(peer_max_concurrent_streams);
+            on_receive_settings(peer_max_concurrent_streams);
+            // Ensure the captured callback is destroyed while ExecCtx is still
+            // alive. Its destructor may trigger work that needs to schedule
+            // closures on the ExecCtx.
+            on_receive_settings = nullptr;
           });
       GRPC_DCHECK(on_receive_first_settings_ == nullptr);
     }
@@ -307,8 +316,11 @@ class SettingsPromiseManager final : public RefCounted<SettingsPromiseManager> {
       event_engine->Run([on_receive_settings =
                              std::move(on_receive_first_settings_)]() mutable {
         ExecCtx exec_ctx;
-        std::move(on_receive_settings)(
-            absl::UnavailableError("transport closed"));
+        on_receive_settings(absl::UnavailableError("transport closed"));
+        // Ensure the captured callback is destroyed while ExecCtx is still
+        // alive. Its destructor may trigger work that needs to schedule
+        // closures on the ExecCtx.
+        on_receive_settings = nullptr;
       });
       GRPC_DCHECK(on_receive_first_settings_ == nullptr);
     }
@@ -385,8 +397,8 @@ class SettingsPromiseManager final : public RefCounted<SettingsPromiseManager> {
   // better debuggability.
   Timestamp sent_time_ = Timestamp::InfFuture();
   Waker ack_timeout_waker_;
-  bool did_register_ack_timeout_waker_ = false;
   int number_of_acks_unprocessed_ = 0;
+  bool did_register_ack_timeout_waker_ = false;
   bool should_wait_for_settings_ack_ = false;
 
   // For CHTTP2, MaybeSendUpdate() checks `update_state_` to ensure only one

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

@@ -18,6 +18,7 @@
 
 #include "src/core/ext/transport/chttp2/transport/http2_transport.h"
 
+#include <grpc/event_engine/event_engine.h>
 #include <grpc/grpc.h>
 #include <grpc/impl/channel_arg_names.h>
 
@@ -37,11 +38,11 @@
 #include "src/core/ext/transport/chttp2/transport/header_assembler.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_manager.h"
 #include "src/core/ext/transport/chttp2/transport/http2_settings_promises.h"
 #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/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/slice/slice_buffer.h"
@@ -49,7 +50,8 @@
 #include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/time.h"
 #include "absl/log/log.h"
-#include "absl/types/span.h"
+#include "absl/status/status.h"
+#include "absl/strings/str_cat.h"
 
 namespace grpc_core {
 namespace http2 {
@@ -86,13 +88,33 @@ constexpr Duration kServerKeepaliveTime = Duration::Hours(2);
 // Do not use or edit any of these functions unless you are
 // familiar with the PH2 project (Moving chttp2 to promises.)
 
+///////////////////////////////////////////////////////////////////////////////
+// Read and Write helpers
+
+// This is only called by the HTTP2 Server Transport to validate the incoming
+// connection preface. Since a server does not send a connection preface, this
+// validation is not needed for the client transport.
+Http2Status ValidateIncomingConnectionPreface(
+    const absl::StatusOr<Slice>& status) {
+  if (!status.ok()) {
+    return ToHttpOkOrConnError(status.status());
+  } else if (status.value() !=
+             Slice::FromStaticString(GRPC_CHTTP2_CLIENT_CONNECT_STRING)) {
+    return Http2Status::Http2ConnectionError(
+        Http2ErrorCode::kProtocolError,
+        std::string(RFC9113::kFirstSettingsFrameServer));
+  }
+  return Http2Status::Ok();
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 // Settings helpers
 
 void InitLocalSettings(Http2Settings& settings, const bool is_client) {
   if (is_client) {
     // gRPC has never supported PUSH_PROMISE and we have no plan to do so in the
-    // future.
+    // future. We are not setting this to false for Server to be consistent
+    // with the legacy CHTTP2 transport.
     settings.SetEnablePush(false);
     // This is to make it double-sure that server cannot initiate a stream.
     settings.SetMaxConcurrentStreams(0);
@@ -103,6 +125,21 @@ void InitLocalSettings(Http2Settings& settings, const bool is_client) {
 
 ////////////////////////////////////////////////////////////////////////////////
 // Channel Args helpers
+
+std::string TransportChannelArgs::DebugString() const {
+  return absl::StrCat(
+      "keepalive_time: ", keepalive_time,
+      " keepalive_timeout: ", keepalive_timeout,
+      " ping_timeout: ", ping_timeout, " settings_timeout: ", settings_timeout,
+      " keepalive_permit_without_calls: ", keepalive_permit_without_calls,
+      " enable_preferred_rx_crypto_frame_advertisement: ",
+      enable_preferred_rx_crypto_frame_advertisement,
+      " max_header_list_size_soft_limit: ", max_header_list_size_soft_limit,
+      " max_usable_hpack_table_size: ", max_usable_hpack_table_size,
+      " initial_sequence_number: ", initial_sequence_number,
+      " test_only_ack_pings: ", test_only_ack_pings);
+}
+
 void ReadChannelArgs(const ChannelArgs& channel_args,
                      TransportChannelArgs& args, Http2Settings& local_settings,
                      chttp2::TransportFlowControl& flow_control,
@@ -276,7 +313,7 @@ void ProcessOutgoingDataFrameFlowControl(
 ValueOrHttp2Status<chttp2::FlowControlAction>
 ProcessIncomingDataFrameFlowControl(Http2FrameHeader& frame_header,
                                     chttp2::TransportFlowControl& flow_control,
-                                    RefCountedPtr<Stream> stream) {
+                                    Stream* stream) {
   GRPC_DCHECK_EQ(frame_header.type, 0u);
   if (frame_header.length > 0) {
     if (stream == nullptr) {
@@ -301,7 +338,7 @@ ProcessIncomingDataFrameFlowControl(Http2FrameHeader& frame_header,
       return action;
     } else {
       chttp2::StreamFlowControl::IncomingUpdateContext stream_fc(
-          &stream->flow_control);
+          &stream->GetStreamFlowControl());
       absl::Status fc_status = stream_fc.RecvData(frame_header.length);
       chttp2::FlowControlAction action = stream_fc.MakeAction();
       GRPC_HTTP2_COMMON_DLOG
@@ -325,14 +362,14 @@ ProcessIncomingDataFrameFlowControl(Http2FrameHeader& frame_header,
 
 bool ProcessIncomingWindowUpdateFrameFlowControl(
     const Http2WindowUpdateFrame& frame,
-    chttp2::TransportFlowControl& flow_control, RefCountedPtr<Stream> stream) {
+    chttp2::TransportFlowControl& flow_control, Stream* stream) {
   if (frame.stream_id != 0) {
     if (stream != nullptr) {
       GRPC_HTTP2_COMMON_DLOG
           << "ProcessIncomingWindowUpdateFrameFlowControl stream "
           << frame.stream_id << " increment " << frame.increment;
       chttp2::StreamFlowControl::OutgoingUpdateContext fc_update(
-          &stream->flow_control);
+          &stream->GetStreamFlowControl());
       fc_update.RecvUpdate(frame.increment);
     } else {
       // If stream id is non zero, and stream is nullptr, maybe the stream was
@@ -362,25 +399,36 @@ bool ProcessIncomingWindowUpdateFrameFlowControl(
   return false;
 }
 
-void MaybeAddStreamWindowUpdateFrame(RefCountedPtr<Stream> stream,
-                                     std::vector<Http2Frame>& frames) {
+void MaybeAddTransportWindowUpdateFrame(
+    chttp2::TransportFlowControl& flow_control, FrameSender& frame_sender) {
+  uint32_t window_size =
+      flow_control.DesiredAnnounceSize(/*writing_anyway=*/true);
+  if (window_size > 0) {
+    GRPC_HTTP2_COMMON_DLOG
+        << "MaybeGetWindowUpdateFrames Transport Window Update : "
+        << window_size;
+    frame_sender.AddRegularFrame(
+        Http2WindowUpdateFrame{/*stream_id=*/0, window_size});
+    flow_control.SentUpdate(window_size);
+  }
+}
+
+void MaybeAddStreamWindowUpdateFrame(Stream& stream,
+                                     FrameSender& frame_sender) {
   GRPC_HTTP2_COMMON_DLOG << "MaybeAddStreamWindowUpdateFrame stream="
-                         << ((stream == nullptr)
-                                 ? "null"
-                                 : absl::StrCat(
-                                       stream->GetStreamId(),
-                                       " CanSendWindowUpdateFrames=",
-                                       stream->CanSendWindowUpdateFrames()));
-  if (stream != nullptr && stream->CanSendWindowUpdateFrames()) {
-    const uint32_t increment = stream->flow_control.MaybeSendUpdate();
+                         << stream.GetStreamId()
+                         << " CanSendWindowUpdateFrames="
+                         << stream.CanSendWindowUpdateFrames();
+  if (stream.CanSendWindowUpdateFrames()) {
+    const uint32_t increment = stream.GetStreamFlowControl().MaybeSendUpdate();
     GRPC_HTTP2_COMMON_DLOG
         << "MaybeAddStreamWindowUpdateFrame MaybeSendUpdate { "
-        << stream->GetStreamId() << ", " << increment << " }"
+        << stream.GetStreamId() << ", " << increment << " }"
         << (increment == 0 ? ". The frame will NOT be sent for increment 0"
                            : "");
     if (increment > 0) {
-      frames.emplace_back(
-          Http2WindowUpdateFrame{stream->GetStreamId(), increment});
+      frame_sender.AddRegularFrame(
+          Http2WindowUpdateFrame{stream.GetStreamId(), increment});
     }
   }
 }
@@ -390,7 +438,7 @@ void MaybeAddStreamWindowUpdateFrame(RefCountedPtr<Stream> stream,
 
 Http2Status ParseAndDiscardHeaders(HPackParser& parser, SliceBuffer&& buffer,
                                    HeaderAssembler::ParseHeaderArgs args,
-                                   const RefCountedPtr<Stream> stream,
+                                   Stream* stream,
                                    Http2Status&& original_status) {
   GRPC_HTTP2_COMMON_DLOG << "ParseAndDiscardHeaders buffer "
                             "size: "
@@ -402,9 +450,8 @@ Http2Status ParseAndDiscardHeaders(HPackParser& parser, SliceBuffer&& buffer,
 
   if (stream != nullptr) {
     // Parse all the data in the header assembler
-    Http2Status result = stream->header_assembler.ParseAndDiscardHeaders(
-        parser, args.is_initial_metadata, args.is_client,
-        args.max_header_list_size_soft_limit,
+    Http2Status result = stream->GetHeaderAssembler().ParseAndDiscardHeaders(
+        parser, args.is_initial_metadata, args.max_header_list_size_soft_limit,
         args.max_header_list_size_hard_limit);
     if (!result.IsOk()) {
       GRPC_DCHECK(result.GetType() ==

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

@@ -27,14 +27,12 @@
 #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_settings_manager.h"
-#include "src/core/ext/transport/chttp2/transport/http2_settings_promises.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/promise/activity.h"
-#include "src/core/lib/promise/context.h"
 #include "src/core/lib/promise/poll.h"
-#include "src/core/lib/transport/promise_endpoint.h"
+#include "src/core/lib/slice/slice.h"
 #include "src/core/util/ref_counted_ptr.h"
 #include "absl/log/log.h"
 #include "absl/status/status.h"
@@ -52,14 +50,15 @@ namespace http2 {
 #define GRPC_HTTP2_CLIENT_DLOG \
   DLOG_IF(INFO, GRPC_TRACE_FLAG_ENABLED(http2_ph2_transport))
 
+#define GRPC_HTTP2_SERVER_DLOG \
+  DLOG_IF(INFO, GRPC_TRACE_FLAG_ENABLED(http2_ph2_transport))
+
 #define GRPC_HTTP2_CLIENT_ERROR_DLOG \
   LOG_IF(ERROR, GRPC_TRACE_FLAG_ENABLED(http2_ph2_transport))
 
 #define GRPC_HTTP2_COMMON_DLOG \
   DLOG_IF(INFO, GRPC_TRACE_FLAG_ENABLED(http2_ph2_transport))
 
-constexpr uint32_t kMaxWriteSize = /*10 MB*/ 10u * 1024u * 1024u;
-
 constexpr uint32_t kGoawaySendTimeoutSeconds = 5u;
 
 struct CloseStreamArgs {
@@ -67,11 +66,21 @@ struct CloseStreamArgs {
   bool close_writes;
 };
 
+// TODO(akshitpatel) [PH2][P3] : Write a way to measure the total size of a
+// transport object. Reference :
+// https://github.com/grpc/grpc/pull/41294/files#diff-c685cc4847f228327938326e2a45083a2d0845bacff0ac004bd802027a670c4e
+
 ///////////////////////////////////////////////////////////////////////////////
 // Read and Write helpers
 
 class Http2ReadContext {
  public:
+  Http2ReadContext() = default;
+  Http2ReadContext(const Http2ReadContext&) = delete;
+  Http2ReadContext& operator=(const Http2ReadContext&) = delete;
+  Http2ReadContext(Http2ReadContext&&) = delete;
+  Http2ReadContext& operator=(Http2ReadContext&&) = delete;
+
   // Signals that the read loop should pause. If it's already paused, this is a
   // no-op.
   void SetPauseReadLoop() {
@@ -107,30 +116,8 @@ class Http2ReadContext {
   Waker read_loop_waker_;
 };
 
-inline PromiseEndpoint::WriteArgs GetWriteArgs(
-    const Http2Settings& peer_settings) {
-  PromiseEndpoint::WriteArgs args;
-  int max_frame_size = peer_settings.preferred_receive_crypto_message_size();
-  // Note: max frame size is 0 if the remote peer does not support adjusting the
-  // sending frame size.
-  if (max_frame_size == 0) {
-    max_frame_size = INT_MAX;
-  }
-  // `WriteArgs.max_frame_size` is a suggestion to the endpoint implementation
-  // to group data to be written into frames of the specified max_frame_size. It
-  // is different from HTTP2 SETTINGS_MAX_FRAME_SIZE. That setting limits HTTP2
-  // frame payload size.
-  args.set_max_frame_size(max_frame_size);
-
-  // TODO(akshitpatel) [PH2][P1] : Currently only the WriteArgs related to
-  // preferred_receive_crypto_message_size have been plumbed. The other write
-  // args may need to be plumbed for PH2.
-  // CHTTP2 : Reference :
-  // File : src/core/ext/transport/chttp2/transport/chttp2_transport.cc
-  // Function : write_action
-
-  return args;
-}
+Http2Status ValidateIncomingConnectionPreface(
+    const absl::StatusOr<Slice>& status);
 
 ///////////////////////////////////////////////////////////////////////////////
 // Settings helpers
@@ -153,20 +140,7 @@ struct TransportChannelArgs {
   int max_usable_hpack_table_size;
   int initial_sequence_number;
 
-  std::string DebugString() const {
-    return absl::StrCat(
-        "keepalive_time: ", keepalive_time,
-        " keepalive_timeout: ", keepalive_timeout,
-        " ping_timeout: ", ping_timeout,
-        " settings_timeout: ", settings_timeout,
-        " keepalive_permit_without_calls: ", keepalive_permit_without_calls,
-        " enable_preferred_rx_crypto_frame_advertisement: ",
-        enable_preferred_rx_crypto_frame_advertisement,
-        " max_header_list_size_soft_limit: ", max_header_list_size_soft_limit,
-        " max_usable_hpack_table_size: ", max_usable_hpack_table_size,
-        " initial_sequence_number: ", initial_sequence_number,
-        " test_only_ack_pings: ", test_only_ack_pings);
-  }
+  std::string DebugString() const;
 };
 
 void ReadChannelArgs(const ChannelArgs& channel_args,
@@ -197,15 +171,17 @@ void ProcessOutgoingDataFrameFlowControl(
 ValueOrHttp2Status<chttp2::FlowControlAction>
 ProcessIncomingDataFrameFlowControl(Http2FrameHeader& frame,
                                     chttp2::TransportFlowControl& flow_control,
-                                    RefCountedPtr<Stream> stream);
+                                    Stream* stream);
 
 // Returns true if a write should be triggered
 bool ProcessIncomingWindowUpdateFrameFlowControl(
     const Http2WindowUpdateFrame& frame,
-    chttp2::TransportFlowControl& flow_control, RefCountedPtr<Stream> stream);
+    chttp2::TransportFlowControl& flow_control, Stream* stream);
+
+void MaybeAddTransportWindowUpdateFrame(
+    chttp2::TransportFlowControl& flow_control, FrameSender& frame_sender);
 
-void MaybeAddStreamWindowUpdateFrame(RefCountedPtr<Stream> stream,
-                                     std::vector<Http2Frame>& frames);
+void MaybeAddStreamWindowUpdateFrame(Stream& stream, FrameSender& frame_sender);
 
 ///////////////////////////////////////////////////////////////////////////////
 // Header and Continuation frame processing helpers
@@ -242,7 +218,7 @@ void MaybeAddStreamWindowUpdateFrame(RefCountedPtr<Stream> stream,
 // it returns the original status.
 Http2Status ParseAndDiscardHeaders(HPackParser& parser, SliceBuffer&& buffer,
                                    HeaderAssembler::ParseHeaderArgs args,
-                                   RefCountedPtr<Stream> stream,
+                                   Stream* stream,
                                    Http2Status&& original_status);
 
 }  // namespace http2

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

@@ -295,9 +295,9 @@ struct PromiseEndpointReadTrace {
 };
 
 struct PromiseEndpointWriteTrace {
-  uint64_t bytes;
+  uint64_t count;
   channelz::PropertyList ChannelzProperties() const {
-    return channelz::PropertyList().Set("written_bytes", bytes);
+    return channelz::PropertyList().Set("frames_count", count);
   }
 };
 

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

@@ -21,10 +21,15 @@
 
 #include <cstdint>
 #include <string>
+#include <utility>
 
 #include "src/core/call/metadata_info.h"
 #include "src/core/ext/transport/chttp2/transport/frame.h"
+#include "src/core/lib/event_engine/tcp_socket_utils.h"
+#include "src/core/lib/slice/slice.h"
+#include "src/core/lib/transport/promise_endpoint.h"
 #include "src/core/util/grpc_check.h"
+#include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
 
 namespace grpc_core {
@@ -41,7 +46,8 @@ class IncomingMetadataTracker {
   // a time. This class is distinct from HeaderAssembler, which buffers header
   // payloads on a per-stream basis.
  public:
-  IncomingMetadataTracker() = default;
+  explicit IncomingMetadataTracker(Slice peer_string)
+      : peer_string_(std::move(peer_string)) {}
   ~IncomingMetadataTracker() = default;
 
   IncomingMetadataTracker(IncomingMetadataTracker&& rvalue) = delete;
@@ -49,6 +55,18 @@ class IncomingMetadataTracker {
   IncomingMetadataTracker(const IncomingMetadataTracker&) = delete;
   IncomingMetadataTracker& operator=(const IncomingMetadataTracker&) = delete;
 
+  static Slice GetPeerString(const PromiseEndpoint& endpoint) {
+    absl::StatusOr<std::string> uri =
+        grpc_event_engine::experimental::ResolvedAddressToURI(
+            endpoint.GetPeerAddress());
+    if (uri.ok()) {
+      return Slice::FromCopiedString(*uri);
+    }
+    return Slice::FromCopiedString("unknown");
+  }
+
+  Slice peer_string() const { return peer_string_.Ref(); }
+
   void set_soft_limit(uint32_t limit) {
     max_header_list_size_soft_limit_ = limit;
   }
@@ -88,7 +106,12 @@ class IncomingMetadataTracker {
   // Returns stream id of stream for which headers are being received.
   uint32_t GetStreamId() const { return incoming_header_stream_id_; }
 
-  bool ClientReceivedDuplicateMetadata(
+  // A gRPC server is permitted to send both initial metadata and trailing
+  // metadata where initial metadata is optional.
+  // A gRPC C++ client is permitted to send only initial metadata.
+  // However, other gRPC Client implementations may send trailing metadata too.
+  // So we allow only a maximum of 2 metadata per streams.
+  bool DidReceiveDuplicateMetadata(
       const bool did_receive_initial_metadata,
       const bool did_receive_trailing_metadata) const {
     const bool is_duplicate_initial_metadata =
@@ -98,13 +121,6 @@ class IncomingMetadataTracker {
     return is_duplicate_initial_metadata || is_duplicate_trailing_metadata;
   }
 
-  bool ServerReceivedDuplicateMetadata(
-      const bool did_receive_initial_metadata) const {
-    // TODO(tjagtap) : [PH2][P2] : Verify this when implementing Server.
-    // Also write a small unit test for it.
-    return !incoming_header_end_stream_ && did_receive_initial_metadata;
-  }
-
   std::string DebugString() const {
     return absl::StrCat(
         "{ incoming_header_in_progress : ",
@@ -115,6 +131,10 @@ class IncomingMetadataTracker {
   }
 
  private:
+  // Initialized only once at the time of transport creation.
+  // Should remain constant for the lifetime of the transport.
+  const Slice peer_string_;
+
   bool incoming_header_in_progress_ = false;
   bool incoming_header_end_stream_ = false;
   uint32_t incoming_header_stream_id_ = 0;

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

@@ -34,6 +34,7 @@
 #include <utility>
 #include <variant>
 
+#include "src/core/call/metadata.h"
 #include "src/core/call/metadata_batch.h"
 #include "src/core/channelz/channelz.h"
 #include "src/core/ext/transport/chttp2/transport/call_tracer_wrapper.h"
@@ -314,6 +315,7 @@ struct grpc_chttp2_transport final : public grpc_core::FilterStackTransport,
       transport_framing_endpoint_extension = nullptr;
 
   grpc_core::MemoryOwner memory_owner;
+  grpc_core::StreamQuotaRefPtr stream_quota;
   const grpc_core::MemoryAllocator::Reservation self_reservation;
   grpc_core::ReclamationSweep active_reclamation;
   grpc_core::InstrumentStorageRefPtr<grpc_core::ResourceQuotaDomain>
@@ -891,8 +893,10 @@ void grpc_chttp2_reset_ping_clock(grpc_chttp2_transport* t);
 void grpc_chttp2_mark_stream_writable(grpc_chttp2_transport* t,
                                       grpc_chttp2_stream* s);
 
-void grpc_chttp2_cancel_stream(grpc_chttp2_transport* t, grpc_chttp2_stream* s,
-                               grpc_error_handle due_to_error, bool tarpit);
+void grpc_chttp2_cancel_stream(
+    grpc_chttp2_transport* t, grpc_chttp2_stream* s,
+    grpc_error_handle due_to_error, bool tarpit,
+    grpc_core::ServerMetadataHandle send_trailing_metadata = nullptr);
 
 void grpc_chttp2_maybe_complete_recv_initial_metadata(grpc_chttp2_transport* t,
                                                       grpc_chttp2_stream* s);