grpc 1.75.0 → 1.78.1

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

@@ -19,52 +19,75 @@
 #ifndef GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HTTP2_CLIENT_TRANSPORT_H
 #define GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HTTP2_CLIENT_TRANSPORT_H
 
+#include <grpc/event_engine/event_engine.h>
+#include <grpc/grpc.h>
+#include <grpc/support/port_platform.h>
+
+#include <cstddef>
 #include <cstdint>
+#include <memory>
+#include <optional>
+#include <string>
 #include <utility>
+#include <vector>
 
 #include "src/core/call/call_spine.h"
+#include "src/core/call/metadata.h"
+#include "src/core/channelz/channelz.h"
+#include "src/core/ext/transport/chttp2/transport/flow_control.h"
 #include "src/core/ext/transport/chttp2/transport/frame.h"
-#include "src/core/ext/transport/chttp2/transport/header_assembler.h"
+#include "src/core/ext/transport/chttp2/transport/goaway.h"
 #include "src/core/ext/transport/chttp2/transport/hpack_encoder.h"
 #include "src/core/ext/transport/chttp2/transport/hpack_parser.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/http2_transport.h"
+#include "src/core/ext/transport/chttp2/transport/http2_ztrace_collector.h"
+#include "src/core/ext/transport/chttp2/transport/incoming_metadata_tracker.h"
 #include "src/core/ext/transport/chttp2/transport/keepalive.h"
-#include "src/core/ext/transport/chttp2/transport/message_assembler.h"
 #include "src/core/ext/transport/chttp2/transport/ping_promise.h"
+#include "src/core/ext/transport/chttp2/transport/stream.h"
 #include "src/core/ext/transport/chttp2/transport/stream_data_queue.h"
 #include "src/core/ext/transport/chttp2/transport/writable_streams.h"
-#include "src/core/lib/promise/inter_activity_mutex.h"
-#include "src/core/lib/promise/loop.h"
-#include "src/core/lib/promise/mpsc.h"
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/iomgr/closure.h"
+#include "src/core/lib/iomgr/iomgr_fwd.h"
+#include "src/core/lib/promise/activity.h"
+#include "src/core/lib/promise/context.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"
+#include "src/core/lib/promise/poll.h"
+#include "src/core/lib/promise/promise.h"
+#include "src/core/lib/promise/race.h"
+#include "src/core/lib/promise/try_seq.h"
+#include "src/core/lib/resource_quota/memory_quota.h"
+#include "src/core/lib/slice/slice.h"
+#include "src/core/lib/slice/slice_buffer.h"
 #include "src/core/lib/transport/connectivity_state.h"
 #include "src/core/lib/transport/promise_endpoint.h"
 #include "src/core/lib/transport/transport.h"
+#include "src/core/util/check_class_size.h"
+#include "src/core/util/debug_location.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/orphanable.h"
 #include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/sync.h"
+#include "src/core/util/time.h"
+#include "absl/base/thread_annotations.h"
+#include "absl/container/flat_hash_map.h"
+#include "absl/container/flat_hash_set.h"
+#include "absl/functional/any_invocable.h"
+#include "absl/log/log.h"
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/span.h"
 
 namespace grpc_core {
 namespace http2 {
 
-// All Promise Based HTTP2 Transport TODOs have the tag
-// [PH2][Pn] where n = 0 to 5.
-// This helps to maintain the uniformity for quick lookup and fixing.
-//
-// [PH2][P0] MUST be fixed before the current PR is submitted.
-// [PH2][P1] MUST be fixed before the current sub-project is considered
-//           complete.
-// [PH2][P2] MUST be fixed before the current Milestone is considered
-//           complete.
-// [PH2][P3] MUST be fixed before Milestone 3 is considered complete.
-// [PH2][P4] Can be fixed after roll out begins. Evaluate these during
-//           Milestone 4. Either do the TODOs or delete them.
-// [PH2][P5] This MUST be a separate standalone project.
-// [PH2][EXT] This is a TODO related to a project unrelated to PH2 but happening
-//            in parallel.
-
 // Http2 Client Transport Spawns Overview
 
 // | Promise Spawn       | Max Duration | Promise Resolution    | Max Spawns |
@@ -78,22 +101,21 @@ namespace http2 {
 // Max Party Slots (Always): 3
 // Max Promise Slots (Worst Case): 4
 
-// Experimental : This is just the initial skeleton of class
-// and it is functions. The code will be written iteratively.
+// Experimental : The code will be written iteratively.
 // Do not use or edit any of these functions unless you are
 // familiar with the PH2 project (Moving chttp2 to promises.)
 // TODO(tjagtap) : [PH2][P3] : Update the experimental status of the code before
 // http2 rollout begins.
-class Http2ClientTransport final : public ClientTransport {
-  // TODO(tjagtap) : [PH2][P3] Move the definitions to the header for better
-  // inlining. For now definitions are in the cc file to
-  // reduce cognitive load in the header.
+class Http2ClientTransport final : public ClientTransport,
+                                   public channelz::DataSource {
+  // TODO(akshitpatel) [PH2][P1] : Functions that need a mutex to be held should
+  // have "locked" suffix in function name.
  public:
   Http2ClientTransport(
       PromiseEndpoint endpoint, GRPC_UNUSED const ChannelArgs& channel_args,
       std::shared_ptr<grpc_event_engine::experimental::EventEngine>
           event_engine,
-      grpc_closure* on_receive_settings);
+      absl::AnyInvocable<void(absl::StatusOr<uint32_t>)> on_receive_settings);
 
   Http2ClientTransport(const Http2ClientTransport&) = delete;
   Http2ClientTransport& operator=(const Http2ClientTransport&) = delete;
@@ -120,36 +142,56 @@ class Http2ClientTransport final : public ClientTransport {
       OrphanablePtr<ConnectivityStateWatcherInterface> watcher);
   void StopConnectivityWatch(ConnectivityStateWatcherInterface* watcher);
 
+  void StartWatch(RefCountedPtr<StateWatcher> watcher) override;
+  void StopWatch(RefCountedPtr<StateWatcher> watcher) override;
+
   void Orphan() override;
-  void AbortWithError();
 
   RefCountedPtr<channelz::SocketNode> GetSocketNode() const override {
+    return const_cast<channelz::BaseNode*>(
+               channelz::DataSource::channelz_node())
+        ->RefAsSubclass<channelz::SocketNode>();
+  }
+
+  std::unique_ptr<channelz::ZTrace> GetZTrace(absl::string_view name) override {
+    if (name == "transport_frames") return ztrace_collector_->MakeZTrace();
     return nullptr;
   }
 
-  auto TestOnlyEnqueueOutgoingFrame(Http2Frame frame) {
-    // TODO(tjagtap) : [PH2][P3] : See if making a sender in the constructor
-    // and using that always would be more efficient.
-    return AssertResultType<absl::Status>(Map(
-        outgoing_frames_.MakeSender().Send(std::move(frame), 1),
-        [](StatusFlag status) {
-          GRPC_HTTP2_CLIENT_DLOG
-              << "Http2ClientTransport::TestOnlyEnqueueOutgoingFrame status="
-              << status;
-          return (status.ok()) ? absl::OkStatus()
-                               : absl::InternalError("Failed to enqueue frame");
-        }));
+  void AddData(channelz::DataSink sink) override;
+  void SpawnAddChannelzData(RefCountedPtr<Party> party,
+                            channelz::DataSink sink);
+
+  auto TestOnlyTriggerWriteCycle() {
+    return Immediate(writable_stream_list_.ForceReadyForWrite());
   }
 
   auto TestOnlySendPing(absl::AnyInvocable<void()> on_initiate,
                         bool important = false) {
-    return ping_manager_.RequestPing(std::move(on_initiate), important);
+    return ping_manager_->RequestPing(std::move(on_initiate), important);
   }
 
   template <typename Factory>
-  auto TestOnlySpawnPromise(absl::string_view name, Factory factory) {
-    return general_party_->Spawn(name, std::move(factory), [](auto) {});
+  void TestOnlySpawnPromise(absl::string_view name, Factory&& factory) {
+    general_party_->Spawn(name, std::forward<Factory>(factory), [](Empty) {});
+  }
+
+  int64_t TestOnlyTransportFlowControlWindow() {
+    return flow_control_.remote_window();
+  }
+
+  int64_t TestOnlyGetStreamFlowControlWindow(const uint32_t stream_id) {
+    RefCountedPtr<Stream> stream = LookupStream(stream_id);
+    if (stream == nullptr) {
+      return -1;
+    }
+    return stream->flow_control.remote_window_delta();
+  }
+
+  bool AreTransportFlowControlTokensAvailable() {
+    return flow_control_.remote_window() > 0;
   }
+  void SpawnTransportLoops();
 
  private:
   // Promise factory for processing each type of frame
@@ -162,10 +204,7 @@ class Http2ClientTransport final : public ClientTransport {
   Http2Status ProcessHttp2WindowUpdateFrame(Http2WindowUpdateFrame frame);
   Http2Status ProcessHttp2ContinuationFrame(Http2ContinuationFrame frame);
   Http2Status ProcessHttp2SecurityFrame(Http2SecurityFrame frame);
-  Http2Status ProcessMetadata(uint32_t stream_id, HeaderAssembler& assembler,
-                              CallHandler& call,
-                              bool& did_push_initial_metadata,
-                              bool& did_push_trailing_metadata);
+  Http2Status ProcessMetadata(RefCountedPtr<Stream> stream);
 
   // Reading from the endpoint.
 
@@ -179,204 +218,89 @@ class Http2ClientTransport final : public ClientTransport {
   // Returns a promise that will process one HTTP2 frame.
   auto ProcessOneFrame(Http2Frame frame);
 
-  // Returns a promise that will do the cleanup after the ReadLoop ends.
-  auto OnReadLoopEnded();
-
   // Writing to the endpoint.
 
-  // Read from the MPSC queue and write it.
-  auto WriteFromQueue();
-
-  // Returns a promise to keep writing in a Loop till a fail/close is
-  // received.
-  auto WriteLoop();
-
-  // Returns a promise that will do the cleanup after the WriteLoop ends.
-  auto OnWriteLoopEnded();
+  // Write time sensitive control frames to the endpoint. Frames sent from here
+  // will be GOAWAY, SETTINGS, PING and PING acks, WINDOW_UPDATE and
+  // Custom gRPC security frame.
+  // These frames are written to the endpoint in a single endpoint write. If any
+  // module needs to take action after the write (for cases like spawning
+  // timeout promises), they MUST plug the call in the
+  // NotifyControlFramesWriteDone.
+  auto ProcessAndWriteControlFrames();
 
-  // Returns a promise to keep draining data and control frames from all the
-  // active streams. This includes all stream specific frames like data, header,
-  // continuation and reset stream frames.
-  auto StreamMultiplexerLoop();
+  // Notify the control frames modules that the endpoint write is done.
+  void NotifyControlFramesWriteDone();
 
-  // Returns a promise that will do the cleanup after the StreamMultiplexerLoop
-  // ends.
-  auto OnStreamMultiplexerLoopEnded();
+  // Returns a promise to keep draining control frames and data frames from all
+  // the writable streams and write to the endpoint.
+  auto MultiplexerLoop();
 
   // Returns a promise to fetch data from the callhandler and pass it further
   // down towards the endpoint.
-  auto CallOutboundLoop(CallHandler call_handler, uint32_t stream_id,
-                        InterActivityMutex<uint32_t>::Lock lock,
+  auto CallOutboundLoop(CallHandler call_handler, RefCountedPtr<Stream> stream,
                         ClientMetadataHandle metadata);
 
-  // Returns a promise to enqueue a frame to MPSC
-  auto EnqueueOutgoingFrame(Http2Frame frame) {
-    // TODO(tjagtap) : [PH2][P3] : See if making a sender in the constructor
-    // and using that always would be more efficient.
-    return AssertResultType<absl::Status>(Map(
-        outgoing_frames_.MakeSender().Send(std::move(frame), 1),
-        [self = RefAsSubclass<Http2ClientTransport>()](StatusFlag status) {
-          GRPC_HTTP2_CLIENT_DLOG
-              << "Http2ClientTransport::EnqueueOutgoingFrame status=" << status;
-          return (status.ok())
-                     ? absl::OkStatus()
-                     : self->HandleError(Http2Status::AbslConnectionError(
-                           absl::StatusCode::kInternal,
-                           "Failed to enqueue frame"));
-        }));
+  // TODO(akshitpatel) : [PH2][P1] : Make this a synchronous function.
+  // Force triggers a transport write cycle
+  auto TriggerWriteCycle() {
+    return Immediate(writable_stream_list_.ForceReadyForWrite());
   }
 
-  // Force triggers a transport write cycle
-  auto TriggerWriteCycle() { return EnqueueOutgoingFrame(Http2EmptyFrame{}); }
+  auto FlowControlPeriodicUpdateLoop();
+  // TODO(tjagtap) [PH2][P2][BDP] Remove this when the BDP code is done.
+  void AddPeriodicUpdatePromiseWaker() {
+    periodic_updates_waker_ = GetContext<Activity>()->MakeNonOwningWaker();
+  }
+  // TODO(tjagtap) [PH2][P2][BDP] Remove this when the BDP code is done.
+  void WakeupPeriodicUpdatePromise() { periodic_updates_waker_.Wakeup(); }
+
+  // Processes the flow control action and take necessary steps.
+  void ActOnFlowControlAction(const chttp2::FlowControlAction& action,
+                              RefCountedPtr<Stream> stream);
+
+  void NotifyStateWatcherOnDisconnectLocked(
+      absl::Status status, StateWatcher::DisconnectInfo disconnect_info)
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(&transport_mutex_);
 
   RefCountedPtr<Party> general_party_;
+  std::shared_ptr<grpc_event_engine::experimental::EventEngine> event_engine_;
 
   PromiseEndpoint endpoint_;
-  Http2SettingsManager settings_;
-  Duration settings_timeout_;
+  RefCountedPtr<SettingsPromiseManager> settings_;
 
   Http2FrameHeader current_frame_header_;
+  // Returns the number of active streams. A stream is removed from the `active`
+  // list once both client and server agree to close the stream. The count of
+  // stream_list_(even though stream list represents streams open for reads)
+  // works here because of the following cases where the stream is closed:
+  // 1. Reading a RST stream frame: In this case, the stream is immediately
+  //    closed for reads and writes and removed from the stream_list_
+  //    (effectively tracking the number of active streams).
+  // 2. Reading a Trailing Metadata frame: In this case, the stream MAY be
+  //    closed for reads and writes immediately which follows the above case. In
+  //    other cases, the transport either reads RST stream frame from the server
+  //    (and follows case 1) or sends a half close frame and closes the stream
+  //    for reads and writes (in the multiplexer loop).
+  // 3. Hitting error condition in the transport: In this case, RST stream is
+  //    is enqueued and the stream is closed for reads immediately. This means
+  //    we effectively reduce the number of active streams inline (because we
+  //    remove the stream from the stream_list_). This is fine because the
+  //    priority logic in list of writable streams ensures that the RST stream
+  //    frame is given priority over any new streams being created by the
+  //    client.
+  // 4. Application abort: In this case, multiplexer loop will write RST stream
+  //    frame to the endpoint and close the stream from reads and writes. This
+  //    then follows the same reasoning as case 1.
+  inline uint32_t GetActiveStreamCountLocked() const
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(transport_mutex_) {
+    return stream_list_.size();
+  }
 
-  // Managing the streams
-  struct Stream : public RefCounted<Stream> {
-    explicit Stream(CallHandler call, const uint32_t stream_id1)
-        : call(std::move(call)),
-          stream_state(HttpStreamState::kIdle),
-          stream_id(stream_id1),
-          header_assembler(stream_id1),
-          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)) {}
-
-    ////////////////////////////////////////////////////////////////////////////
-    // Data Queue Helpers
-
-    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);
-    }
-
-    auto DequeueFrames(const uint32_t transport_tokens,
-                       const uint32_t max_frame_length,
-                       HPackCompressor& encoder) {
-      return data_queue->DequeueFrames(transport_tokens, max_frame_length,
-                                       encoder);
-    }
-
-    ////////////////////////////////////////////////////////////////////////////
-    // Stream State Management
-
-    // Modify the stream state
-    // The possible stream transitions are as follows:
-    // kIdle -> kOpen
-    // kOpen -> kClosed/kHalfClosedLocal/kHalfClosedRemote
-    // kHalfClosedLocal/kHalfClosedRemote -> kClosed
-    // kClosed -> kClosed
-    void SentInitialMetadata() {
-      DCHECK(stream_state == HttpStreamState::kIdle);
-      stream_state = HttpStreamState::kOpen;
-    }
-
-    void MarkHalfClosedLocal() {
-      switch (stream_state) {
-        case HttpStreamState::kIdle:
-          DCHECK(false) << "MarkHalfClosedLocal called for an idle stream";
-          break;
-        case HttpStreamState::kOpen:
-          stream_state = HttpStreamState::kHalfClosedLocal;
-          break;
-        case HttpStreamState::kHalfClosedRemote:
-          stream_state = HttpStreamState::kClosed;
-          break;
-        case HttpStreamState::kHalfClosedLocal:
-          break;
-        case HttpStreamState::kClosed:
-          DCHECK(false) << "MarkHalfClosedLocal called for a closed stream";
-          break;
-      }
-    }
-
-    void MarkHalfClosedRemote() {
-      switch (stream_state) {
-        case HttpStreamState::kIdle:
-          DCHECK(false) << "MarkHalfClosedRemote called for an idle stream";
-          break;
-        case HttpStreamState::kOpen:
-          stream_state = HttpStreamState::kHalfClosedRemote;
-          break;
-        case HttpStreamState::kHalfClosedLocal:
-          stream_state = HttpStreamState::kClosed;
-          break;
-        case HttpStreamState::kHalfClosedRemote:
-          break;
-        case HttpStreamState::kClosed:
-          DCHECK(false) << "MarkHalfClosedRemote called for a closed stream";
-          break;
-      }
-    }
-
-    HttpStreamState GetStreamState() const { return stream_state; }
-
-    inline bool IsClosed() const {
-      return stream_state == HttpStreamState::kClosed;
-    }
-
-    CallHandler call;
-    // TODO(akshitpatel) : [PH2][P3] : Investigate if this needs to be atomic.
-    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;
-  };
-
-  uint32_t NextStreamId(
-      InterActivityMutex<uint32_t>::Lock& next_stream_id_lock) {
-    const uint32_t stream_id = *next_stream_id_lock;
-    if (stream_id > RFC9113::kMaxStreamId31Bit) {
+  // Returns the next stream id. If the next stream id is not available, it
+  // returns std::nullopt. MUST be called from the transport party.
+  absl::StatusOr<uint32_t> NextStreamId() {
+    if (next_stream_id_ > GetMaxAllowedStreamId()) {
       // TODO(tjagtap) : [PH2][P3] : Handle case if transport runs out of stream
       // ids
       // RFC9113 : Stream identifiers cannot be reused. Long-lived connections
@@ -386,75 +310,109 @@ class Http2ClientTransport final : public ClientTransport {
       // that is unable to establish a new stream identifier can send a GOAWAY
       // frame so that the client is forced to open a new connection for new
       // streams.
+      return absl::ResourceExhaustedError("No more stream ids available");
+    }
+    // TODO(akshitpatel) : [PH2][P3] : There is a channel arg to delay
+    // starting new streams instead of failing them. This needs to be
+    // implemented.
+    {
+      MutexLock lock(&transport_mutex_);
+      if (GetActiveStreamCountLocked() >=
+          settings_->peer().max_concurrent_streams()) {
+        return absl::ResourceExhaustedError("Reached max concurrent streams");
+      }
     }
+
     // RFC9113 : Streams initiated by a client MUST use odd-numbered stream
     // identifiers.
-    (*next_stream_id_lock) += 2;
-    return stream_id;
+    uint32_t new_stream_id =
+        std::exchange(next_stream_id_, next_stream_id_ + 2);
+    if (GPR_UNLIKELY(next_stream_id_ > GetMaxAllowedStreamId())) {
+      ReportDisconnection(
+          absl::ResourceExhaustedError("Transport Stream IDs exhausted"),
+          {},  // TODO(tjagtap) : [PH2][P2] : Report better disconnect info.
+          "no_more_stream_ids");
+    }
+    return new_stream_id;
   }
 
-  MpscReceiver<Http2Frame> outgoing_frames_;
+  // Returns the next stream id without incrementing it. MUST be called from the
+  // transport party.
+  uint32_t PeekNextStreamId() const { return next_stream_id_; }
+
+  // Returns the last stream id sent by the transport. If no streams were sent,
+  // returns 0. MUST be called from the transport party.
+  uint32_t GetLastStreamId() const {
+    const uint32_t next_stream_id = PeekNextStreamId();
+    return (next_stream_id > 1) ? (next_stream_id - 2) : 0;
+  }
+
+  absl::Status InitializeStream(RefCountedPtr<Stream> stream);
+
+  void AddToStreamList(RefCountedPtr<Stream> stream);
 
   Mutex transport_mutex_;
-  // TODO(tjagtap) : [PH2][P2] : Add to map in StartCall and clean this
-  // mapping up in the on_done of the CallInitiator or CallHandler
+
   absl::flat_hash_map<uint32_t, RefCountedPtr<Stream>> stream_list_
       ABSL_GUARDED_BY(transport_mutex_);
 
-  // Mutex to preserve the order of headers being sent out for new streams.
-  // This also tracks the stream_id for creating new streams.
-  InterActivityMutex<uint32_t> stream_id_mutex_;
+  uint32_t next_stream_id_;
   HPackCompressor encoder_;
   HPackParser parser_;
   bool is_transport_closed_ ABSL_GUARDED_BY(transport_mutex_) = false;
+  Latch<void> transport_closed_latch_;
+
+  template <typename Promise>
+  auto UntilTransportClosed(Promise promise) {
+    return Race(Map(transport_closed_latch_.Wait(),
+                    [](Empty) {
+                      GRPC_HTTP2_CLIENT_DLOG << "Transport closed";
+                      return absl::CancelledError("Transport closed");
+                    }),
+                std::move(promise));
+  }
+
+  // Spawns an infallible promise on the given party.
+  template <typename Factory>
+  void SpawnInfallible(RefCountedPtr<Party> party, absl::string_view name,
+                       Factory&& factory);
+
+  // Spawns an infallible promise on the transport party.
+  template <typename Factory>
+  void SpawnInfallibleTransportParty(absl::string_view name, Factory&& factory);
+
+  // Spawns a promise on the transport party. If the promise returns a non-ok
+  // status, it is handled by closing the transport with the corresponding
+  // status.
+  template <typename Factory>
+  void SpawnGuardedTransportParty(absl::string_view name, Factory&& factory);
 
   ConnectivityStateTracker state_tracker_ ABSL_GUARDED_BY(transport_mutex_){
       "http2_client", GRPC_CHANNEL_READY};
 
-  bool MakeStream(CallHandler call_handler, uint32_t stream_id);
+  RefCountedPtr<StateWatcher> watcher_ ABSL_GUARDED_BY(transport_mutex_);
 
-  struct CloseStreamArgs {
-    bool close_reads;
-    bool close_writes;
-    bool send_rst_stream;
-    bool push_trailing_metadata;
-  };
+  // Runs on the call party.
+  std::optional<RefCountedPtr<Stream>> MakeStream(CallHandler call_handler);
 
   // This function MUST be idempotent.
-  void CloseStream(uint32_t stream_id, absl::Status status,
-                   CloseStreamArgs args, DebugLocation whence = {});
-
-  RefCountedPtr<Http2ClientTransport::Stream> LookupStream(uint32_t stream_id);
-
-  auto EndpointReadSlice(const size_t num_bytes) {
-    return Map(endpoint_.ReadSlice(num_bytes),
-               [self = RefAsSubclass<Http2ClientTransport>()](
-                   absl::StatusOr<Slice> status) {
-                 // We are ignoring the case where the read fails and call
-                 // GotData() regardless. Reasoning:
-                 // 1. It is expected that if the read fails, the transport will
-                 //    close and the keepalive loop will be stopped.
-                 // 2. It does not seem worth to have an extra condition for the
-                 //    success cases which would be way more common.
-                 self->keepalive_manager_.GotData();
-                 return status;
-               });
-  }
+  void CloseStream(RefCountedPtr<Stream> stream, CloseStreamArgs args,
+                   DebugLocation whence = {});
 
-  auto EndpointRead(const size_t num_bytes) {
-    return Map(endpoint_.Read(num_bytes),
-               [self = RefAsSubclass<Http2ClientTransport>()](
-                   absl::StatusOr<SliceBuffer> status) {
-                 // We are ignoring the case where the read fails and call
-                 // GotData() regardless. Reasoning:
-                 // 1. It is expected that if the read fails, the transport will
-                 //    close and the keepalive loop will be stopped.
-                 // 2. It does not seem worth to have an extra condition for the
-                 //    success cases which would be way more common.
-                 self->keepalive_manager_.GotData();
-                 return status;
-               });
-  }
+  void BeginCloseStream(RefCountedPtr<Stream> stream,
+                        std::optional<uint32_t> reset_stream_error_code,
+                        ServerMetadataHandle&& metadata,
+                        DebugLocation whence = {});
+
+  RefCountedPtr<Stream> LookupStream(uint32_t stream_id);
+
+  auto EndpointReadSlice(const size_t num_bytes);
+  auto EndpointRead(const size_t num_bytes);
+
+  // HTTP2 Settings
+  auto WaitForSettingsTimeoutOnDone();
+  void MaybeSpawnWaitForSettingsTimeout();
+  void EnforceLatestIncomingSettings();
 
   // This function MUST run on the transport party.
   void CloseTransport();
@@ -470,23 +428,25 @@ class Http2ClientTransport final : public ClientTransport {
   // should not be cancelled in case of stream errors.
   // If the error is a connection error, it closes the transport and returns the
   // corresponding (failed) absl status.
-  absl::Status HandleError(Http2Status status, DebugLocation whence = {}) {
+  absl::Status HandleError(const std::optional<uint32_t> stream_id,
+                           Http2Status status, DebugLocation whence = {}) {
     auto error_type = status.GetType();
-    DCHECK(error_type != Http2Status::Http2ErrorType::kOk);
+    GRPC_DCHECK(error_type != Http2Status::Http2ErrorType::kOk);
 
     if (error_type == Http2Status::Http2ErrorType::kStreamError) {
-      LOG(ERROR) << "Stream Error: " << status.DebugString();
-      CloseStream(current_frame_header_.stream_id, status.GetAbslStreamError(),
-                  CloseStreamArgs{
-                      /*close_reads=*/true,
-                      /*close_writes=*/true,
-                      /*send_rst_stream=*/true,
-                      /*push_trailing_metadata=*/true,
-                  },
-                  whence);
+      GRPC_HTTP2_CLIENT_ERROR_DLOG << "Stream Error: " << status.DebugString();
+      GRPC_DCHECK(stream_id.has_value());
+      // Passing a cancelled server metadata handle to propagate the error
+      // to the upper layers.
+      BeginCloseStream(
+          LookupStream(stream_id.value()),
+          Http2ErrorCodeToFrameErrorCode(status.GetStreamErrorCode()),
+          CancelledServerMetadataFromStatus(status.GetAbslStreamError()),
+          whence);
       return absl::OkStatus();
     } else if (error_type == Http2Status::Http2ErrorType::kConnectionError) {
-      LOG(ERROR) << "Connection Error: " << status.DebugString();
+      GRPC_HTTP2_CLIENT_ERROR_DLOG << "Connection Error: "
+                                   << status.DebugString();
       absl::Status absl_status = status.GetAbslConnectionError();
       MaybeSpawnCloseTransport(std::move(status), whence);
       return absl_status;
@@ -494,79 +454,81 @@ class Http2ClientTransport final : public ClientTransport {
     GPR_UNREACHABLE_CODE(return absl::InternalError("Invalid error type"));
   }
 
-  bool bytes_sent_in_last_write_;
-  bool incoming_header_in_progress_;
-  bool incoming_header_end_stream_;
+  bool should_reset_ping_clock_;
   bool is_first_write_;
-  uint32_t incoming_header_stream_id_;
-  grpc_closure* on_receive_settings_;
+  IncomingMetadataTracker incoming_headers_;
+
+  // The target number of bytes to write in a single write cycle. We may not
+  // always honour this max_write_size. We MAY overshoot it at most once per
+  // write cycle.
+  size_t max_write_size_;
+  // The number of bytes remaining to be written in the current write cycle.
+  size_t write_bytes_remaining_;
+
+  // The max_write_size will be decided dynamically based on the available
+  // bandwidth on the wire. We aim to keep the time spent in the write loop to
+  // about 100ms.
+  void SetMaxWriteSize(const size_t max_write_size) {
+    GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport SetMaxWriteSize "
+                           << " max_write_size changed: " << max_write_size_
+                           << " -> " << max_write_size;
+    max_write_size_ = max_write_size;
+  }
+
+  size_t GetMaxWriteSize() const { return max_write_size_; }
+
+  auto SerializeAndWrite(std::vector<Http2Frame>&& frames);
+  // Tracks the max allowed stream id. Currently this is only set on receiving a
+  // graceful GOAWAY frame.
+  uint32_t max_allowed_stream_id_ = RFC9113::kMaxStreamId31Bit;
+
+  uint32_t GetMaxAllowedStreamId() const;
 
-  uint32_t max_header_list_size_soft_limit_;
+  void SetMaxAllowedStreamId(uint32_t max_allowed_stream_id);
+
+  bool CanCloseTransportLocked() const
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(transport_mutex_);
 
   // Ping related members
-  // TODO(akshitpatel) : [PH2][P2] : Consider removing the timeout related
-  // members.
-  // Duration between two consecutive keepalive pings
-  const Duration keepalive_time_;
-  // Duration to wait for a keepalive ping ack before triggering timeout. This
-  // only takes effect if the assigned value is less than the ping timeout.
-  const Duration keepalive_timeout_;
-  // Duration to wait for ping ack before triggering timeout
-  const Duration ping_timeout_;
-  PingManager ping_manager_;
-  std::vector<uint64_t> pending_ping_acks_;
-  KeepaliveManager keepalive_manager_;
+
+  // Duration between two consecutive keepalive pings.
+  Duration keepalive_time_;
+  bool test_only_ack_pings_;
+  std::optional<PingManager> ping_manager_;
+  std::optional<KeepaliveManager> keepalive_manager_;
 
   // Flags
   bool keepalive_permit_without_calls_;
 
   auto SendPing(absl::AnyInvocable<void()> on_initiate, bool important) {
-    return ping_manager_.RequestPing(std::move(on_initiate), important);
+    return ping_manager_->RequestPing(std::move(on_initiate), important);
   }
-  auto WaitForPingAck() { return ping_manager_.WaitForPingAck(); }
+  auto WaitForPingAck() { return ping_manager_->WaitForPingAck(); }
 
-  // Ping Helper functions
-  // Returns a promise that resolves once a ping frame is written to the
-  // endpoint.
-  auto CreateAndWritePing(bool ack, uint64_t opaque_data) {
-    Http2Frame frame = Http2PingFrame{ack, opaque_data};
-    SliceBuffer output_buf;
-    Serialize(absl::Span<Http2Frame>(&frame, 1), output_buf);
-    return endpoint_.Write(std::move(output_buf), {});
-  }
+  void MaybeGetWindowUpdateFrames(SliceBuffer& output_buf);
+
+  void ReportDisconnection(const absl::Status& status,
+                           StateWatcher::DisconnectInfo disconnect_info,
+                           const char* reason);
 
+  void ReportDisconnectionLocked(const absl::Status& status,
+                                 StateWatcher::DisconnectInfo disconnect_info,
+                                 const char* reason)
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(&transport_mutex_);
+
+  // Ping Helper functions
   Duration NextAllowedPingInterval() {
     MutexLock lock(&transport_mutex_);
-    return (!keepalive_permit_without_calls_ && stream_list_.empty())
+    return (!keepalive_permit_without_calls_ &&
+            GetActiveStreamCountLocked() == 0)
                ? Duration::Hours(2)
                : Duration::Seconds(1);
   }
 
-  auto MaybeSendPing() {
-    return ping_manager_.MaybeSendPing(NextAllowedPingInterval(),
-                                       ping_timeout_);
-  }
-
-  auto MaybeSendPingAcks() {
-    return AssertResultType<absl::Status>(If(
-        pending_ping_acks_.empty(), [] { return absl::OkStatus(); },
-        [this] {
-          std::vector<Http2Frame> frames;
-          frames.reserve(pending_ping_acks_.size());
-          for (auto& opaque_data : pending_ping_acks_) {
-            frames.emplace_back(Http2PingFrame{true, opaque_data});
-          }
-          pending_ping_acks_.clear();
-          SliceBuffer output_buf;
-          Serialize(absl::Span<Http2Frame>(frames), output_buf);
-          return endpoint_.Write(std::move(output_buf), {});
-        }));
-  }
-
   auto AckPing(uint64_t opaque_data) {
     bool valid_ping_ack_received = true;
 
-    if (!ping_manager_.AckPing(opaque_data)) {
+    if (!ping_manager_->AckPing(opaque_data)) {
       GRPC_HTTP2_CLIENT_DLOG << "Unknown ping response received for ping id="
                              << opaque_data;
       valid_ping_ack_received = false;
@@ -578,13 +540,10 @@ class Http2ClientTransport final : public ClientTransport {
         // When this happens, it becomes important to ensure that if a ping ack
         // is received and there is an "important" outstanding ping request, we
         // should retry to send it out now.
-        valid_ping_ack_received && ping_manager_.ImportantPingRequested(),
+        valid_ping_ack_received && ping_manager_->ImportantPingRequested(),
         [self = RefAsSubclass<Http2ClientTransport>()] {
           return Map(self->TriggerWriteCycle(), [](const absl::Status status) {
-            return (status.ok())
-                       ? Http2Status::Ok()
-                       : Http2Status::AbslConnectionError(
-                             status.code(), std::string(status.message()));
+            return ToHttpOkOrConnError(status);
           });
         },
         [] { return Immediate(Http2Status::Ok()); });
@@ -598,29 +557,22 @@ class Http2ClientTransport final : public ClientTransport {
           PingSystemInterfaceImpl(transport));
     }
 
-    // Returns a promise that resolves once a ping frame is written to the
-    // endpoint.
-    Promise<absl::Status> SendPing(SendPingArgs args) override {
-      return transport_->CreateAndWritePing(args.ack, args.opaque_data);
-    }
-
     Promise<absl::Status> TriggerWrite() override {
       return transport_->TriggerWriteCycle();
     }
 
     Promise<absl::Status> PingTimeout() override {
-      // TODO(akshitpatel) : [PH2][P2] : Trigger goaway here.
-      // Returns a promise that resolves once goaway is sent.
-      LOG(INFO) << "Ping timeout at time: " << Timestamp::Now();
+      GRPC_HTTP2_CLIENT_DLOG << "Ping timeout at time: " << Timestamp::Now();
 
       // TODO(akshitpatel) : [PH2][P2] : The error code here has been chosen
       // based on CHTTP2's usage of GRPC_STATUS_UNAVAILABLE (which corresponds
       // to kRefusedStream). However looking at RFC9113, definition of
       // kRefusedStream doesn't seem to fit this case. We should revisit this
       // and update the error code.
-      return Immediate(
-          transport_->HandleError(Http2Status::Http2ConnectionError(
-              Http2ErrorCode::kRefusedStream, "Ping timeout")));
+      return Immediate(transport_->HandleError(
+          std::nullopt,
+          Http2Status::Http2ConnectionError(Http2ErrorCode::kRefusedStream,
+                                            GRPC_CHTTP2_PING_TIMEOUT_STR)));
     }
 
    private:
@@ -650,17 +602,17 @@ class Http2ClientTransport final : public ClientTransport {
       });
     }
     Promise<absl::Status> OnKeepAliveTimeout() override {
-      // TODO(akshitpatel) : [PH2][P2] : Trigger goaway here.
-      LOG(INFO) << "Keepalive timeout triggered";
+      GRPC_HTTP2_CLIENT_DLOG << "Keepalive timeout triggered";
 
       // TODO(akshitpatel) : [PH2][P2] : The error code here has been chosen
       // based on CHTTP2's usage of GRPC_STATUS_UNAVAILABLE (which corresponds
       // to kRefusedStream). However looking at RFC9113, definition of
       // kRefusedStream doesn't seem to fit this case. We should revisit this
       // and update the error code.
-      return Immediate(
-          transport_->HandleError(Http2Status::Http2ConnectionError(
-              Http2ErrorCode::kRefusedStream, "Keepalive timeout")));
+      return Immediate(transport_->HandleError(
+          std::nullopt, Http2Status::Http2ConnectionError(
+                            Http2ErrorCode::kRefusedStream,
+                            GRPC_CHTTP2_KEEPALIVE_TIMEOUT_STR)));
     }
 
     bool NeedToSendKeepAlivePing() override {
@@ -668,7 +620,7 @@ class Http2ClientTransport final : public ClientTransport {
       {
         MutexLock lock(&transport_->transport_mutex_);
         need_to_send_ping = (transport_->keepalive_permit_without_calls_ ||
-                             !transport_->stream_list_.empty());
+                             transport_->GetActiveStreamCountLocked() > 0);
       }
       return need_to_send_ping;
     }
@@ -680,24 +632,83 @@ class Http2ClientTransport final : public ClientTransport {
     Http2ClientTransport* transport_;
   };
 
-  WritableStreams writable_stream_list_;
+  class GoawayInterfaceImpl : public GoawayInterface {
+   public:
+    static std::unique_ptr<GoawayInterface> Make(
+        Http2ClientTransport* transport) {
+      return std::make_unique<GoawayInterfaceImpl>(
+          GoawayInterfaceImpl(transport));
+    }
+
+    Promise<absl::Status> SendPingAndWaitForAck() override {
+      return transport_->ping_manager_->RequestPing(/*on_initiate=*/[] {},
+                                                    /*important=*/true);
+    }
+
+    void TriggerWriteCycle() override { transport_->TriggerWriteCycle(); }
+
+    uint32_t GetLastAcceptedStreamId() override {
+      GRPC_DCHECK(false)
+          << "GetLastAcceptedStreamId is not implemented for client transport.";
+      LOG(ERROR) << "GetLastAcceptedStreamId is not implemented for client "
+                    "transport.";
+      return 0;
+    }
+
+   private:
+    explicit GoawayInterfaceImpl(Http2ClientTransport* transport)
+        : transport_(transport) {}
+
+    Http2ClientTransport* transport_;
+  };
+
+  GoawayManager goaway_manager_;
+
+  WritableStreams<RefCountedPtr<Stream>> writable_stream_list_;
 
-  auto MaybeAddStreamToWritableStreamList(const uint32_t stream_id,
-                                          const bool became_writable) {
-    if (became_writable) {
+  absl::Status MaybeAddStreamToWritableStreamList(
+      const RefCountedPtr<Stream> stream,
+      const StreamDataQueue<ClientMetadataHandle>::StreamWritabilityUpdate
+          result) {
+    if (result.became_writable) {
       GRPC_HTTP2_CLIENT_DLOG
           << "Http2ClientTransport MaybeAddStreamToWritableStreamList "
              " Stream id: "
-          << stream_id << " became writable";
-      absl::Status status = writable_stream_list_.Enqueue(
-          stream_id, WritableStreams::StreamPriority::kDefault);
+          << stream->GetStreamId() << " became writable";
+      absl::Status status =
+          writable_stream_list_.Enqueue(stream, result.priority);
       if (!status.ok()) {
-        return HandleError(Http2Status::Http2ConnectionError(
-            Http2ErrorCode::kProtocolError, "Failed to enqueue stream"));
+        return HandleError(
+            std::nullopt,
+            Http2Status::Http2ConnectionError(
+                Http2ErrorCode::kRefusedStream,
+                "Failed to enqueue stream to writable stream list"));
       }
     }
     return absl::OkStatus();
   }
+  bool SetOnDone(CallHandler call_handler, RefCountedPtr<Stream> stream);
+  absl::StatusOr<std::vector<Http2Frame>> DequeueStreamFrames(
+      RefCountedPtr<Stream> stream);
+
+  /// Based on channel args, preferred_rx_crypto_frame_sizes are advertised to
+  /// the peer
+  bool enable_preferred_rx_crypto_frame_advertisement_;
+  MemoryOwner memory_owner_;
+  chttp2::TransportFlowControl flow_control_;
+  std::shared_ptr<PromiseHttp2ZTraceCollector> ztrace_collector_;
+  absl::flat_hash_set<uint32_t> window_update_list_;
+
+  // TODO(tjagtap) [PH2][P2][BDP] Remove this when the BDP code is done.
+  Waker periodic_updates_waker_;
+
+  Http2ReadContext reader_state_;
+  Http2Status ParseAndDiscardHeaders(SliceBuffer&& buffer, bool is_end_headers,
+                                     RefCountedPtr<Stream> stream,
+                                     Http2Status&& original_status,
+                                     DebugLocation whence = {});
+  void ReadChannelArgs(const ChannelArgs& channel_args,
+                       TransportChannelArgs& args);
 };
 
 // Since the corresponding class in CHTTP2 is about 3.9KB, our goal is to