grpc 1.75.0 → 1.78.1

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

@@ -20,18 +20,24 @@
 #define GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HTTP2_TRANSPORT_H
 
 #include <cstdint>
-#include <utility>
+#include <string>
 
-#include "src/core/call/call_spine.h"
-#include "src/core/call/metadata_info.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/hpack_parser.h"
 #include "src/core/ext/transport/chttp2/transport/http2_settings.h"
-#include "src/core/lib/promise/mpsc.h"
-#include "src/core/lib/promise/party.h"
+#include "src/core/ext/transport/chttp2/transport/http2_settings_manager.h"
+#include "src/core/ext/transport/chttp2/transport/http2_settings_promises.h"
+#include "src/core/ext/transport/chttp2/transport/http2_status.h"
+#include "src/core/ext/transport/chttp2/transport/stream.h"
+#include "src/core/lib/promise/activity.h"
+#include "src/core/lib/promise/context.h"
+#include "src/core/lib/promise/poll.h"
 #include "src/core/lib/transport/promise_endpoint.h"
-#include "src/core/lib/transport/transport.h"
 #include "src/core/util/ref_counted_ptr.h"
-#include "src/core/util/sync.h"
+#include "absl/log/log.h"
+#include "absl/status/status.h"
 
 namespace grpc_core {
 namespace http2 {
@@ -46,29 +52,198 @@ namespace http2 {
 #define GRPC_HTTP2_CLIENT_DLOG \
   DLOG_IF(INFO, GRPC_TRACE_FLAG_ENABLED(http2_ph2_transport))
 
+#define GRPC_HTTP2_CLIENT_ERROR_DLOG \
+  LOG_IF(ERROR, GRPC_TRACE_FLAG_ENABLED(http2_ph2_transport))
+
 #define GRPC_HTTP2_COMMON_DLOG \
   DLOG_IF(INFO, GRPC_TRACE_FLAG_ENABLED(http2_ph2_transport))
 
-// Timeout for getting an ack back on settings changes
-#define GRPC_ARG_SETTINGS_TIMEOUT "grpc.http2.settings_timeout"
+constexpr uint32_t kMaxWriteSize = /*10 MB*/ 10u * 1024u * 1024u;
+
+constexpr uint32_t kGoawaySendTimeoutSeconds = 5u;
+
+struct CloseStreamArgs {
+  bool close_reads;
+  bool close_writes;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// Read and Write helpers
+
+class Http2ReadContext {
+ public:
+  // Signals that the read loop should pause. If it's already paused, this is a
+  // no-op.
+  void SetPauseReadLoop() {
+    // TODO(tjagtap) [PH2][P2][Settings] Plumb with when we receive urgent
+    // settings. Example - initial window size 0 is urgent because it indicates
+    // extreme memory pressure on the server.
+    should_pause_read_loop_ = true;
+  }
+
+  // If SetPauseReadLoop() was called, this returns Pending and
+  // registers a waker that will be woken by WakeReadLoop().
+  // If SetPauseReadLoop() was not called, this returns OkStatus.
+  // This should be polled by the read loop to yield control when requested.
+  Poll<absl::Status> MaybePauseReadLoop() {
+    if (should_pause_read_loop_) {
+      read_loop_waker_ = GetContext<Activity>()->MakeNonOwningWaker();
+      return Pending{};
+    }
+    return absl::OkStatus();
+  }
+
+  // If SetPauseReadLoop() was called, resumes it by
+  // waking up the ReadLoop. If not paused, this is a no-op.
+  void ResumeReadLoopIfPaused() {
+    if (should_pause_read_loop_) {
+      should_pause_read_loop_ = false;
+      read_loop_waker_.Wakeup();
+    }
+  }
+
+ private:
+  bool should_pause_read_loop_ = false;
+  Waker read_loop_waker_;
+};
+
+inline PromiseEndpoint::WriteArgs GetWriteArgs(
+    const Http2Settings& peer_settings) {
+  PromiseEndpoint::WriteArgs args;
+  int max_frame_size = peer_settings.preferred_receive_crypto_message_size();
+  // Note: max frame size is 0 if the remote peer does not support adjusting the
+  // sending frame size.
+  if (max_frame_size == 0) {
+    max_frame_size = INT_MAX;
+  }
+  // `WriteArgs.max_frame_size` is a suggestion to the endpoint implementation
+  // to group data to be written into frames of the specified max_frame_size. It
+  // is different from HTTP2 SETTINGS_MAX_FRAME_SIZE. That setting limits HTTP2
+  // frame payload size.
+  args.set_max_frame_size(max_frame_size);
+
+  // TODO(akshitpatel) [PH2][P1] : Currently only the WriteArgs related to
+  // preferred_receive_crypto_message_size have been plumbed. The other write
+  // args may need to be plumbed for PH2.
+  // CHTTP2 : Reference :
+  // File : src/core/ext/transport/chttp2/transport/chttp2_transport.cc
+  // Function : write_action
+
+  return args;
+}
 
-// TODO(akshitpatel) : [PH2][P2] : Choose appropriate size later.
-constexpr int kMpscSize = 10;
-constexpr uint32_t kStreamQueueSize = /*1 MB*/ 1024u * 1024u;
+///////////////////////////////////////////////////////////////////////////////
+// Settings helpers
 
-enum class HttpStreamState : uint8_t {
-  // https://www.rfc-editor.org/rfc/rfc9113.html#name-stream-states
-  kIdle,
-  kOpen,
-  kHalfClosedLocal,
-  kHalfClosedRemote,
-  kClosed,
+void InitLocalSettings(Http2Settings& settings, bool is_client);
+
+////////////////////////////////////////////////////////////////////////////////
+// Channel Args helpers
+
+struct TransportChannelArgs {
+  Duration keepalive_time;
+  Duration keepalive_timeout;
+  Duration ping_timeout;
+  Duration settings_timeout;
+  bool keepalive_permit_without_calls;
+  bool enable_preferred_rx_crypto_frame_advertisement;
+  // This is used to test peer behaviour when we never send a ping ack.
+  bool test_only_ack_pings;
+  uint32_t max_header_list_size_soft_limit;
+  int max_usable_hpack_table_size;
+  int initial_sequence_number;
+
+  std::string DebugString() const {
+    return absl::StrCat(
+        "keepalive_time: ", keepalive_time,
+        " keepalive_timeout: ", keepalive_timeout,
+        " ping_timeout: ", ping_timeout,
+        " settings_timeout: ", settings_timeout,
+        " keepalive_permit_without_calls: ", keepalive_permit_without_calls,
+        " enable_preferred_rx_crypto_frame_advertisement: ",
+        enable_preferred_rx_crypto_frame_advertisement,
+        " max_header_list_size_soft_limit: ", max_header_list_size_soft_limit,
+        " max_usable_hpack_table_size: ", max_usable_hpack_table_size,
+        " initial_sequence_number: ", initial_sequence_number,
+        " test_only_ack_pings: ", test_only_ack_pings);
+  }
 };
 
-void InitLocalSettings(Http2Settings& settings, const bool is_client);
+void ReadChannelArgs(const ChannelArgs& channel_args,
+                     TransportChannelArgs& args, Http2Settings& local_settings,
+                     chttp2::TransportFlowControl& flow_control,
+                     bool is_client);
 
 void ReadSettingsFromChannelArgs(const ChannelArgs& channel_args,
-                                 Http2Settings& settings, const bool is_client);
+                                 Http2Settings& local_settings,
+                                 chttp2::TransportFlowControl& flow_control,
+                                 bool is_client);
+
+///////////////////////////////////////////////////////////////////////////////
+// ChannelZ helpers
+
+RefCountedPtr<channelz::SocketNode> CreateChannelzSocketNode(
+    std::shared_ptr<grpc_event_engine::experimental::EventEngine::Endpoint>
+        event_engine_endpoint,
+    const ChannelArgs& args);
+
+///////////////////////////////////////////////////////////////////////////////
+// Flow control helpers
+
+void ProcessOutgoingDataFrameFlowControl(
+    chttp2::StreamFlowControl& stream_flow_control,
+    uint32_t flow_control_tokens_consumed);
+
+ValueOrHttp2Status<chttp2::FlowControlAction>
+ProcessIncomingDataFrameFlowControl(Http2FrameHeader& frame,
+                                    chttp2::TransportFlowControl& flow_control,
+                                    RefCountedPtr<Stream> stream);
+
+// Returns true if a write should be triggered
+bool ProcessIncomingWindowUpdateFrameFlowControl(
+    const Http2WindowUpdateFrame& frame,
+    chttp2::TransportFlowControl& flow_control, RefCountedPtr<Stream> stream);
+
+void MaybeAddStreamWindowUpdateFrame(RefCountedPtr<Stream> stream,
+                                     std::vector<Http2Frame>& frames);
+
+///////////////////////////////////////////////////////////////////////////////
+// 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,
+                                   RefCountedPtr<Stream> stream,
+                                   Http2Status&& original_status);
 
 }  // namespace http2
 }  // namespace grpc_core

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

@@ -19,6 +19,7 @@
 #include <map>
 #include <string>
 
+#include "src/core/channelz/property_list.h"
 #include "src/core/channelz/ztrace_collector.h"
 #include "src/core/ext/transport/chttp2/transport/frame.h"
 
@@ -27,7 +28,7 @@ namespace http2_ztrace_collector_detail {
 
 class Config {
  public:
-  explicit Config(std::map<std::string, std::string>) {}
+  explicit Config(const channelz::ZTrace::Args&) {}
 
   template <typename T>
   bool Finishes(const T&) {
@@ -43,12 +44,13 @@ struct H2DataTrace {
   bool end_stream;
   uint32_t payload_length;
 
-  void RenderJson(Json::Object& json) const {
-    json["read"] = Json::FromBool(kRead);
-    json["frame_type"] = Json::FromString("DATA");
-    json["stream_id"] = Json::FromNumber(stream_id);
-    json["end_stream"] = Json::FromBool(end_stream);
-    json["payload_length"] = Json::FromNumber(payload_length);
+  channelz::PropertyList ChannelzProperties() const {
+    return channelz::PropertyList()
+        .Set("read", kRead)
+        .Set("frame_type", "DATA")
+        .Set("stream_id", stream_id)
+        .Set("end_stream", end_stream)
+        .Set("payload_length", payload_length);
   }
 };
 
@@ -60,14 +62,14 @@ struct H2HeaderTrace {
   bool continuation;
   uint32_t payload_length;
 
-  void RenderJson(Json::Object& json) const {
-    json["read"] = Json::FromBool(kRead);
-    json["frame_type"] = continuation ? Json::FromString("CONTINUATION")
-                                      : Json::FromString("HEADERS");
-    json["stream_id"] = Json::FromNumber(stream_id);
-    json["end_headers"] = Json::FromBool(end_headers);
-    json["end_stream"] = Json::FromBool(end_stream);
-    json["payload_length"] = Json::FromNumber(payload_length);
+  channelz::PropertyList ChannelzProperties() const {
+    return channelz::PropertyList()
+        .Set("read", kRead)
+        .Set("frame_type", continuation ? "CONTINUATION" : "HEADERS")
+        .Set("stream_id", stream_id)
+        .Set("end_headers", end_headers)
+        .Set("end_stream", end_stream)
+        .Set("payload_length", payload_length);
   }
 };
 
@@ -76,11 +78,12 @@ struct H2RstStreamTrace {
   uint32_t stream_id;
   uint32_t error_code;
 
-  void RenderJson(Json::Object& json) const {
-    json["read"] = Json::FromBool(kRead);
-    json["frame_type"] = Json::FromString("RST_STREAM");
-    json["stream_id"] = Json::FromNumber(stream_id);
-    json["error_code"] = Json::FromNumber(error_code);
+  channelz::PropertyList ChannelzProperties() const {
+    return channelz::PropertyList()
+        .Set("read", kRead)
+        .Set("frame_type", "RST_STREAM")
+        .Set("stream_id", stream_id)
+        .Set("error_code", error_code);
   }
 };
 
@@ -89,18 +92,20 @@ struct H2SettingsTrace {
   bool ack;
   std::vector<Http2SettingsFrame::Setting> settings;
 
-  void RenderJson(Json::Object& json) const {
-    json["read"] = Json::FromBool(kRead);
-    json["frame_type"] = Json::FromString("SETTINGS");
-    json["ack"] = Json::FromBool(ack);
-    Json::Array settings_array;
-    for (const auto& setting : settings) {
-      Json::Object setting_object;
-      setting_object["id"] = Json::FromNumber(setting.id);
-      setting_object["value"] = Json::FromNumber(setting.value);
-      settings_array.push_back(Json::FromObject(std::move(setting_object)));
-    }
-    json["settings"] = Json::FromArray(std::move(settings_array));
+  channelz::PropertyList ChannelzProperties() const {
+    return channelz::PropertyList()
+        .Set("read", kRead)
+        .Set("frame_type", "SETTINGS")
+        .Set("ack", ack)
+        .Set("settings", [this]() {
+          channelz::PropertyTable table;
+          for (const auto& setting : settings) {
+            table.AppendRow(channelz::PropertyList()
+                                .Set("id", setting.id)
+                                .Set("value", setting.value));
+          }
+          return table;
+        }());
   }
 };
 
@@ -109,11 +114,12 @@ struct H2PingTrace {
   bool ack;
   uint64_t opaque;
 
-  void RenderJson(Json::Object& json) const {
-    json["read"] = Json::FromBool(kRead);
-    json["frame_type"] = Json::FromString("PING");
-    json["ack"] = Json::FromBool(ack);
-    json["opaque"] = Json::FromNumber(opaque);
+  channelz::PropertyList ChannelzProperties() const {
+    return channelz::PropertyList()
+        .Set("read", kRead)
+        .Set("frame_type", "PING")
+        .Set("ack", ack)
+        .Set("opaque", opaque);
   }
 };
 
@@ -123,12 +129,13 @@ struct H2GoAwayTrace {
   uint32_t error_code;
   std::string debug_data;
 
-  void RenderJson(Json::Object& json) const {
-    json["read"] = Json::FromBool(kRead);
-    json["frame_type"] = Json::FromString("GOAWAY");
-    json["last_stream_id"] = Json::FromNumber(last_stream_id);
-    json["error_code"] = Json::FromNumber(error_code);
-    json["debug_data"] = Json::FromString(debug_data);
+  channelz::PropertyList ChannelzProperties() const {
+    return channelz::PropertyList()
+        .Set("read", kRead)
+        .Set("frame_type", "GOAWAY")
+        .Set("last_stream_id", last_stream_id)
+        .Set("error_code", error_code)
+        .Set("debug_data", debug_data);
   }
 };
 
@@ -137,11 +144,12 @@ struct H2WindowUpdateTrace {
   uint32_t stream_id;
   uint32_t window_size_increment;
 
-  void RenderJson(Json::Object& json) const {
-    json["read"] = Json::FromBool(kRead);
-    json["frame_type"] = Json::FromString("WINDOW_UPDATE");
-    json["stream_id"] = Json::FromNumber(stream_id);
-    json["window_size_increment"] = Json::FromNumber(window_size_increment);
+  channelz::PropertyList ChannelzProperties() const {
+    return channelz::PropertyList()
+        .Set("read", kRead)
+        .Set("frame_type", "WINDOW_UPDATE")
+        .Set("stream_id", stream_id)
+        .Set("window_size_increment", window_size_increment);
   }
 };
 
@@ -149,10 +157,11 @@ template <bool kRead>
 struct H2SecurityTrace {
   uint32_t payload_length;
 
-  void RenderJson(Json::Object& json) const {
-    json["read"] = Json::FromBool(kRead);
-    json["frame_type"] = Json::FromString("SECURITY");
-    json["payload_length"] = Json::FromNumber(payload_length);
+  channelz::PropertyList ChannelzProperties() const {
+    return channelz::PropertyList()
+        .Set("read", kRead)
+        .Set("frame_type", "SECURITY")
+        .Set("payload_length", payload_length);
   }
 };
 
@@ -162,12 +171,13 @@ struct H2UnknownFrameTrace {
   uint32_t stream_id;
   uint32_t payload_length;
 
-  void RenderJson(Json::Object& json) const {
-    json["frame_type"] = Json::FromString("UNKNOWN");
-    json["type"] = Json::FromNumber(type);
-    json["flags"] = Json::FromNumber(flags);
-    json["stream_id"] = Json::FromNumber(stream_id);
-    json["payload_length"] = Json::FromNumber(payload_length);
+  channelz::PropertyList ChannelzProperties() const {
+    return channelz::PropertyList()
+        .Set("frame_type", "UNKNOWN")
+        .Set("type", type)
+        .Set("flags", flags)
+        .Set("stream_id", stream_id)
+        .Set("payload_length", payload_length);
   }
 };
 
@@ -176,35 +186,94 @@ struct H2FlowControlStall {
   int64_t stream_window;
   uint32_t stream_id;
 
-  void RenderJson(Json::Object& json) const {
-    json["metadata_type"] = Json::FromString("FLOW_CONTROL_STALL");
-    json["transport_window"] = Json::FromNumber(transport_window);
-    json["stream_window"] = Json::FromNumber(stream_window);
-    json["stream_id"] = Json::FromNumber(stream_id);
+  channelz::PropertyList ChannelzProperties() const {
+    return channelz::PropertyList()
+        .Set("frame_type", "FLOW_CONTROL_STALL")
+        .Set("transport_window", transport_window)
+        .Set("stream_window", stream_window)
+        .Set("stream_id", stream_id);
   }
 };
 
 struct H2BeginWriteCycle {
   uint32_t target_size;
 
-  void RenderJson(Json::Object& json) const {
-    json["metadata_type"] = Json::FromString("BEGIN_WRITE_CYCLE");
-    json["target_size"] = Json::FromNumber(target_size);
+  channelz::PropertyList ChannelzProperties() const {
+    return channelz::PropertyList()
+        .Set("frame_type", "BEGIN_WRITE_CYCLE")
+        .Set("target_size", target_size);
   }
 };
 
 struct H2BeginEndpointWrite {
   uint32_t write_size;
 
-  void RenderJson(Json::Object& json) const {
-    json["metadata_type"] = Json::FromString("BEGIN_ENDPOINT_WRITE");
-    json["write_size"] = Json::FromNumber(write_size);
+  channelz::PropertyList ChannelzProperties() const {
+    return channelz::PropertyList()
+        .Set("frame_type", "BEGIN_ENDPOINT_WRITE")
+        .Set("write_size", write_size);
   }
 };
 
 struct H2EndWriteCycle {
-  void RenderJson(Json::Object& json) const {
-    json["metadata_type"] = Json::FromString("END_WRITE_CYCLE");
+  channelz::PropertyList ChannelzProperties() const {
+    return channelz::PropertyList().Set("frame_type", "END_WRITE_CYCLE");
+  }
+};
+
+struct H2TcpMetricsTrace {
+  std::shared_ptr<
+      grpc_event_engine::experimental::EventEngine::Endpoint::TelemetryInfo>
+      telemetry_info;
+  grpc_event_engine::experimental::EventEngine::Endpoint::WriteEvent event;
+  std::vector<
+      grpc_event_engine::experimental::EventEngine::Endpoint::WriteMetric>
+      metrics;
+  absl::Time timestamp;
+
+  size_t MemoryUsage() const {
+    return sizeof(H2TcpMetricsTrace) + metrics.capacity() * sizeof(metrics[0]);
+  }
+
+  channelz::PropertyList ChannelzProperties() const {
+    absl::string_view event_string = "unknown";
+    switch (event) {
+      case grpc_event_engine::experimental::EventEngine::Endpoint::WriteEvent::
+          kSendMsg:
+        event_string = "send_msg";
+        break;
+      case grpc_event_engine::experimental::EventEngine::Endpoint::WriteEvent::
+          kScheduled:
+        event_string = "scheduled";
+        break;
+      case grpc_event_engine::experimental::EventEngine::Endpoint::WriteEvent::
+          kSent:
+        event_string = "sent";
+        break;
+      case grpc_event_engine::experimental::EventEngine::Endpoint::WriteEvent::
+          kAcked:
+        event_string = "acked";
+        break;
+      case grpc_event_engine::experimental::EventEngine::Endpoint::WriteEvent::
+          kClosed:
+        event_string = "closed";
+        break;
+      default:
+        break;
+    }
+    return channelz::PropertyList()
+        .Set("event", event_string)
+        .Set("tcp_event_timestamp", timestamp)
+        .Merge([this]() {
+          channelz::PropertyList props;
+          for (const auto& metric : metrics) {
+            if (auto key = telemetry_info->GetMetricName(metric.key);
+                key.has_value()) {
+              props.Set(*key, metric.value);
+            }
+          }
+          return props;
+        }());
   }
 };
 
@@ -216,7 +285,38 @@ using Http2ZTraceCollector = channelz::ZTraceCollector<
     H2RstStreamTrace<true>, H2SettingsTrace<true>, H2PingTrace<true>,
     H2GoAwayTrace<true>, H2WindowUpdateTrace<true>, H2SecurityTrace<true>,
     H2UnknownFrameTrace, H2FlowControlStall, H2BeginWriteCycle, H2EndWriteCycle,
-    H2BeginEndpointWrite>;
+    H2BeginEndpointWrite, H2TcpMetricsTrace>;
+
+struct PromiseEndpointReadTrace {
+  uint64_t bytes;
+  channelz::PropertyList ChannelzProperties() const {
+    return channelz::PropertyList().Set("read_bytes", bytes);
+  }
+};
+
+struct PromiseEndpointWriteTrace {
+  uint64_t bytes;
+  channelz::PropertyList ChannelzProperties() const {
+    return channelz::PropertyList().Set("written_bytes", bytes);
+  }
+};
+
+namespace promise_http2_ztrace_collector_detail {
+class Config {
+ public:
+  explicit Config(const channelz::ZTrace::Args&) {}
+
+  template <typename T>
+  bool Finishes(const T&) {
+    return false;
+  }
+};
+}  // namespace promise_http2_ztrace_collector_detail
+
+using PromiseHttp2ZTraceCollector =
+    channelz::ZTraceCollector<promise_http2_ztrace_collector_detail::Config,
+                              PromiseEndpointReadTrace,
+                              PromiseEndpointWriteTrace>;
 
 }  // namespace grpc_core