grpc 1.78.0 → 1.80.0.pre1

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

@@ -44,9 +44,11 @@
 #include <variant>
 #include <vector>
 
+#include "src/core/call/metadata.h"
 #include "src/core/call/metadata_batch.h"
 #include "src/core/call/metadata_info.h"
 #include "src/core/channelz/property_list.h"
+#include "src/core/client_channel/client_channel_internal.h"
 #include "src/core/config/config_vars.h"
 #include "src/core/ext/transport/chttp2/transport/call_tracer_wrapper.h"
 #include "src/core/ext/transport/chttp2/transport/flow_control.h"
@@ -169,8 +171,9 @@ static void read_action_locked(grpc_core::RefCountedPtr<grpc_chttp2_transport>,
 static void continue_read_action_locked(
     grpc_core::RefCountedPtr<grpc_chttp2_transport> t);
 
-static void close_from_api(grpc_chttp2_transport* t, grpc_chttp2_stream* s,
-                           grpc_error_handle error, bool tarpit);
+static void close_from_api(
+    grpc_chttp2_transport* t, grpc_chttp2_stream* s, grpc_error_handle error,
+    bool tarpit, grpc_core::ServerMetadataHandle send_trailing_metadata);
 
 // Start new streams that have been created if we can
 static void maybe_start_some_streams(grpc_chttp2_transport* t);
@@ -347,6 +350,17 @@ std::string HttpAnnotation::ToString() const {
   return s;
 }
 
+void HttpAnnotation::ForEachKeyValue(
+    absl::FunctionRef<void(absl::string_view, ValueType)> f) const {
+  f("type", static_cast<int64_t>(type_));
+  f("time_sec", static_cast<int64_t>(time_.tv_sec));
+  f("time_nsec", static_cast<int64_t>(time_.tv_nsec));
+  if (write_stats_.has_value()) {
+    f("target_write_size",
+      static_cast<int64_t>(write_stats_->target_write_size));
+  }
+}
+
 }  // namespace grpc_core
 
 //
@@ -692,6 +706,8 @@ grpc_chttp2_transport::grpc_chttp2_transport(
       memory_owner(channel_args.GetObject<grpc_core::ResourceQuota>()
                        ->memory_quota()
                        ->CreateMemoryOwner()),
+      stream_quota(
+          channel_args.GetObject<grpc_core::ResourceQuota>()->stream_quota()),
       self_reservation(
           memory_owner.MakeReservation(sizeof(grpc_chttp2_transport))),
       // TODO(ctiller): clean this up so we don't need to RefAsSubclass
@@ -1393,7 +1409,7 @@ void grpc_chttp2_add_incoming_goaway(grpc_chttp2_transport* t,
         t->keepalive_time.millis() > max_keepalive_time_millis
             ? INT_MAX
             : t->keepalive_time.millis() * KEEPALIVE_TIME_BACKOFF_MULTIPLIER;
-    if (!grpc_core::IsTransportStateWatcherEnabled()) {
+    if (!grpc_core::IsSubchannelConnectionScalingEnabled()) {
       status.SetPayload(grpc_core::kKeepaliveThrottlingKey,
                         absl::Cord(std::to_string(throttled_keepalive_time)));
     }
@@ -1405,8 +1421,8 @@ void grpc_chttp2_add_incoming_goaway(grpc_chttp2_transport* t,
   if (!grpc_core::test_only_disable_transient_failure_state_notification) {
     connectivity_state_set(t, GRPC_CHANNEL_TRANSIENT_FAILURE, status,
                            "got_goaway");
+    t->NotifyStateWatcherOnDisconnectLocked(std::move(status), disconnect_info);
   }
-  t->NotifyStateWatcherOnDisconnectLocked(std::move(status), disconnect_info);
 }
 
 static void maybe_start_some_streams(grpc_chttp2_transport* t) {
@@ -1829,8 +1845,10 @@ static void perform_stream_op_locked(void* stream_op,
   }
 
   if (op->cancel_stream) {
-    grpc_chttp2_cancel_stream(t, s, op_payload->cancel_stream.cancel_error,
-                              op_payload->cancel_stream.tarpit);
+    grpc_chttp2_cancel_stream(
+        t, s, op_payload->cancel_stream.cancel_error,
+        op_payload->cancel_stream.tarpit,
+        std::move(op_payload->cancel_stream.send_trailing_metadata));
   }
 
   if (op->send_initial_metadata) {
@@ -2443,15 +2461,23 @@ void MaybeTarpit(grpc_chttp2_transport* t, bool tarpit, F fn) {
 }  // namespace
 }  // namespace grpc_core
 
-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) {
   if (!t->is_client && !s->sent_trailing_metadata &&
       grpc_error_has_clear_grpc_status(due_to_error) &&
       !(s->read_closed && s->write_closed)) {
-    close_from_api(t, s, due_to_error, tarpit);
+    close_from_api(t, s, due_to_error, tarpit,
+                   std::move(send_trailing_metadata));
     return;
   }
 
+  if (grpc_core::IsPromiseFilterSendCancelMetadataEnabled()) {
+    send_trailing_metadata.reset();
+  }
+  GRPC_DCHECK(send_trailing_metadata == nullptr);
+
   if (!due_to_error.ok() && !s->seen_error) {
     s->seen_error = true;
   }
@@ -2637,8 +2663,9 @@ grpc_chttp2_transport::RemovedStreamHandle grpc_chttp2_mark_stream_closed(
   return rsh;
 }
 
-static void close_from_api(grpc_chttp2_transport* t, grpc_chttp2_stream* s,
-                           grpc_error_handle error, bool tarpit) {
+static void close_from_api(
+    grpc_chttp2_transport* t, grpc_chttp2_stream* s, grpc_error_handle error,
+    bool tarpit, grpc_core::ServerMetadataHandle send_trailing_metadata) {
   grpc_status_code grpc_status;
   std::string message;
   grpc_error_get_status(error, s->deadline, &grpc_status, &message, nullptr,
@@ -2650,9 +2677,9 @@ static void close_from_api(grpc_chttp2_transport* t, grpc_chttp2_stream* s,
   auto remove_stream_handle = grpc_chttp2_mark_stream_closed(t, s, 1, 1, error);
   grpc_core::MaybeTarpit(
       t, tarpit,
-      [error = std::move(error),
-       sent_initial_metadata = s->sent_initial_metadata, id = s->id,
+      [sent_initial_metadata = s->sent_initial_metadata, id = s->id,
        grpc_status, message = std::move(message),
+       send_trailing_metadata = std::move(send_trailing_metadata),
        remove_stream_handle =
            std::move(remove_stream_handle)](grpc_chttp2_transport* t) mutable {
         grpc_slice hdr;
@@ -2660,6 +2687,9 @@ static void close_from_api(grpc_chttp2_transport* t, grpc_chttp2_stream* s,
         grpc_slice http_status_hdr;
         grpc_slice content_type_hdr;
         grpc_slice message_pfx;
+        size_t msg_len = message.length();
+        grpc_core::Slice message_slice =
+            grpc_core::Slice::FromCopiedString(std::move(message));
         uint8_t* p;
         uint32_t len = 0;
 
@@ -2726,57 +2756,70 @@ static void close_from_api(grpc_chttp2_transport* t, grpc_chttp2_stream* s,
           len += static_cast<uint32_t> GRPC_SLICE_LENGTH(content_type_hdr);
         }
 
-        status_hdr = GRPC_SLICE_MALLOC(15 + (grpc_status >= 10));
-        p = GRPC_SLICE_START_PTR(status_hdr);
-        *p++ = 0x00;  // literal header, not indexed
-        *p++ = 11;    // len(grpc-status)
-        *p++ = 'g';
-        *p++ = 'r';
-        *p++ = 'p';
-        *p++ = 'c';
-        *p++ = '-';
-        *p++ = 's';
-        *p++ = 't';
-        *p++ = 'a';
-        *p++ = 't';
-        *p++ = 'u';
-        *p++ = 's';
-        if (grpc_status < 10) {
-          *p++ = 1;
-          *p++ = static_cast<uint8_t>('0' + grpc_status);
+        grpc_core::RawEncoder raw_encoder(
+            t->settings.peer().allow_true_binary_metadata());
+
+        if (grpc_core::IsPromiseFilterSendCancelMetadataEnabled()) {
+          raw_encoder.Encode(grpc_core::GrpcStatusMetadata(), grpc_status);
+          raw_encoder.Encode(grpc_core::GrpcMessageMetadata(), message_slice);
+          if (send_trailing_metadata != nullptr) {
+            send_trailing_metadata->Encode(&raw_encoder);
+            send_trailing_metadata.reset();
+          }
+          len += raw_encoder.Length();
         } else {
-          *p++ = 2;
-          *p++ = static_cast<uint8_t>('0' + (grpc_status / 10));
-          *p++ = static_cast<uint8_t>('0' + (grpc_status % 10));
+          status_hdr = GRPC_SLICE_MALLOC(15 + (grpc_status >= 10));
+          p = GRPC_SLICE_START_PTR(status_hdr);
+          *p++ = 0x00;  // literal header, not indexed
+          *p++ = 11;    // len(grpc-status)
+          *p++ = 'g';
+          *p++ = 'r';
+          *p++ = 'p';
+          *p++ = 'c';
+          *p++ = '-';
+          *p++ = 's';
+          *p++ = 't';
+          *p++ = 'a';
+          *p++ = 't';
+          *p++ = 'u';
+          *p++ = 's';
+          if (grpc_status < 10) {
+            *p++ = 1;
+            *p++ = static_cast<uint8_t>('0' + grpc_status);
+          } else {
+            *p++ = 2;
+            *p++ = static_cast<uint8_t>('0' + (grpc_status / 10));
+            *p++ = static_cast<uint8_t>('0' + (grpc_status % 10));
+          }
+          GRPC_CHECK(p == GRPC_SLICE_END_PTR(status_hdr));
+          len += static_cast<uint32_t> GRPC_SLICE_LENGTH(status_hdr);
+
+          GRPC_CHECK(msg_len <= UINT32_MAX);
+          grpc_core::VarintWriter<1> msg_len_writer(
+              static_cast<uint32_t>(msg_len));
+          message_pfx = GRPC_SLICE_MALLOC(14 + msg_len_writer.length());
+          p = GRPC_SLICE_START_PTR(message_pfx);
+          *p++ = 0x00;  // literal header, not indexed
+          *p++ = 12;    // len(grpc-message)
+          *p++ = 'g';
+          *p++ = 'r';
+          *p++ = 'p';
+          *p++ = 'c';
+          *p++ = '-';
+          *p++ = 'm';
+          *p++ = 'e';
+          *p++ = 's';
+          *p++ = 's';
+          *p++ = 'a';
+          *p++ = 'g';
+          *p++ = 'e';
+          msg_len_writer.Write(0, p);
+          p += msg_len_writer.length();
+          GRPC_CHECK(p == GRPC_SLICE_END_PTR(message_pfx));
+          len += static_cast<uint32_t> GRPC_SLICE_LENGTH(message_pfx);
+          len += static_cast<uint32_t>(msg_len);
         }
-        GRPC_CHECK(p == GRPC_SLICE_END_PTR(status_hdr));
-        len += static_cast<uint32_t> GRPC_SLICE_LENGTH(status_hdr);
-
-        size_t msg_len = message.length();
-        GRPC_CHECK(msg_len <= UINT32_MAX);
-        grpc_core::VarintWriter<1> msg_len_writer(
-            static_cast<uint32_t>(msg_len));
-        message_pfx = GRPC_SLICE_MALLOC(14 + msg_len_writer.length());
-        p = GRPC_SLICE_START_PTR(message_pfx);
-        *p++ = 0x00;  // literal header, not indexed
-        *p++ = 12;    // len(grpc-message)
-        *p++ = 'g';
-        *p++ = 'r';
-        *p++ = 'p';
-        *p++ = 'c';
-        *p++ = '-';
-        *p++ = 'm';
-        *p++ = 'e';
-        *p++ = 's';
-        *p++ = 's';
-        *p++ = 'a';
-        *p++ = 'g';
-        *p++ = 'e';
-        msg_len_writer.Write(0, p);
-        p += msg_len_writer.length();
-        GRPC_CHECK(p == GRPC_SLICE_END_PTR(message_pfx));
-        len += static_cast<uint32_t> GRPC_SLICE_LENGTH(message_pfx);
-        len += static_cast<uint32_t>(msg_len);
+        GRPC_DCHECK(send_trailing_metadata == nullptr);
 
         hdr = GRPC_SLICE_MALLOC(9);
         p = GRPC_SLICE_START_PTR(hdr);
@@ -2797,10 +2840,13 @@ static void close_from_api(grpc_chttp2_transport* t, grpc_chttp2_stream* s,
           grpc_slice_buffer_add(&t->qbuf, http_status_hdr);
           grpc_slice_buffer_add(&t->qbuf, content_type_hdr);
         }
-        grpc_slice_buffer_add(&t->qbuf, status_hdr);
-        grpc_slice_buffer_add(&t->qbuf, message_pfx);
-        grpc_slice_buffer_add(&t->qbuf,
-                              grpc_slice_from_cpp_string(std::move(message)));
+        if (grpc_core::IsPromiseFilterSendCancelMetadataEnabled()) {
+          std::move(raw_encoder).Flush(&t->qbuf);
+        } else {
+          grpc_slice_buffer_add(&t->qbuf, status_hdr);
+          grpc_slice_buffer_add(&t->qbuf, message_pfx);
+          grpc_slice_buffer_add(&t->qbuf, message_slice.TakeCSlice());
+        }
         grpc_chttp2_reset_ping_clock(t);
         grpc_chttp2_add_rst_stream_to_next_write(
             t, id, static_cast<intptr_t>(Http2ErrorCode::kNoError), nullptr);
@@ -3668,6 +3714,10 @@ void grpc_chttp2_transport::MaybeNotifyOnReceiveSettingsLocked(
       [notify_on_receive_settings = std::move(notify_on_receive_settings),
        max_concurrent_streams]() mutable {
         grpc_core::ExecCtx exec_ctx;
-        std::move(notify_on_receive_settings)(max_concurrent_streams);
+        notify_on_receive_settings(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.
+        notify_on_receive_settings = nullptr;
       });
 }

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

@@ -135,6 +135,8 @@ class HttpAnnotation : public CallTracerAnnotationInterface::Annotation {
   }
 
   std::string ToString() const override;
+  void ForEachKeyValue(
+      absl::FunctionRef<void(absl::string_view, ValueType)> f) const override;
 
   Type http_type() const { return type_; }
   gpr_timespec time() const { return time_; }

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

@@ -37,6 +37,7 @@
 #include "src/core/lib/transport/bdp_estimator.h"
 #include "src/core/util/grpc_check.h"
 #include "src/core/util/time.h"
+#include "absl/container/flat_hash_set.h"
 #include "absl/functional/function_ref.h"
 #include "absl/log/log.h"
 #include "absl/status/status.h"
@@ -404,6 +405,14 @@ class TransportFlowControl final {
     return stats;
   }
 
+  void AddStreamToWindowUpdateList(const uint32_t stream_id) {
+    window_update_list_.insert(stream_id);
+  }
+  absl::flat_hash_set<uint32_t> DrainWindowUpdateList() {
+    return std::exchange(window_update_list_, {});
+  }
+  size_t window_update_list_size() const { return window_update_list_.size(); }
+
  private:
   friend class StreamFlowControl;
 
@@ -461,6 +470,7 @@ class TransportFlowControl final {
   int64_t announced_window_ = kDefaultWindow;
   uint32_t acked_init_window_ = kDefaultWindow;
   uint32_t sent_init_window_ = kDefaultWindow;
+  absl::flat_hash_set<uint32_t> window_update_list_;
 };
 
 // Implementation of flow control that abides to HTTP/2 spec and attempts
@@ -599,7 +609,7 @@ class StreamFlowControl final {
     return stats;
   }
 
-  void ReportIfStalled(bool is_client, uint32_t stream_id,
+  void ReportIfStalled(const bool is_client, const uint32_t stream_id,
                        const Http2Settings& peer_settings) const {
     if (remote_window_delta() + peer_settings.initial_window_size() <= 0 ||
         tfc_->remote_window_ == 0) {

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

@@ -223,8 +223,7 @@ class SerializeHeaderAndPayload {
     GRPC_HTTP2_FRAME_DLOG
         << "SerializeHeaderAndPayload Http2DataFrame Type:0 { stream_id:"
         << frame.stream_id << ", end_stream:" << frame.end_stream
-        << ", payload_length:" << frame.payload.Length()
-        << ", payload:" << MaybeTruncatePayload(frame.payload) << "}";
+        << ", payload_length:" << frame.payload.Length() << "}";
     auto hdr = extra_bytes_.TakeFirst(kFrameHeaderSize);
     Http2FrameHeader{static_cast<uint32_t>(frame.payload.Length()),
                      static_cast<uint8_t>(FrameType::kData),
@@ -241,8 +240,7 @@ class SerializeHeaderAndPayload {
         << "SerializeHeaderAndPayload Http2HeaderFrame Type:1 { stream_id:"
         << frame.stream_id << ", end_headers:" << frame.end_headers
         << ", end_stream:" << frame.end_stream
-        << ", payload_length:" << frame.payload.Length()
-        << ", payload:" << MaybeTruncatePayload(frame.payload) << "}";
+        << ", payload_length:" << frame.payload.Length() << "}";
     auto hdr = extra_bytes_.TakeFirst(kFrameHeaderSize);
     Http2FrameHeader{
         static_cast<uint32_t>(frame.payload.Length()),
@@ -262,7 +260,6 @@ class SerializeHeaderAndPayload {
                           << frame.stream_id
                           << ", end_headers:" << frame.end_headers
                           << ", payload_length:" << frame.payload.Length()
-                          << ", payload:" << MaybeTruncatePayload(frame.payload)
                           << "}";
     auto hdr = extra_bytes_.TakeFirst(kFrameHeaderSize);
     Http2FrameHeader{
@@ -880,14 +877,4 @@ Http2Status ValidateFrameHeader(const uint32_t max_frame_size_setting,
   // for server.
   return Http2Status::Ok();
 }
-
-std::string MaybeTruncatePayload(SliceBuffer& payload, const uint32_t length) {
-  if (payload.Length() <= length) {
-    return payload.JoinIntoString();
-  }
-  std::string result(length, '\0');
-  payload.CopyFirstNBytesIntoBuffer(length, result.data());
-  return absl::StrCat(result, "<clipped>");
-}
-
 }  // namespace grpc_core

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

@@ -32,10 +32,6 @@
 
 namespace grpc_core {
 
-// Prints the first `length` bytes of the payload. If the payload is longer than
-// `length`, it appends "<clipped>" to the output.
-std::string MaybeTruncatePayload(SliceBuffer& payload, uint32_t length = 15);
-
 ///////////////////////////////////////////////////////////////////////////////
 // Frame types
 //

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

@@ -18,6 +18,9 @@
 
 #include "src/core/ext/transport/chttp2/transport/goaway.h"
 
+#include <utility>
+
+#include "src/core/ext/transport/chttp2/transport/write_cycle.h"
 #include "src/core/util/grpc_check.h"
 
 namespace grpc_core {
@@ -57,14 +60,14 @@ std::optional<Http2Frame> GoawayManager::MaybeGetGoawayFrame() {
   return std::nullopt;
 }
 
-void GoawayManager::MaybeGetSerializedGoawayFrame(SliceBuffer& output_buf) {
+void GoawayManager::MaybeGetSerializedGoawayFrame(FrameSender& frame_sender) {
   GRPC_HTTP2_GOAWAY_LOG << "MaybeGetSerializedGoawayFrames: current state: "
                         << context_->GoawayStateToString(
                                context_->goaway_state);
 
   std::optional<Http2Frame> goaway_frame = MaybeGetGoawayFrame();
   if (goaway_frame.has_value()) {
-    Serialize(absl::Span<Http2Frame>(&goaway_frame.value(), 1), output_buf);
+    frame_sender.AddRegularFrame(std::move(goaway_frame.value()));
     GRPC_HTTP2_GOAWAY_LOG << "GOAWAY frame serialized.";
   }
 }
@@ -117,6 +120,18 @@ std::string GoawayManager::Context::GoawayStateToString(
   }
 }
 
+absl::Status GoawayManager::Context::TriggerWriteCycle() {
+  GRPC_HTTP2_GOAWAY_LOG << "TriggerWriteCycle: current state: "
+                        << GoawayStateToString(goaway_state);
+  absl::Status status = goaway_interface->TriggerWriteCycle();
+  if (!status.ok()) {
+    GRPC_HTTP2_GOAWAY_LOG << "TriggerWriteCycle failed with status: " << status;
+    goaway_state = GoawayState::kDone;
+  }
+
+  return status;
+}
+
 std::optional<Http2Frame> GoawayManager::TestOnlyMaybeGetGoawayFrame() {
   GRPC_HTTP2_GOAWAY_LOG << "TestOnlyMaybeGetGoawayFrame: current state: "
                         << context_->GoawayStateToString(

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

@@ -19,8 +19,12 @@
 #ifndef GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_GOAWAY_H
 #define GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_GOAWAY_H
 
+#include <cstdint>
+#include <optional>
+
 #include "src/core/ext/transport/chttp2/transport/frame.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/promise/activity.h"
 #include "src/core/lib/promise/if.h"
 #include "src/core/lib/promise/promise.h"
@@ -47,7 +51,7 @@ class GoawayInterface {
   virtual Promise<absl::Status> SendPingAndWaitForAck() = 0;
 
   // Triggers a transport write cycle.
-  virtual void TriggerWriteCycle() = 0;
+  virtual absl::Status TriggerWriteCycle() = 0;
 
   // Only used for graceful GOAWAY (and by extension relevant only for server).
   // Returns the last accepted stream id by the transport.
@@ -154,6 +158,7 @@ class GoawayManager {
     std::string GoawayStateToString(GoawayState goaway_state);
 
     void SentGoawayTransition();
+    absl::Status TriggerWriteCycle();
 
     GoawayState goaway_state = GoawayState::kIdle;
     std::unique_ptr<GoawayInterface> goaway_interface;
@@ -222,7 +227,10 @@ class GoawayManager {
           /*error_code=*/static_cast<uint32_t>(error_code),
           /*debug_data=*/debug_data.TakeOwned(),
           /*last_good_stream_id=*/last_good_stream_id);
-      ctx->goaway_interface->TriggerWriteCycle();
+      absl::Status status = ctx->TriggerWriteCycle();
+      if (!status.ok()) {
+        return status;
+      }
       return Pending{};
     };
   }
@@ -272,8 +280,11 @@ class GoawayManager {
               /*error_code=*/static_cast<uint32_t>(Http2ErrorCode::kNoError),
               /*debug_data=*/debug_data.TakeOwned(),
               /*last_good_stream_id=*/last_good_stream_id);
-          ctx->goaway_interface->TriggerWriteCycle();
-          return TrySeq(ctx->goaway_interface->SendPingAndWaitForAck(),
+
+          return TrySeq([ctx]() { return ctx->TriggerWriteCycle(); },
+                        [ctx]() {
+                          return ctx->goaway_interface->SendPingAndWaitForAck();
+                        },
                         [ctx]() -> Poll<absl::Status> {
                           GRPC_HTTP2_GOAWAY_LOG
                               << "Ping resolved. Current state: "
@@ -287,7 +298,11 @@ class GoawayManager {
                                    "kFinalGracefulGoawayScheduled.";
                             ctx->goaway_state =
                                 GoawayState::kFinalGracefulGoawayScheduled;
-                            ctx->goaway_interface->TriggerWriteCycle();
+                            absl::Status status =
+                                ctx->goaway_interface->TriggerWriteCycle();
+                            if (!status.ok()) {
+                              return status;
+                            }
                           }
                           return Pending{};
                         });
@@ -328,7 +343,7 @@ class GoawayManager {
 
   // Called from the transport write cycle to serialize the GOAWAY frame if
   // needed.
-  void MaybeGetSerializedGoawayFrame(SliceBuffer& output_buf);
+  void MaybeGetSerializedGoawayFrame(FrameSender& frame_sender);
 
   bool IsImmediateGoAway() const {
     return context_->goaway_state == GoawayState::kImmediateGoawayRequested;
@@ -339,6 +354,12 @@ class GoawayManager {
   // write cycle, this function handles the needed state transition.
   void NotifyGoawaySent();
 
+  static bool IsGracefulGoaway(Http2GoawayFrame& frame) {
+    return frame.error_code ==
+               static_cast<uint32_t>(Http2ErrorCode::kNoError) &&
+           frame.last_stream_id == RFC9113::kMaxStreamId31Bit;
+  }
+
   // Returns the current GOAWAY state.
   GoawayState TestOnlyGetGoawayState() const { return context_->goaway_state; }
   std::optional<Http2Frame> TestOnlyMaybeGetGoawayFrame();

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

@@ -57,21 +57,6 @@ constexpr absl::string_view kAssemblerHpackError =
     "RFC9113 : A decoding error in a field block MUST be treated as a "
     "connection error of type COMPRESSION_ERROR.";
 
-constexpr absl::string_view kGrpcErrorMaxTwoHeaderFrames =
-    "Too many header frames sent by peer";
-
-// 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. Which means only 2 HEADER frames are legal per stream.
-constexpr uint8_t kMaxHeaderFrames = 2;
-
-// TODO(tjagtap) : [PH2][P3] : Handle the case where a Server receives two
-// header frames. Which means that the client sent trailing metadata. While we
-// dont expect a gRPC C++ peer to behave like this, this might break interop
-// tests and genuine interop cases.
-
 // RFC9113
 // https://www.rfc-editor.org/rfc/rfc9113.html#name-field-section-compression-a
 // A complete field section (which contains our gRPC Metadata) consists of
@@ -154,7 +139,7 @@ class HeaderAssembler {
 
   // The caller MUST check using IsReady() before calling this function
   ValueOrHttp2Status<Arena::PoolPtr<grpc_metadata_batch>> ReadMetadata(
-      HPackParser& parser, bool is_initial_metadata, bool is_client,
+      HPackParser& parser, bool is_initial_metadata,
       const uint32_t max_header_list_size_soft_limit,
       const uint32_t max_header_list_size_hard_limit) {
     ASSEMBLER_LOG << "HeaderAssembler::ReadMetadata " << buffer_.Length()
@@ -185,7 +170,7 @@ class HeaderAssembler {
         ParseHeaderArgs{
             /*is_initial_metadata=*/is_initial_metadata,
             /*is_end_headers=*/is_ready_,
-            /*is_client=*/is_client,
+            /*is_client=*/is_client_,
             /*max_header_list_size_soft_limit=*/max_header_list_size_soft_limit,
             /*max_header_list_size_hard_limit=*/max_header_list_size_hard_limit,
             /*stream_id=*/stream_id_,
@@ -199,13 +184,13 @@ class HeaderAssembler {
   }
 
   Http2Status ParseAndDiscardHeaders(
-      HPackParser& parser, const bool is_initial_metadata, const bool is_client,
+      HPackParser& parser, const bool is_initial_metadata,
       const uint32_t max_header_list_size_soft_limit,
       const uint32_t max_header_list_size_hard_limit) {
     ASSEMBLER_LOG << "HeaderAssembler::ParseAndDiscardHeaders "
                   << buffer_.Length() << " Bytes"
                   << " is_initial_metadata: " << is_initial_metadata
-                  << " is_client: " << is_client
+                  << " is_client: " << is_client_
                   << " max_header_list_size_soft_limit: "
                   << max_header_list_size_soft_limit
                   << "max_header_list_size_hard_limit: "
@@ -215,7 +200,7 @@ class HeaderAssembler {
         ParseHeaderArgs{
             /*is_initial_metadata=*/is_initial_metadata,
             /*is_end_headers=*/is_ready_,
-            /*is_client=*/is_client,
+            /*is_client=*/is_client_,
             /*max_header_list_size_soft_limit=*/max_header_list_size_soft_limit,
             /*max_header_list_size_hard_limit=*/max_header_list_size_hard_limit,
             /*stream_id=*/stream_id_,
@@ -229,10 +214,11 @@ class HeaderAssembler {
   // This value MUST be checked before calling ReadMetadata()
   bool IsReady() const { return is_ready_; }
 
-  explicit HeaderAssembler()
+  explicit HeaderAssembler(const bool is_client)
       : header_in_progress_(false),
         is_ready_(false),
         allow_true_binary_metadata_acked_(true),
+        is_client_(is_client),
         stream_id_(0) {}
 
   ~HeaderAssembler() = default;
@@ -338,6 +324,7 @@ class HeaderAssembler {
   bool header_in_progress_;
   bool is_ready_;
   bool allow_true_binary_metadata_acked_;
+  const bool is_client_;
   uint32_t stream_id_;
   SliceBuffer buffer_;
 };