grpc 1.80.0 → 1.81.0

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

@@ -266,7 +266,14 @@ class SettingsPromiseManager final : public RefCounted<SettingsPromiseManager> {
   // ChannelZ and Security Frame Stuff
 
   channelz::PropertyGrid ChannelzProperties() const {
-    return settings_.ChannelzProperties();
+    return settings_.ChannelzProperties().SetColumn(
+        "Counters",
+        channelz::PropertyList().Set("initial_window_size_increase_count",
+                                     initial_window_size_increase_count_));
+  }
+
+  void IncrementInitialWindowSizeIncreaseCount() {
+    ++initial_window_size_increase_count_;
   }
 
   bool IsSecurityFrameExpected() const {
@@ -422,6 +429,9 @@ class SettingsPromiseManager final : public RefCounted<SettingsPromiseManager> {
     kReady,
   };
   SettingsState state_;
+
+  // Counters
+  size_t initial_window_size_increase_count_ = 0;
 };
 
 }  // namespace grpc_core

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

@@ -433,43 +433,5 @@ void MaybeAddStreamWindowUpdateFrame(Stream& stream,
   }
 }
 
-// /////////////////////////////////////////////////////////////////////////////
-// Header and Continuation frame processing helpers
-
-Http2Status ParseAndDiscardHeaders(HPackParser& parser, SliceBuffer&& buffer,
-                                   HeaderAssembler::ParseHeaderArgs args,
-                                   Stream* stream,
-                                   Http2Status&& original_status) {
-  GRPC_HTTP2_COMMON_DLOG << "ParseAndDiscardHeaders buffer "
-                            "size: "
-                         << buffer.Length() << " args: " << args.DebugString()
-                         << " stream_id: "
-                         << (stream == nullptr ? 0 : stream->GetStreamId())
-                         << " original_status: "
-                         << original_status.DebugString();
-
-  if (stream != nullptr) {
-    // Parse all the data in the header assembler
-    Http2Status result = stream->GetHeaderAssembler().ParseAndDiscardHeaders(
-        parser, args.is_initial_metadata, args.max_header_list_size_soft_limit,
-        args.max_header_list_size_hard_limit);
-    if (!result.IsOk()) {
-      GRPC_DCHECK(result.GetType() ==
-                  Http2Status::Http2ErrorType::kConnectionError);
-      LOG(ERROR) << "Connection Error: " << result;
-      return result;
-    }
-  }
-
-  if (buffer.Length() == 0) {
-    return std::move(original_status);
-  }
-
-  Http2Status status = HeaderAssembler::ParseHeader(
-      parser, std::move(buffer), /*grpc_metadata_batch=*/nullptr, args);
-
-  return (status.IsOk()) ? std::move(original_status) : std::move(status);
-}
-
 }  // namespace http2
 }  // namespace grpc_core

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

@@ -21,6 +21,7 @@
 
 #include <cstdint>
 #include <string>
+#include <type_traits>
 
 #include "src/core/channelz/channelz.h"
 #include "src/core/ext/transport/chttp2/transport/flow_control.h"
@@ -119,6 +120,35 @@ class Http2ReadContext {
 Http2Status ValidateIncomingConnectionPreface(
     const absl::StatusOr<Slice>& status);
 
+template <typename T, typename Tracker>
+inline Http2Status ValidateMetadataFrameState(
+    T& frame, Stream& stream, Tracker& incoming_headers,
+    const uint32_t max_header_list_size) {
+  if (stream.IsStreamHalfClosedRemote()) {
+    return incoming_headers.ParseAndDiscardHeaders(
+        std::move(frame.payload), frame.end_headers, &stream,
+        Http2Status::Http2StreamError(
+            Http2ErrorCode::kStreamClosed,
+            std::string(RFC9113::kHalfClosedRemoteState)),
+        max_header_list_size);
+  }
+
+  if constexpr (std::is_same_v<std::decay_t<T>, Http2HeaderFrame>) {
+    if (incoming_headers.DidReceiveDuplicateMetadata(
+            stream.IsInitialMetadataReceived(),
+            stream.IsTrailingMetadataReceived())) {
+      return incoming_headers.ParseAndDiscardHeaders(
+          std::move(frame.payload), frame.end_headers, &stream,
+          Http2Status::Http2StreamError(
+              Http2ErrorCode::kInternalError,
+              std::string(GrpcErrors::kTooManyMetadata)),
+          max_header_list_size);
+    }
+  }
+
+  return Http2Status::Ok();
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 // Settings helpers
 
@@ -183,44 +213,7 @@ void MaybeAddTransportWindowUpdateFrame(
 
 void MaybeAddStreamWindowUpdateFrame(Stream& stream, FrameSender& frame_sender);
 
-///////////////////////////////////////////////////////////////////////////////
-// Header and Continuation frame processing helpers
-
-// This function is used to partially process a HEADER or CONTINUATION frame.
-// `PARTIAL PROCESSING` means reading the payload of a HEADER or CONTINUATION
-// and processing it with the HPACK decoder, and then discarding the payload.
-// This is done to keep the transports HPACK parser in sync with peers HPACK.
-// Scenarios where 'partial processing' is used:
 //
-// Case 1: Received a HEADER/CONTINUATION frame
-// 1. If the frame is invalid ('ParseHeaderFrame'/'ParseContinuationFrame'
-//    returns a non-OK status) then it is a connection error. In this case, we
-//    do NOT invoke 'partial processing' as the transport is about to be closed
-//    anyway.
-// 2. If ParseFramePayload returns a non-OK status, then it is a connection
-//    error. In this case, we do NOT invoke 'partial processing' as the
-//    transport is about to be closed anyway.
-// 3. If the frame is valid, but lookup stream fails, then we invoke 'partial
-//    processing' and pass the current payload through the HPACK decoder. This
-//    can happen if the stream was already closed.
-// 4. If the frame is valid, lookup stream succeeds and we fail while processing
-//    the frame (be it stream or connection error), we first parse the buffered
-//    payload (if any) in the stream through the HPACK decoder and then pass the
-//    current payload through the HPACK decoder.
-// Case 2: Stream close
-// 1. If the stream is being aborted by the upper layers or the transport hit
-//    a stream error on a stream while reading HEADER/CONTINUATION frames, we
-//    invoke 'partial processing' to parse the enqueued buffer (if any) in the
-//    stream to keep our HPACK state consistent with the peer right before
-//    closing the stream. This is done as the next time a HEADER/CONTINUATION
-//    frame is received from the peer, the stream lookup will start failing.
-// This function returns a connection error if HPACK parsing fails. Otherwise,
-// it returns the original status.
-Http2Status ParseAndDiscardHeaders(HPackParser& parser, SliceBuffer&& buffer,
-                                   HeaderAssembler::ParseHeaderArgs args,
-                                   Stream* stream,
-                                   Http2Status&& original_status);
-
 }  // namespace http2
 }  // namespace grpc_core
 

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

@@ -19,16 +19,25 @@
 #ifndef GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_INCOMING_METADATA_TRACKER_H
 #define GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_INCOMING_METADATA_TRACKER_H
 
+#include <grpc/support/port_platform.h>
+
 #include <cstdint>
 #include <string>
 #include <utility>
 
 #include "src/core/call/metadata_info.h"
-#include "src/core/ext/transport/chttp2/transport/frame.h"
+#include "src/core/ext/transport/chttp2/transport/header_assembler.h"
+#include "src/core/ext/transport/chttp2/transport/hpack_parser.h"
+#include "src/core/ext/transport/chttp2/transport/http2_status.h"
+#include "src/core/ext/transport/chttp2/transport/http2_transport.h"
+#include "src/core/ext/transport/chttp2/transport/stream.h"
 #include "src/core/lib/event_engine/tcp_socket_utils.h"
 #include "src/core/lib/slice/slice.h"
+#include "src/core/lib/slice/slice_buffer.h"
 #include "src/core/lib/transport/promise_endpoint.h"
+#include "src/core/util/debug_location.h"
 #include "src/core/util/grpc_check.h"
+#include "absl/log/log.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
 
@@ -46,8 +55,8 @@ class IncomingMetadataTracker {
   // a time. This class is distinct from HeaderAssembler, which buffers header
   // payloads on a per-stream basis.
  public:
-  explicit IncomingMetadataTracker(Slice peer_string)
-      : peer_string_(std::move(peer_string)) {}
+  explicit IncomingMetadataTracker(Slice peer_string, const bool is_client)
+      : peer_string_(std::move(peer_string)), is_client_(is_client) {}
   ~IncomingMetadataTracker() = default;
 
   IncomingMetadataTracker(IncomingMetadataTracker&& rvalue) = delete;
@@ -72,11 +81,69 @@ class IncomingMetadataTracker {
   }
   uint32_t soft_limit() const { return max_header_list_size_soft_limit_; }
 
+  HPackParser& parser() { return parser_; }
+
+  void SetMaxHeaderTableSize(const uint32_t size) {
+    parser_.hpack_table()->SetMaxBytes(size);
+  }
+
+  // This function is used to partially process a HEADER or CONTINUATION frame.
+  // `PARTIAL PROCESSING` means reading the payload of a HEADER or CONTINUATION
+  // and processing it with the HPACK decoder, and then discarding the payload.
+  // This is done to keep the transports HPACK parser in sync with peers HPACK.
+  // Scenarios where 'partial processing' is used when we receive a HEADER or
+  // CONTINUATION frames when a stream is closed, or there is a Stream Error. We
+  // do not do partial processing for Connection Errors because the Transport
+  // will be destroyed soon after.
+  Http2Status ParseAndDiscardHeaders(
+      SliceBuffer&& buffer, const bool is_end_headers, Stream* stream,
+      Http2Status&& original_status,
+      const uint32_t max_header_list_size_hard_limit) {
+    const HeaderAssembler::ParseHeaderArgs args = {
+        /*is_initial_metadata=*/!incoming_header_end_stream_,
+        /*is_end_headers=*/is_end_headers,
+        /*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=*/incoming_header_stream_id_,
+    };
+    GRPC_HTTP2_COMMON_DLOG << "ParseAndDiscardHeaders buffer "
+                              "size: "
+                           << buffer.Length() << " args: " << args.DebugString()
+                           << " stream_id: "
+                           << (stream == nullptr ? 0 : stream->GetStreamId())
+                           << " original_status: "
+                           << original_status.DebugString();
+    if (stream != nullptr) {
+      // Parse all the data in the header assembler
+      Http2Status result = stream->GetHeaderAssembler().ParseAndDiscardHeaders(
+          parser_, args.is_initial_metadata,
+          args.max_header_list_size_soft_limit,
+          args.max_header_list_size_hard_limit);
+      if (!result.IsOk()) {
+        GRPC_DCHECK(result.GetType() ==
+                    Http2Status::Http2ErrorType::kConnectionError);
+        LOG(ERROR) << "Connection Error: " << result;
+        return result;
+      }
+    }
+
+    if (buffer.Length() == 0) {
+      return std::move(original_status);
+    }
+
+    Http2Status status = HeaderAssembler::ParseHeader(
+        parser_, std::move(buffer), /*grpc_metadata_batch=*/nullptr, args);
+
+    return (status.IsOk()) ? std::move(original_status) : std::move(status);
+  }
+
   //////////////////////////////////////////////////////////////////////////////
   // Writing Header and Continuation State
 
   // Called when a HEADER frame is received.
-  void OnHeaderReceived(const Http2HeaderFrame& frame) {
+  void UpdateState(const Http2HeaderFrame& frame) {
     GRPC_CHECK(!incoming_header_in_progress_);
     incoming_header_in_progress_ = !frame.end_headers;
     incoming_header_stream_id_ = frame.stream_id;
@@ -84,7 +151,7 @@ class IncomingMetadataTracker {
   }
 
   // Called when a CONTINUATION frame is received.
-  void OnContinuationReceived(const Http2ContinuationFrame& frame) {
+  void UpdateState(const Http2ContinuationFrame& frame) {
     GRPC_CHECK(incoming_header_in_progress_);
     GRPC_CHECK_EQ(frame.stream_id, incoming_header_stream_id_);
     incoming_header_in_progress_ = !frame.end_headers;
@@ -134,12 +201,14 @@ class IncomingMetadataTracker {
   // Initialized only once at the time of transport creation.
   // Should remain constant for the lifetime of the transport.
   const Slice peer_string_;
+  const bool is_client_;
 
   bool incoming_header_in_progress_ = false;
   bool incoming_header_end_stream_ = false;
   uint32_t incoming_header_stream_id_ = 0;
   uint32_t max_header_list_size_soft_limit_ =
       DEFAULT_MAX_HEADER_LIST_SIZE_SOFT_LIMIT;
+  HPackParser parser_;
 };
 
 }  // namespace http2

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

@@ -533,6 +533,7 @@ struct grpc_chttp2_transport final : public grpc_core::FilterStackTransport,
   grpc_core::Duration keepalive_timeout;
   /// number of stream objects currently allocated by this transport
   std::atomic<size_t> streams_allocated{0};
+  uint32_t max_deallocating_streams = 0;
   /// keep-alive state machine state
   grpc_chttp2_keepalive_state keepalive_state;
   // Soft limit on max header size.

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

@@ -688,7 +688,10 @@ static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
     } else if (GPR_UNLIKELY(
                    t->max_concurrent_streams_overload_protection &&
                    t->streams_allocated.load(std::memory_order_relaxed) >
-                       t->settings.local().max_concurrent_streams())) {
+                       static_cast<uint64_t>(
+                           t->settings.local().max_concurrent_streams()) +
+                           static_cast<uint64_t>(
+                               t->max_deallocating_streams))) {
       // We have more streams allocated than we'd like, so apply some pushback
       // by refusing this stream.
       ++t->num_pending_induced_frames;

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

@@ -235,7 +235,7 @@ class SecurityFrameHandler final : public RefCounted<SecurityFrameHandler> {
     // 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}",
+        "payload_length=%zu, transport_closed_=%s}",
         endpoint_extension_ == nullptr ? "null" : "non-null", sleep_state_str,
         payload_.Length(), transport_closed_ ? "true" : "false");
   }

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

@@ -80,19 +80,25 @@ class Stream : public RefCounted<Stream> {
             /*queue_size*/ kStreamQueueSize)) {}
 
   explicit Stream(CallInitiator call_initiator,
-                  chttp2::TransportFlowControl& transport_flow_control)
+                  chttp2::TransportFlowControl& transport_flow_control,
+                  const uint32_t stream_id,
+                  const bool allow_true_binary_metadata_peer,
+                  const bool allow_true_binary_metadata_acked)
       : header_assembler_(/*is_client*/ false),
         flow_control_(&transport_flow_control),
         call_(std::move(call_initiator)),
         is_write_closed_(false),
-        stream_id_(kInvalidStreamId),
+        stream_id_(stream_id),
         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)) {}
+            /*queue_size*/ kStreamQueueSize)) {
+    InitializeStream(allow_true_binary_metadata_peer,
+                     allow_true_binary_metadata_acked);
+  }
 
   Stream(const Stream&) = delete;
   Stream(Stream&&) = delete;
@@ -104,17 +110,19 @@ class Stream : public RefCounted<Stream> {
   // is that we will be creating two new disassemblers for every dequeue call.
   // The upside is that we save 8 bytes per call. Decide based on benchmark
   // results.
-  void InitializeStream(const uint32_t stream_id,
-                        const bool allow_true_binary_metadata_peer,
-                        const bool allow_true_binary_metadata_acked) {
+  void InitializeClientStream(const uint32_t stream_id,
+                              const bool allow_true_binary_metadata_peer,
+                              const bool allow_true_binary_metadata_acked) {
+    GRPC_DCHECK(std::holds_alternative<CallHandler>(call_))
+        << "Client Only Function";
     GRPC_DCHECK_NE(stream_id, 0u);
     GRPC_DCHECK_EQ(this->stream_id_, 0u);
-    GRPC_HTTP2_STREAM_LOG << "Stream::InitializeStream stream_id=" << stream_id;
+    GRPC_HTTP2_STREAM_LOG << "Stream::InitializeClientStream 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);
+      InitializeStream(allow_true_binary_metadata_peer,
+                       allow_true_binary_metadata_acked);
     }
   }
 
@@ -166,7 +174,7 @@ class Stream : public RefCounted<Stream> {
                                         state == HttpStreamState::kClosed));
   }
 
-  auto ReceivedFlowControlWindowUpdate(const uint32_t stream_fc_tokens) {
+  auto UpdateStreamWritability(const int64_t stream_fc_tokens) {
     return data_queue_->ReceivedFlowControlWindowUpdate(stream_fc_tokens);
   }
 
@@ -335,6 +343,16 @@ class Stream : public RefCounted<Stream> {
   }
 
  private:
+  void InitializeStream(const bool allow_true_binary_metadata_peer,
+                        const bool allow_true_binary_metadata_acked) {
+    GRPC_HTTP2_STREAM_LOG << "Stream::InitializeStream stream_id="
+                          << stream_id_;
+    GRPC_DCHECK_GE(stream_id_, 0u);
+    header_assembler_.InitializeStream(stream_id_,
+                                       allow_true_binary_metadata_acked);
+    data_queue_->SetStreamId(stream_id_, allow_true_binary_metadata_peer);
+  }
+
   GrpcMessageAssembler assembler_;
   HeaderAssembler header_assembler_;
   chttp2::StreamFlowControl flow_control_;

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

@@ -28,6 +28,9 @@ namespace grpc_core {
 
 Duration TarpitDuration(const int min_tarpit_duration_ms,
                         const int max_tarpit_duration_ms) {
+  if (min_tarpit_duration_ms > max_tarpit_duration_ms) {
+    return Duration::Milliseconds(min_tarpit_duration_ms);
+  }
   return Duration::Milliseconds(absl::LogUniform<int>(
       SharedBitGen(), min_tarpit_duration_ms, max_tarpit_duration_ms));
 }

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

@@ -23,6 +23,7 @@
 #include <limits>
 #include <optional>
 #include <queue>
+#include <type_traits>
 #include <vector>
 
 #include "src/core/ext/transport/chttp2/transport/transport_common.h"
@@ -48,7 +49,7 @@ struct HasGetStreamId {
 template <typename StreamPtr>
 struct HasGetStreamId<
     StreamPtr,
-    absl::void_t<decltype(std::declval<StreamPtr>()->GetStreamId())>> {
+    std::void_t<decltype(std::declval<StreamPtr>()->GetStreamId())>> {
   static constexpr bool value =
       std::is_same_v<decltype(std::declval<StreamPtr>()->GetStreamId()),
                      uint32_t>;
@@ -118,82 +119,6 @@ class WritableStreams {
     return absl::OkStatus();
   }
 
-  // Dequeues a single stream id from the queue.
-  // Returns a promise that resolves to the next stream id or an error if the
-  // dequeue fails. High level flow:
-  // 1. Synchronous dequeue from the mpsc queue to get a batch of stream ids.
-  // 2. If the batch is non-empty, the stream ids are pushed to the prioritized
-  //    queue.
-  // 3. If the prioritized queue is non-empty, the stream with the highest
-  //    priority is popped. If there are multiple stream ids with the same
-  //    priority, the stream enqueued first is popped first.
-  // 4. If the prioritized queue is empty, the mpsc queue is queried again for
-  //    a batch of stream ids. If the mpsc queue is empty, we block until a
-  //    stream id is enqueued.
-  // 5. Once mpsc dequeue promise is resolved, the stream ids are pushed to the
-  //    prioritized queue.
-  // 6. Return the stream id with the highest priority.
-  // If this returns error, transport MUST be closed.
-  // TODO(akshitpatel) : [PH2][P2] - This will be deprecated in favor of
-  // WaitForReady.
-  auto Next(const bool transport_tokens_available) {
-    // TODO(akshitpatel) : [PH2][P2] - Need to add an immediate dequeue option
-    // for the mpsc queue in favor of the race.
-
-    return AssertResultType<absl::StatusOr<StreamPtr>>(TrySeq(
-        // The current MPSC queue does not have a version of NextBatch that
-        // resolves immediately. So we made this Race to ensure that the
-        // "Dequeue" from the mpsc resolves immediately - Either with data , or
-        // empty.
-        Race(
-            queue_.NextBatch(kMaxBatchSize),
-            Immediate(
-                ValueOrFailure<std::vector<std::optional<StreamIDAndPriority>>>(
-                    std::vector<std::optional<StreamIDAndPriority>>()))),
-        [this, transport_tokens_available](
-            std::vector<std::optional<StreamIDAndPriority>> batch) {
-          AddToPrioritizedQueue(batch);
-          std::optional<StreamPtr> stream =
-              prioritized_queue_.Pop(transport_tokens_available);
-          return If(
-              stream.has_value(),
-              [stream]() -> absl::StatusOr<StreamPtr> {
-                GRPC_WRITABLE_STREAMS_DEBUG << "Next stream id: "
-                                            << (*stream)->GetStreamId();
-                return stream.value();
-              },
-              [this, transport_tokens_available] {
-                GRPC_WRITABLE_STREAMS_DEBUG << "Query queue for next batch";
-                return Map(
-                    // PrioritizedQueue is empty at this point. Hence we block
-                    // on mpsc queue to get a new batch of stream ids.
-                    queue_.NextBatch(kMaxBatchSize),
-                    [this, transport_tokens_available](
-                        ValueOrFailure<
-                            std::vector<std::optional<StreamIDAndPriority>>>
-                            batch) -> absl::StatusOr<StreamPtr> {
-                      if (batch.ok()) {
-                        GRPC_WRITABLE_STREAMS_DEBUG << "Next batch size "
-                                                    << batch.value().size();
-                        AddToPrioritizedQueue(batch.value());
-                        std::optional<StreamPtr> stream =
-                            prioritized_queue_.Pop(transport_tokens_available);
-                        // TODO(akshitpatel) : [PH2][P4] - This GRPC_DCHECK
-                        // should ideally be fine. But in case if
-                        // queue_.NextBatch spuriously returns an empty batch,
-                        // move to a Loop to avoid this.
-                        GRPC_DCHECK(stream.has_value());
-                        GRPC_WRITABLE_STREAMS_DEBUG
-                            << "Next stream id: "
-                            << stream.value()->GetStreamId();
-                        return stream.value();
-                      }
-                      return absl::InternalError("Failed to read from queue");
-                    });
-              });
-        }));
-  }
-
   // Wait for a stream to be ready to be dequeued. This is a blocking call.
   // This returns a promise that resolves when there is a writeable stream ready
   // to be dequeued or ForceReadyForWrite() is called.