grpc 1.78.0 → 1.80.0.pre1

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

@@ -17,15 +17,245 @@
 #ifndef GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_SECURITY_FRAME_H
 #define GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_SECURITY_FRAME_H
 
-#include <grpc/slice.h>
-#include <stdint.h>
+#include <grpc/event_engine/event_engine.h>
+#include <grpc/support/port_platform.h>
 
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <utility>
+
+#include "src/core/ext/transport/chttp2/transport/frame.h"
+#include "src/core/ext/transport/chttp2/transport/write_cycle.h"
+#include "src/core/lib/debug/trace.h"
+#include "src/core/lib/event_engine/query_extensions.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/slice/slice_buffer.h"
 #include "src/core/lib/transport/transport_framing_endpoint_extension.h"
+#include "src/core/util/grpc_check.h"
+#include "src/core/util/ref_counted.h"
+#include "src/core/util/sync.h"
+#include "absl/base/thread_annotations.h"
+#include "absl/log/log.h"
+#include "absl/strings/str_format.h"
 
 namespace grpc_core {
 
-// TODO(tjagtap) [PH2][P1] Implement
+#define GRPC_HTTP2_SECURITY_FRAME_DLOG \
+  DLOG_IF(INFO, GRPC_TRACE_FLAG_ENABLED(http2_ph2_transport))
+
+// Manages sending and receiving HTTP2 security frames (type 0x08).
+// It bridges HTTP2 Transport and TransportFramingEndpointExtension.
+class SecurityFrameHandler final : public RefCounted<SecurityFrameHandler> {
+ public:
+  SecurityFrameHandler() = default;
+  ~SecurityFrameHandler() override {
+    GRPC_HTTP2_SECURITY_FRAME_DLOG << "SecurityFrameHandler::Destructor";
+  };
+  SecurityFrameHandler(const SecurityFrameHandler&) = delete;
+  SecurityFrameHandler& operator=(const SecurityFrameHandler&) = delete;
+  SecurityFrameHandler(SecurityFrameHandler&&) = delete;
+  SecurityFrameHandler& operator=(SecurityFrameHandler&&) = delete;
+
+  ///////////////////////////////////////////////////////////////////////////////
+  // Initialization
+
+  // SendFrameCallbackFactory is called from the Transport Party.
+  // But the callback that it returns is run on some other thread.
+  auto SendFrameCallbackFactory(
+      std::shared_ptr<grpc_event_engine::experimental::EventEngine>
+          event_engine) {
+    return [self = this->Ref(), event_engine](SliceBuffer* data) {
+      event_engine->Run([self, data = std::move(*data)]() mutable {
+        GRPC_HTTP2_SECURITY_FRAME_DLOG << "SecurityFrameHandler::Callback";
+        bool call_wakeup = false;
+        {
+          MutexLock lock(&self->mutex_);
+          // In the rare possibility that we receive 2 quick callbacks in
+          // succession before the transport is able to read the payload_
+          // then we will apply the latest key and discard the old key.
+          self->payload_.Clear();
+          if (!self->transport_closed_) {
+            self->payload_.Swap(&data);
+            call_wakeup = true;
+          }
+        }
+        if (call_wakeup) {
+          GRPC_HTTP2_SECURITY_FRAME_DLOG
+              << "SecurityFrameHandler::Callback Wakeup";
+          self->waker_.Wakeup();
+        }
+      });
+    };
+  }
+
+  struct EndpointExtensionState {
+    bool is_set = false;
+  };
+
+  // Only run on the Transport Party
+  GRPC_MUST_USE_RESULT EndpointExtensionState Initialize(
+      std::shared_ptr<grpc_event_engine::experimental::EventEngine>
+          event_engine) {
+    GRPC_HTTP2_SECURITY_FRAME_DLOG << "SecurityFrameHandler::Initialize";
+    endpoint_extension_ = grpc_event_engine::experimental::QueryExtension<
+        TransportFramingEndpointExtension>(event_engine.get());
+    if (endpoint_extension_ != nullptr) {
+      endpoint_extension_->SetSendFrameCallback(
+          SendFrameCallbackFactory(event_engine));
+      return EndpointExtensionState{true};
+    }
+    LOG(ERROR) << "SecurityFrameHandler::Initialize could not initialize "
+                  "TransportFramingEndpointExtension";
+    return EndpointExtensionState{false};
+  }
+
+  ///////////////////////////////////////////////////////////////////////////////
+  // When a Security Frame is received by the Transport
+
+  // Only run on the Transport Party
+  void ProcessPayload(SliceBuffer&& payload) {
+    GRPC_HTTP2_SECURITY_FRAME_DLOG << "SecurityFrameHandler::ProcessPayload";
+    if (endpoint_extension_ != nullptr) {
+      MutexLock lock(&mutex_);
+      if (!transport_closed_) {
+        endpoint_extension_->ReceiveFrame(std::move(payload));
+      }
+    }
+  }
+
+  //////////////////////////////////////////////////////////////////////////////
+  // When a Security Frame needs to be sent by the Transport
+
+  enum class SleepState : uint8_t {
+    kWaitingForFrame,  // Sleep until we have a security frame to send
+    kWriteOneFrame,
+    kScheduledWrite,
+    kTransportClosed,
+  };
+
+  // Only run on the Transport Party - From SecurityFrameLoop Promise
+  auto WaitForSecurityFrameSending() {
+    GRPC_DCHECK(endpoint_extension_ != nullptr);
+    return [self = this->Ref()]() -> Poll<Empty> {
+      GRPC_HTTP2_SECURITY_FRAME_DLOG
+          << "SecurityFrameHandler::WaitForSecurityFrameSending";
+      if (self->sleep_state_ == SleepState::kTransportClosed) {
+        return Empty{};
+      } else if (self->sleep_state_ == SleepState::kWaitingForFrame) {
+        MutexLock lock(&self->mutex_);
+        if (self->payload_.Length() > 0) {
+          self->sleep_state_ = SleepState::kWriteOneFrame;
+          return Empty{};
+        }
+      }
+      GRPC_HTTP2_SECURITY_FRAME_DLOG
+          << "SecurityFrameHandler::WaitForSecurityFrameSending Add Waker";
+      self->waker_ = GetContext<Activity>()->MakeNonOwningWaker();
+      return Pending{};
+    };
+  }
+
+  struct TerminateSecurityFrameLoop {
+    bool terminate = false;
+  };
+
+  // Only run on the Transport Party - From SecurityFrameLoop Promise
+  TerminateSecurityFrameLoop TriggerWriteSecurityFrame() {
+    GRPC_HTTP2_SECURITY_FRAME_DLOG
+        << "SecurityFrameHandler::TriggerWriteSecurityFrame";
+    GRPC_DCHECK(endpoint_extension_ != nullptr);
+    GRPC_DCHECK(sleep_state_ == SleepState::kWriteOneFrame ||
+                sleep_state_ == SleepState::kTransportClosed);
+    if (sleep_state_ == SleepState::kWriteOneFrame) {
+      sleep_state_ = SleepState::kScheduledWrite;
+    }
+    return TerminateSecurityFrameLoop{
+        (sleep_state_ == SleepState::kTransportClosed)};
+  }
+
+  // TODO(tjagtap) [PH2][P5] Simplify WaitForSecurityFrameSending and
+  // TriggerWriteSecurityFrame by merging the two.
+
+  // Only run on the Transport Party - From MultiplexerLoop Promise
+  void MaybeAppendSecurityFrame(http2::FrameSender& frame_sender) {
+    GRPC_DCHECK(sleep_state_ != SleepState::kWriteOneFrame);
+    if (sleep_state_ == SleepState::kScheduledWrite &&
+        endpoint_extension_ != nullptr) {
+      Http2Frame frame = Http2SecurityFrame();
+      {
+        MutexLock lock(&mutex_);
+        GRPC_DCHECK(payload_.Length() != 0);
+        GRPC_HTTP2_SECURITY_FRAME_DLOG
+            << "SecurityFrameHandler::MaybeAppendSecurityFrame Write Frame "
+               "Length "
+            << payload_.Length();
+        std::get<Http2SecurityFrame>(frame).payload.Swap(&payload_);
+        GRPC_DCHECK(payload_.Length() == 0);
+      }
+      frame_sender.AddRegularFrame(std::move(frame));
+      sleep_state_ = SleepState::kWaitingForFrame;
+    }
+  }
+
+  //////////////////////////////////////////////////////////////////////////////
+  // Cleanup
+
+  // Only run on the Transport Party
+  void OnTransportClosed() {
+    GRPC_HTTP2_SECURITY_FRAME_DLOG << "SecurityFrameHandler::OnTransportClosed";
+    MutexLock lock(&mutex_);
+    transport_closed_ = true;
+    sleep_state_ = SleepState::kTransportClosed;
+    payload_.Clear();
+    waker_.Wakeup();  // To terminate the SecurityFrameLoop
+  }
+
+  SleepState TestOnlySleepState() { return sleep_state_; }
+
+  std::string TestOnlyDebugString() {
+    std::string sleep_state_str;
+    switch (sleep_state_) {
+      case SleepState::kWaitingForFrame:
+        sleep_state_str = "kWaitingForFrame";
+        break;
+      case SleepState::kWriteOneFrame:
+        sleep_state_str = "kWriteOneFrame";
+        break;
+      case SleepState::kScheduledWrite:
+        sleep_state_str = "kScheduledWrite";
+        break;
+      case SleepState::kTransportClosed:
+        sleep_state_str = "kTransportClosed";
+        break;
+    }
+    MutexLock lock(&mutex_);
+    // Do not ever LOG the payload. It has a security key.
+    return absl::StrFormat(
+        "SecurityFrameHandler{endpoint_extension_=%s, sleep_state_=%s, "
+        "payload_length=%d, transport_closed_=%s}",
+        endpoint_extension_ == nullptr ? "null" : "non-null", sleep_state_str,
+        payload_.Length(), transport_closed_ ? "true" : "false");
+  }
+
+ private:
+  // Only access endpoint_extension_ from the transport party
+  TransportFramingEndpointExtension* endpoint_extension_ = nullptr;
+
+  // Initialized on the transport party and woken up by some other thread.
+  Waker waker_;
+
+  Mutex mutex_;
+  // Written/Cleared by the other thread, Read and Cleared by transport party.
+  SliceBuffer payload_ ABSL_GUARDED_BY(mutex_);
+  // Written by transport party, read by both threads.
+  bool transport_closed_ ABSL_GUARDED_BY(mutex_) = false;
+
+  // Only access sleep_state_ from the transport party
+  SleepState sleep_state_ = SleepState::kWaitingForFrame;
+};
 
 }  // namespace grpc_core
 

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

@@ -21,10 +21,11 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <atomic>
 #include <cstdint>
-#include <limits>
 #include <string>
 #include <utility>
+#include <variant>
 
 #include "src/core/call/call_spine.h"
 #include "src/core/call/message.h"
@@ -36,6 +37,7 @@
 #include "src/core/ext/transport/chttp2/transport/http2_status.h"
 #include "src/core/ext/transport/chttp2/transport/message_assembler.h"
 #include "src/core/ext/transport/chttp2/transport/stream_data_queue.h"
+#include "src/core/ext/transport/chttp2/transport/write_cycle.h"
 #include "src/core/util/grpc_check.h"
 #include "src/core/util/ref_counted.h"
 #include "src/core/util/ref_counted_ptr.h"
@@ -60,20 +62,42 @@ enum class HttpStreamState : uint8_t {
 };
 
 // Managing the streams
-struct Stream : public RefCounted<Stream> {
-  explicit Stream(CallHandler call,
+class Stream : public RefCounted<Stream> {
+ public:
+  explicit Stream(CallHandler call_handler,
                   chttp2::TransportFlowControl& transport_flow_control)
-      : call(std::move(call)),
-        is_write_closed(false),
-        stream_state(HttpStreamState::kIdle),
-        stream_id(kInvalidStreamId),
-        did_receive_initial_metadata(false),
-        did_receive_trailing_metadata(false),
-        did_push_server_trailing_metadata(false),
-        data_queue(MakeRefCounted<StreamDataQueue<ClientMetadataHandle>>(
-            /*is_client*/ true,
-            /*queue_size*/ kStreamQueueSize)),
-        flow_control(&transport_flow_control) {}
+      : header_assembler_(/*is_client*/ true),
+        flow_control_(&transport_flow_control),
+        call_(std::move(call_handler)),
+        is_write_closed_(false),
+        stream_id_(kInvalidStreamId),
+        stream_state_(HttpStreamState::kIdle),
+        did_receive_initial_metadata_(false),
+        did_receive_trailing_metadata_(false),
+        did_push_server_trailing_metadata_(false),
+        data_queue_(MakeRefCounted<StreamDataQueue<ClientMetadataHandle>>(
+            std::get<CallHandler>(call_).arena(), /*is_client*/ true,
+            /*queue_size*/ kStreamQueueSize)) {}
+
+  explicit Stream(CallInitiator call_initiator,
+                  chttp2::TransportFlowControl& transport_flow_control)
+      : header_assembler_(/*is_client*/ false),
+        flow_control_(&transport_flow_control),
+        call_(std::move(call_initiator)),
+        is_write_closed_(false),
+        stream_id_(kInvalidStreamId),
+        stream_state_(HttpStreamState::kIdle),
+        did_receive_initial_metadata_(false),
+        did_receive_trailing_metadata_(false),
+        did_push_server_trailing_metadata_(false),
+        data_queue_(MakeRefCounted<StreamDataQueue<ClientMetadataHandle>>(
+            std::get<CallInitiator>(call_).arena(), /*is_client*/ false,
+            /*queue_size*/ kStreamQueueSize)) {}
+
+  Stream(const Stream&) = delete;
+  Stream(Stream&&) = delete;
+  Stream& operator=(const Stream&) = delete;
+  Stream& operator=(Stream&&) = delete;
 
   // TODO(akshitpatel) : [PH2][P4] : SetStreamId can be avoided if we pass the
   // stream id as a parameter to the dequeue function. The only downside here
@@ -84,13 +108,13 @@ struct Stream : public RefCounted<Stream> {
                         const bool allow_true_binary_metadata_peer,
                         const bool allow_true_binary_metadata_acked) {
     GRPC_DCHECK_NE(stream_id, 0u);
-    GRPC_DCHECK_EQ(this->stream_id, 0u);
+    GRPC_DCHECK_EQ(this->stream_id_, 0u);
     GRPC_HTTP2_STREAM_LOG << "Stream::InitializeStream stream_id=" << stream_id;
-    if (GPR_LIKELY(this->stream_id == 0)) {
-      this->stream_id = stream_id;
-      header_assembler.InitializeStream(stream_id,
-                                        allow_true_binary_metadata_acked);
-      data_queue->SetStreamId(stream_id, allow_true_binary_metadata_peer);
+    if (GPR_LIKELY(this->stream_id_ == 0)) {
+      this->stream_id_ = stream_id;
+      header_assembler_.InitializeStream(stream_id,
+                                         allow_true_binary_metadata_acked);
+      data_queue_->SetStreamId(stream_id, allow_true_binary_metadata_peer);
     }
   }
 
@@ -100,12 +124,12 @@ struct Stream : public RefCounted<Stream> {
 
   auto EnqueueInitialMetadata(ClientMetadataHandle&& metadata) {
     GRPC_HTTP2_STREAM_LOG << "Stream::EnqueueInitialMetadata";
-    return data_queue->EnqueueInitialMetadata(std::move(metadata));
+    return data_queue_->EnqueueInitialMetadata(std::move(metadata));
   }
 
   auto EnqueueTrailingMetadata(ClientMetadataHandle&& metadata) {
     GRPC_HTTP2_STREAM_LOG << "Stream::EnqueueTrailingMetadata";
-    return data_queue->EnqueueTrailingMetadata(std::move(metadata));
+    return data_queue_->EnqueueTrailingMetadata(std::move(metadata));
   }
 
   auto EnqueueMessage(MessageHandle&& message) {
@@ -113,36 +137,37 @@ struct Stream : public RefCounted<Stream> {
                           << " with payload size = "
                           << message->payload()->Length()
                           << " and flags = " << message->flags();
-    return data_queue->EnqueueMessage(std::move(message));
+    return data_queue_->EnqueueMessage(std::move(message));
   }
 
   auto EnqueueHalfClosed() {
     GRPC_HTTP2_STREAM_LOG << "Stream::EnqueueHalfClosed";
-    return data_queue->EnqueueHalfClosed();
+    return data_queue_->EnqueueHalfClosed();
   }
 
   auto EnqueueResetStream(const uint32_t error_code) {
     GRPC_HTTP2_STREAM_LOG << "Stream::EnqueueResetStream"
                           << " with error_code = " << error_code;
-    return data_queue->EnqueueResetStream(error_code);
+    return data_queue_->EnqueueResetStream(error_code);
   }
 
   // Called from the transport party
   auto DequeueFrames(const uint32_t tokens,
                      const uint32_t stream_flow_control_tokens,
-                     const uint32_t max_frame_length,
-                     HPackCompressor& encoder) {
-    HttpStreamState state = stream_state;
+                     const uint32_t max_frame_length, HPackCompressor& encoder,
+                     FrameSender& frame_sender) {
+    HttpStreamState state = stream_state_;
     // Reset stream MUST not be sent if the stream is idle or closed.
-    return data_queue->DequeueFrames(tokens, max_frame_length,
-                                     stream_flow_control_tokens, encoder,
-                                     /*can_send_reset_stream=*/
-                                     !(state == HttpStreamState::kIdle ||
-                                       state == HttpStreamState::kClosed));
+    return data_queue_->DequeueFrames(tokens, max_frame_length,
+                                      stream_flow_control_tokens, encoder,
+                                      frame_sender,
+                                      /*can_send_reset_stream=*/
+                                      !(state == HttpStreamState::kIdle ||
+                                        state == HttpStreamState::kClosed));
   }
 
   auto ReceivedFlowControlWindowUpdate(const uint32_t stream_fc_tokens) {
-    return data_queue->ReceivedFlowControlWindowUpdate(stream_fc_tokens);
+    return data_queue_->ReceivedFlowControlWindowUpdate(stream_fc_tokens);
   }
 
   ////////////////////////////////////////////////////////////////////////////
@@ -156,78 +181,90 @@ struct Stream : public RefCounted<Stream> {
   // kHalfClosedLocal/kHalfClosedRemote -> kClosed
   // kClosed -> kClosed
   void SentInitialMetadata() {
-    GRPC_DCHECK(stream_state == HttpStreamState::kIdle);
-    stream_state = HttpStreamState::kOpen;
+    GRPC_DCHECK(stream_state_ == HttpStreamState::kIdle);
+    stream_state_ = HttpStreamState::kOpen;
   }
 
   void MarkHalfClosedLocal() {
-    switch (stream_state) {
+    switch (stream_state_) {
       case HttpStreamState::kIdle:
         GRPC_DCHECK(false) << "MarkHalfClosedLocal called for an idle stream";
         break;
       case HttpStreamState::kOpen:
         GRPC_HTTP2_STREAM_LOG
-            << "Stream::MarkHalfClosedLocal stream_id=" << stream_id
+            << "Stream::MarkHalfClosedLocal stream_id=" << stream_id_
             << " transitioning to kHalfClosedLocal";
-        stream_state = HttpStreamState::kHalfClosedLocal;
+        stream_state_ = HttpStreamState::kHalfClosedLocal;
         break;
       case HttpStreamState::kHalfClosedRemote:
         GRPC_HTTP2_STREAM_LOG
-            << "Stream::MarkHalfClosedLocal stream_id=" << stream_id
+            << "Stream::MarkHalfClosedLocal stream_id=" << stream_id_
             << " transitioning to kClosed";
-        stream_state = HttpStreamState::kClosed;
+        stream_state_ = HttpStreamState::kClosed;
         break;
       case HttpStreamState::kHalfClosedLocal:
         break;
       case HttpStreamState::kClosed:
         GRPC_HTTP2_STREAM_LOG
-            << "Stream::MarkHalfClosedLocal stream_id=" << stream_id
+            << "Stream::MarkHalfClosedLocal stream_id=" << stream_id_
             << " already closed";
         break;
     }
   }
 
   void MarkHalfClosedRemote() {
-    switch (stream_state) {
+    switch (stream_state_) {
       case HttpStreamState::kIdle:
         GRPC_DCHECK(false) << "MarkHalfClosedRemote called for an idle stream";
         break;
       case HttpStreamState::kOpen:
         GRPC_HTTP2_STREAM_LOG
-            << "Stream::MarkHalfClosedRemote stream_id=" << stream_id
+            << "Stream::MarkHalfClosedRemote stream_id=" << stream_id_
             << " transitioning to kHalfClosedRemote";
-        stream_state = HttpStreamState::kHalfClosedRemote;
+        stream_state_ = HttpStreamState::kHalfClosedRemote;
         break;
       case HttpStreamState::kHalfClosedLocal:
         GRPC_HTTP2_STREAM_LOG
-            << "Stream::MarkHalfClosedRemote stream_id=" << stream_id
+            << "Stream::MarkHalfClosedRemote stream_id=" << stream_id_
             << " transitioning to kClosed";
-        stream_state = HttpStreamState::kClosed;
+        stream_state_ = HttpStreamState::kClosed;
         break;
       case HttpStreamState::kHalfClosedRemote:
         break;
       case HttpStreamState::kClosed:
         GRPC_HTTP2_STREAM_LOG
-            << "Stream::MarkHalfClosedRemote stream_id=" << stream_id
+            << "Stream::MarkHalfClosedRemote stream_id=" << stream_id_
             << " already closed";
         break;
     }
   }
 
   inline bool IsStreamIdle() const {
-    return stream_state == HttpStreamState::kIdle;
+    return stream_state_ == HttpStreamState::kIdle;
   }
   inline bool IsStreamHalfClosedRemote() const {
-    return stream_state == HttpStreamState::kHalfClosedRemote;
+    return stream_state_ == HttpStreamState::kHalfClosedRemote;
+  }
+  inline bool IsHalfClosedLocal() const {
+    return stream_state_ == HttpStreamState::kHalfClosedLocal;
   }
-  inline uint32_t GetStreamId() const { return stream_id; }
+  inline bool IsStreamClosed() const {
+    return stream_state_ == HttpStreamState::kClosed;
+  }
+
+  inline uint32_t GetStreamId() const { return stream_id_; }
 
-  inline bool IsClosedForWrites() const { return is_write_closed; }
-  inline void SetWriteClosed() { is_write_closed = true; }
+  inline bool IsClosedForWrites() const {
+    return is_write_closed_.load(std::memory_order_relaxed);
+  }
+
+  inline void SetWriteClosed() {
+    is_write_closed_.store(true, std::memory_order_relaxed);
+  }
 
   inline bool CanSendWindowUpdateFrames() const {
-    return stream_state == HttpStreamState::kOpen ||
-           stream_state == HttpStreamState::kHalfClosedLocal;
+    return stream_state_ == HttpStreamState::kOpen ||
+           stream_state_ == HttpStreamState::kHalfClosedLocal;
   }
 
   inline Http2Status CanStreamReceiveDataFrames() const {
@@ -236,7 +273,7 @@ struct Stream : public RefCounted<Stream> {
           Http2ErrorCode::kStreamClosed,
           std::string(RFC9113::kHalfClosedRemoteState));
     }
-    if (!did_receive_initial_metadata || did_receive_trailing_metadata) {
+    if (!IsInitialMetadataReceived() || IsTrailingMetadataReceived()) {
       return Http2Status::Http2StreamError(
           Http2ErrorCode::kStreamClosed,
           std::string(GrpcErrors::kOutOfOrderDataFrame));
@@ -245,20 +282,64 @@ struct Stream : public RefCounted<Stream> {
   }
 
   void MaybePushServerTrailingMetadata(ServerMetadataHandle&& metadata) {
+    GRPC_DCHECK(std::holds_alternative<CallHandler>(call_));
     GRPC_HTTP2_STREAM_LOG << "Stream::MaybePushServerTrailingMetadata "
                              "stream_id="
-                          << stream_id
+                          << stream_id_
                           << " metadata=" << metadata->DebugString()
                           << " did_push_server_trailing_metadata="
-                          << did_push_server_trailing_metadata;
+                          << did_push_server_trailing_metadata_;
 
-    if (!did_push_server_trailing_metadata) {
-      did_push_server_trailing_metadata = true;
-      call.SpawnPushServerTrailingMetadata(std::move(metadata));
+    if (!did_push_server_trailing_metadata_) {
+      did_push_server_trailing_metadata_ = true;
+      GetCallHandler().SpawnPushServerTrailingMetadata(std::move(metadata));
     }
   }
 
-  CallHandler call;
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION bool IsInitialMetadataReceived() const {
+    return did_receive_initial_metadata_;
+  }
+
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION void SetInitialMetadataReceived() {
+    did_receive_initial_metadata_ = true;
+  }
+
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION bool IsTrailingMetadataReceived() const {
+    return did_receive_trailing_metadata_;
+  }
+
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION void SetTrailingMetadataReceived() {
+    did_receive_trailing_metadata_ = true;
+  }
+
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION CallHandler& GetCallHandler() {
+    return std::get<CallHandler>(call_);
+  }
+
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION CallInitiator& GetCallInitiator() {
+    return std::get<CallInitiator>(call_);
+  }
+
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION GrpcMessageAssembler&
+  GetGrpcMessageAssembler() {
+    return assembler_;
+  }
+
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION HeaderAssembler& GetHeaderAssembler() {
+    return header_assembler_;
+  }
+
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION chttp2::StreamFlowControl&
+  GetStreamFlowControl() {
+    return flow_control_;
+  }
+
+ private:
+  GrpcMessageAssembler assembler_;
+  HeaderAssembler header_assembler_;
+  chttp2::StreamFlowControl flow_control_;
+  std::variant<CallInitiator, CallHandler> call_;
+
   // This flag is kept separate from the stream_state as the stream_state
   // is inline with the HTTP2 spec, whereas this flag is an implementation
   // detail of the PH2 transport. As far as PH2 is concerned, if a stream is
@@ -266,19 +347,17 @@ struct Stream : public RefCounted<Stream> {
   // Similarly if a stream is closed for reads(this is achieved by removing the
   // stream from the transport map), then all the frames read on that stream
   // will be dropped.
-  bool is_write_closed;
+  std::atomic<bool> is_write_closed_;
+  uint32_t stream_id_;
+
   // This MUST be accessed from the transport party.
-  HttpStreamState stream_state;
-  uint32_t stream_id;
-  GrpcMessageAssembler assembler;
-  HeaderAssembler header_assembler;
-  bool did_receive_initial_metadata;
-  bool did_receive_trailing_metadata;
-  bool did_push_server_trailing_metadata;
-  // TODO(akshitpatel) : [PH2][P3][Server] : This would need to change to
+  HttpStreamState stream_state_;
+  bool did_receive_initial_metadata_;
+  bool did_receive_trailing_metadata_;
+  bool did_push_server_trailing_metadata_;
+  // TODO(akshitpatel) : [PH2][P0][Server] : This would need to change to
   // accomodate ServerMetadataHandle for the server side.
-  RefCountedPtr<StreamDataQueue<ClientMetadataHandle>> data_queue;
-  chttp2::StreamFlowControl flow_control;
+  RefCountedPtr<StreamDataQueue<ClientMetadataHandle>> data_queue_;
 };
 
 }  // namespace http2