grpc 1.74.0 → 1.75.0

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

@@ -16,12 +16,14 @@
 //
 //
 
+#include "src/core/ext/transport/chttp2/transport/http2_transport.h"
+
 #include <cstdint>
 #include <utility>
 
 #include "src/core/call/call_spine.h"
+#include "src/core/call/metadata_info.h"
 #include "src/core/ext/transport/chttp2/transport/frame.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/lib/transport/promise_endpoint.h"
@@ -36,8 +38,84 @@ namespace http2 {
 // and it is functions. 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] : We may not need this file. Delete once Server
-// Transport is complete.
+
+void InitLocalSettings(Http2Settings& settings, const bool is_client) {
+  if (is_client) {
+    // gRPC has never supported PUSH_PROMISE and we have no plan to do so in the
+    // future.
+    settings.SetEnablePush(false);
+    // This is to make it double-sure that server cannot initite a stream.
+    settings.SetMaxConcurrentStreams(0);
+  }
+  settings.SetMaxHeaderListSize(DEFAULT_MAX_HEADER_LIST_SIZE);
+  settings.SetAllowTrueBinaryMetadata(true);
+}
+
+void ReadSettingsFromChannelArgs(const ChannelArgs& channel_args,
+                                 Http2Settings& settings,
+                                 const bool is_client) {
+  if (channel_args.Contains(GRPC_ARG_HTTP2_HPACK_TABLE_SIZE_DECODER)) {
+    settings.SetHeaderTableSize(
+        channel_args.GetInt(GRPC_ARG_HTTP2_HPACK_TABLE_SIZE_DECODER)
+            .value_or(-1));
+  }
+
+  if (channel_args.Contains(GRPC_ARG_MAX_CONCURRENT_STREAMS)) {
+    if (!is_client) {
+      settings.SetMaxConcurrentStreams(
+          channel_args.GetInt(GRPC_ARG_MAX_CONCURRENT_STREAMS).value_or(-1));
+    } else {
+      // We do not allow the channel arg to alter our 0 setting for
+      // MAX_CONCURRENT_STREAMS for clients because we dont support PUSH_PROMISE
+      LOG(WARNING) << "ChannelArg GRPC_ARG_MAX_CONCURRENT_STREAMS is not "
+                      "available on clients";
+    }
+  }
+
+  if (channel_args.Contains(GRPC_ARG_HTTP2_STREAM_LOOKAHEAD_BYTES)) {
+    settings.SetInitialWindowSize(
+        channel_args.GetInt(GRPC_ARG_HTTP2_STREAM_LOOKAHEAD_BYTES)
+            .value_or(-1));
+    // TODO(tjagtap) [PH2][P2] : Also set this for flow control.
+    // Refer to read_channel_args() in chttp2_transport.cc for more details.
+  }
+
+  settings.SetMaxHeaderListSize(GetHardLimitFromChannelArgs(channel_args));
+
+  if (channel_args.Contains(GRPC_ARG_HTTP2_MAX_FRAME_SIZE)) {
+    settings.SetMaxFrameSize(
+        channel_args.GetInt(GRPC_ARG_HTTP2_MAX_FRAME_SIZE).value_or(-1));
+  }
+
+  if (channel_args
+          .GetBool(GRPC_ARG_EXPERIMENTAL_HTTP2_PREFERRED_CRYPTO_FRAME_SIZE)
+          .value_or(false)) {
+    settings.SetPreferredReceiveCryptoMessageSize(INT_MAX);
+  }
+
+  if (channel_args.Contains(GRPC_ARG_HTTP2_ENABLE_TRUE_BINARY)) {
+    settings.SetAllowTrueBinaryMetadata(
+        channel_args.GetInt(GRPC_ARG_HTTP2_ENABLE_TRUE_BINARY).value_or(-1) !=
+        0);
+  }
+
+  settings.SetAllowSecurityFrame(
+      channel_args.GetBool(GRPC_ARG_SECURITY_FRAME_ALLOWED).value_or(false));
+
+  GRPC_HTTP2_COMMON_DLOG
+      << "Http2Settings: {"
+      << "header_table_size: " << settings.header_table_size()
+      << ", max_concurrent_streams: " << settings.max_concurrent_streams()
+      << ", initial_window_size: " << settings.initial_window_size()
+      << ", max_frame_size: " << settings.max_frame_size()
+      << ", max_header_list_size: " << settings.max_header_list_size()
+      << ", preferred_receive_crypto_message_size: "
+      << settings.preferred_receive_crypto_message_size()
+      << ", enable_push: " << settings.enable_push()
+      << ", allow_true_binary_metadata: "
+      << settings.allow_true_binary_metadata()
+      << ", allow_security_frame: " << settings.allow_security_frame() << "}";
+}
 
 }  // namespace http2
 }  // namespace grpc_core

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

@@ -23,6 +23,7 @@
 #include <utility>
 
 #include "src/core/call/call_spine.h"
+#include "src/core/call/metadata_info.h"
 #include "src/core/ext/transport/chttp2/transport/frame.h"
 #include "src/core/ext/transport/chttp2/transport/http2_settings.h"
 #include "src/core/lib/promise/mpsc.h"
@@ -45,8 +46,15 @@ namespace http2 {
 #define GRPC_HTTP2_CLIENT_DLOG \
   DLOG_IF(INFO, 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"
+
 // TODO(akshitpatel) : [PH2][P2] : Choose appropriate size later.
 constexpr int kMpscSize = 10;
+constexpr uint32_t kStreamQueueSize = /*1 MB*/ 1024u * 1024u;
 
 enum class HttpStreamState : uint8_t {
   // https://www.rfc-editor.org/rfc/rfc9113.html#name-stream-states
@@ -57,7 +65,10 @@ enum class HttpStreamState : uint8_t {
   kClosed,
 };
 
-class TransportSendQeueue {};
+void InitLocalSettings(Http2Settings& settings, const bool is_client);
+
+void ReadSettingsFromChannelArgs(const ChannelArgs& channel_args,
+                                 Http2Settings& settings, const bool is_client);
 
 }  // namespace http2
 }  // namespace grpc_core

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

@@ -76,8 +76,7 @@ class GrpcMessageAssembler {
   ValueOrHttp2Status<MessageHandle> ExtractMessage() {
     const size_t current_len = message_buffer_.Length();
     if (current_len < kGrpcHeaderSizeInBytes) {
-      // TODO(tjagtap) : [PH2][P3] : Write a test for this failure.
-      LOG(ERROR) << "Incomplete gRPC message received";
+      // TODO(tjagtap) : [PH2][P3] : Write a test for this.
       return ReturnNullOrError();
     }
     GrpcMessageHeader header = ExtractGrpcHeader(message_buffer_);
@@ -113,6 +112,7 @@ class GrpcMessageAssembler {
       return Http2Status::Http2StreamError(Http2ErrorCode::kInternalError,
                                            "Incomplete gRPC frame received");
     }
+    VLOG(2) << "Incomplete gRPC message received. Return nullptr";
     return ValueOrHttp2Status<MessageHandle>(nullptr);
   }
   bool is_end_stream_ = false;

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

@@ -54,6 +54,7 @@
 #include "src/core/ext/transport/chttp2/transport/hpack_parser.h"
 #include "src/core/ext/transport/chttp2/transport/hpack_parser_table.h"
 #include "src/core/ext/transport/chttp2/transport/http2_settings.h"
+#include "src/core/ext/transport/chttp2/transport/http2_settings_manager.h"
 #include "src/core/ext/transport/chttp2/transport/http2_status.h"
 #include "src/core/ext/transport/chttp2/transport/http2_ztrace_collector.h"
 #include "src/core/ext/transport/chttp2/transport/internal.h"
@@ -212,7 +213,7 @@ std::string FrameTypeString(uint8_t frame_type, uint8_t flags) {
 std::variant<size_t, absl::Status> grpc_chttp2_perform_read(
     grpc_chttp2_transport* t, const grpc_slice& slice,
     size_t& requests_started) {
-  GRPC_LATENT_SEE_INNER_SCOPE("grpc_chttp2_perform_read");
+  GRPC_LATENT_SEE_SCOPE("grpc_chttp2_perform_read");
 
   const uint8_t* beg = GRPC_SLICE_START_PTR(slice);
   const uint8_t* end = GRPC_SLICE_END_PTR(slice);

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

@@ -40,7 +40,8 @@ using grpc_event_engine::experimental::EventEngine;
                 GRPC_TRACE_FLAG_ENABLED(http2_ping)))
 
 Promise<absl::Status> PingManager::PingPromiseCallbacks::RequestPing(
-    Callback on_initiate) {
+    Callback on_initiate, bool important) {
+  important_ping_requested_ = (important_ping_requested_ || important);
   std::shared_ptr<Latch<void>> latch = std::make_shared<Latch<void>>();
   auto on_ack = [latch]() { latch->Set(); };
   ping_callbacks_.OnPing(std::move(on_initiate), std::move(on_ack));

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

@@ -110,8 +110,8 @@ class PingManager {
   // Returns a promise that resolves once a new ping is initiated and ack is
   // received for the same. The on_initiate callback is executed when the
   // ping is initiated.
-  auto RequestPing(absl::AnyInvocable<void()> on_initiate) {
-    return ping_callbacks_.RequestPing(std::move(on_initiate));
+  auto RequestPing(absl::AnyInvocable<void()> on_initiate, bool important) {
+    return ping_callbacks_.RequestPing(std::move(on_initiate), important);
   }
 
   // Returns a promise that resolves once the next valid ping ack is received.
@@ -125,6 +125,9 @@ class PingManager {
 
   uint64_t StartPing() { return ping_callbacks_.StartPing(); }
   bool PingRequested() { return ping_callbacks_.PingRequested(); }
+  bool ImportantPingRequested() const {
+    return ping_callbacks_.ImportantPingRequested();
+  }
   bool AckPing(uint64_t id) { return ping_callbacks_.AckPing(id); }
   size_t CountPingInflight() { return ping_callbacks_.CountPingInflight(); }
 
@@ -135,11 +138,19 @@ class PingManager {
         std::shared_ptr<grpc_event_engine::experimental::EventEngine>
             event_engine)
         : event_engine_(event_engine) {}
-    Promise<absl::Status> RequestPing(absl::AnyInvocable<void()> on_initiate);
+    Promise<absl::Status> RequestPing(absl::AnyInvocable<void()> on_initiate,
+                                      bool important);
     Promise<absl::Status> WaitForPingAck();
-    void CancelCallbacks() { ping_callbacks_.CancelAll(event_engine_.get()); }
-    uint64_t StartPing() { return ping_callbacks_.StartPing(SharedBitGen()); }
+    void CancelCallbacks() {
+      important_ping_requested_ = false;
+      ping_callbacks_.CancelAll(event_engine_.get());
+    }
+    uint64_t StartPing() {
+      important_ping_requested_ = false;
+      return ping_callbacks_.StartPing(SharedBitGen());
+    }
     bool PingRequested() { return ping_callbacks_.ping_requested(); }
+    bool ImportantPingRequested() const { return important_ping_requested_; }
     bool AckPing(uint64_t id) {
       return ping_callbacks_.AckPing(id, event_engine_.get());
     }
@@ -160,6 +171,12 @@ class PingManager {
    private:
     Chttp2PingCallbacks ping_callbacks_;
     std::shared_ptr<grpc_event_engine::experimental::EventEngine> event_engine_;
+    // Return true if an "important" ping request needs to be started. This can
+    // be used to determine if a ping should be sent as soon as possible. If
+    // there are no outstanding ping requests, this is guaranteed to be false.
+    // If there is at least one outstanding ping request, this may be true or
+    // false.
+    bool important_ping_requested_ = false;
   };
 
   PingPromiseCallbacks ping_callbacks_;