grpc 1.75.0.pre1 → 1.76.0.pre1

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

@@ -31,6 +31,9 @@
 namespace grpc_core {
 
 std::optional<Http2SettingsFrame> Http2SettingsManager::MaybeSendUpdate() {
+  if (!IsPreviousSettingsPromiseResolved()) {
+    return std::nullopt;
+  }
   switch (update_state_) {
     case UpdateState::kSending:
       return std::nullopt;

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

@@ -22,6 +22,7 @@
 
 #include <cstdint>
 #include <optional>
+#include <queue>
 
 #include "absl/functional/function_ref.h"
 #include "absl/strings/string_view.h"
@@ -29,6 +30,7 @@
 #include "src/core/ext/transport/chttp2/transport/frame.h"
 #include "src/core/ext/transport/chttp2/transport/http2_settings.h"
 #include "src/core/ext/transport/chttp2/transport/http2_status.h"
+#include "src/core/lib/channel/channel_args.h"
 #include "src/core/util/useful.h"
 
 namespace grpc_core {
@@ -80,6 +82,13 @@ class Http2SettingsManager {
   // This function is not idempotent.
   GRPC_MUST_USE_RESULT bool AckLastSend();
 
+  GRPC_MUST_USE_RESULT bool IsPreviousSettingsPromiseResolved() const {
+    return did_previous_settings_promise_resolve_;
+  }
+  void SetPreviousSettingsPromiseResolved(const bool value) {
+    did_previous_settings_promise_resolve_ = value;
+  }
+
  private:
   struct CountUpdates {
     http2::Http2ErrorCode IsUpdatePermitted(const uint16_t setting_id,
@@ -135,6 +144,8 @@ class Http2SettingsManager {
   Http2Settings local_;
   Http2Settings sent_;
   Http2Settings acked_;
+
+  bool did_previous_settings_promise_resolve_ = true;
 };
 
 }  // namespace grpc_core

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

@@ -0,0 +1,179 @@
+//
+//
+// Copyright 2025 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
+
+#ifndef GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HTTP2_SETTINGS_PROMISES_H
+#define GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HTTP2_SETTINGS_PROMISES_H
+
+#include <grpc/support/port_platform.h>
+#include <stdint.h>
+
+#include <cstdint>
+#include <optional>
+#include <queue>
+
+#include "absl/functional/function_ref.h"
+#include "absl/strings/string_view.h"
+#include "src/core/channelz/property_list.h"
+#include "src/core/ext/transport/chttp2/transport/frame.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/lib/channel/channel_args.h"
+#include "src/core/lib/promise/race.h"
+#include "src/core/lib/promise/sleep.h"
+#include "src/core/lib/promise/try_seq.h"
+#include "src/core/util/grpc_check.h"
+#include "src/core/util/time.h"
+#include "src/core/util/useful.h"
+namespace grpc_core {
+
+// Timeout for getting an ack back on settings changes
+#define GRPC_ARG_SETTINGS_TIMEOUT "grpc.http2.settings_timeout"
+
+#define GRPC_SETTINGS_TIMEOUT_DLOG DLOG(INFO)
+
+// This class can only be used only from a promise based HTTP2 transports
+// general_party_ .
+// This class is designed with the assumption that only 1 SETTINGS frame will be
+// in flight at a time. And we do not send a second SETTINGS frame till we
+// receive and process the SETTINGS ACK.
+class SettingsTimeoutManager {
+ public:
+  // Assumption : This would be set only once in the life of the transport.
+  inline void SetSettingsTimeout(const ChannelArgs& channel_args,
+                                 const Duration keepalive_timeout) {
+    timeout_ =
+        channel_args.GetDurationFromIntMillis(GRPC_ARG_SETTINGS_TIMEOUT)
+            .value_or(std::max(keepalive_timeout * 2, Duration::Minutes(1)));
+  }
+
+  // To be called when a promise based Transport receives an a SETTINGS ACK
+  // frame.
+  inline void OnSettingsAckReceived() { RecordReceivedAck(); }
+
+  // This returns a promise which must be spawned on transports general party.
+  // This must be spawned soon after the transport sends a SETTINGS frame on the
+  // endpoint.
+  // If we don't get an ACK before timeout, the caller MUST close the transport.
+  auto WaitForSettingsTimeout() {
+    GRPC_SETTINGS_TIMEOUT_DLOG
+        << "SettingsTimeoutManager::WaitForSettingsTimeout Factory";
+    StartSettingsTimeoutTimer();
+    // TODO(tjagtap) : [PH2][P1] : Make this a ref counted class and manage the
+    // lifetime
+    return AssertResultType<absl::Status>(
+        Race(
+            [this]() -> Poll<absl::Status> {
+              GRPC_SETTINGS_TIMEOUT_DLOG
+                  << "SettingsTimeoutManager::WaitForSettingsTimeout Race";
+              // This Promise will "win" the race if we receive the SETTINGS
+              // ACK from the peer within the timeout time.
+              if (DidReceiveAck()) {
+                GRPC_DCHECK(
+                sent_time_ +
+                    (timeout_ *
+                     1.1 /* 10% grace time for this promise to be scheduled*/) >
+                Timestamp::Now())
+                << "Should have timed out";
+                RemoveReceivedAck();
+                return absl::OkStatus();
+              }
+              AddWaitingForAck();
+              return Pending{};
+            },
+            // This promise will "Win" the Race if timeout is crossed and we did
+            // not receive the ACK. The transport must close when this happens.
+            TrySeq(Sleep(timeout_), [sent_time = sent_time_,
+                                     timeout = timeout_]() {
+              GRPC_SETTINGS_TIMEOUT_DLOG
+                  << "SettingsTimeoutManager::WaitForSettingsTimeout Timeout"
+                     " triggered. Transport will close. Sent Time : "
+                  << sent_time << " Timeout Time : " << (sent_time + timeout)
+                  << " Current Time " << Timestamp::Now();
+              return absl::CancelledError(
+                  std::string(RFC9113::kSettingsTimeout));
+            })));
+  }
+
+ private:
+  inline void StartSettingsTimeoutTimer() {
+    GRPC_SETTINGS_TIMEOUT_DLOG
+        << "SettingsTimeoutManager::StartSettingsTimeoutTimer "
+           "did_register_waker_ "
+        << did_register_waker_
+        << " number_of_acks_unprocessed_ : " << number_of_acks_unprocessed_;
+    GRPC_DCHECK_EQ(number_of_acks_unprocessed_, 0);
+    GRPC_DCHECK(!did_register_waker_);
+    sent_time_ = Timestamp::Now();
+  }
+  inline bool DidReceiveAck() {
+    GRPC_SETTINGS_TIMEOUT_DLOG
+        << "SettingsTimeoutManager::DidReceiveAck did_register_waker_ "
+        << did_register_waker_
+        << " number_of_acks_unprocessed_ : " << number_of_acks_unprocessed_;
+    return number_of_acks_unprocessed_ > 0;
+  }
+  inline void AddWaitingForAck() {
+    GRPC_SETTINGS_TIMEOUT_DLOG
+        << "SettingsTimeoutManager::AddWaitingForAck did_register_waker_ "
+        << did_register_waker_
+        << " number_of_acks_unprocessed_ : " << number_of_acks_unprocessed_;
+    if (!did_register_waker_) {
+      GRPC_DCHECK_EQ(number_of_acks_unprocessed_, 0);
+      waker_ = GetContext<Activity>()->MakeNonOwningWaker();
+      did_register_waker_ = true;
+    }
+    GRPC_DCHECK(did_register_waker_);
+  }
+  inline void RecordReceivedAck() {
+    GRPC_SETTINGS_TIMEOUT_DLOG
+        << "SettingsTimeoutManager::RecordReceivedAck did_register_waker_ "
+        << did_register_waker_
+        << " number_of_acks_unprocessed_ : " << number_of_acks_unprocessed_;
+    GRPC_DCHECK_EQ(number_of_acks_unprocessed_, 0);
+    ++number_of_acks_unprocessed_;
+    if (did_register_waker_) {
+      // It is possible that we receive the ACK before WaitForSettingsTimeout is
+      // scheduled. That is why we do this inside an if.
+      waker_.Wakeup();
+      did_register_waker_ = false;
+    }
+    GRPC_DCHECK(!did_register_waker_);
+  }
+  inline void RemoveReceivedAck() {
+    GRPC_SETTINGS_TIMEOUT_DLOG
+        << "SettingsTimeoutManager::RemoveReceivedAck did_register_waker_ "
+        << did_register_waker_
+        << " number_of_acks_unprocessed_ : " << number_of_acks_unprocessed_;
+    --number_of_acks_unprocessed_;
+    GRPC_DCHECK_EQ(number_of_acks_unprocessed_, 0);
+    GRPC_DCHECK(!did_register_waker_);
+  }
+
+  Duration timeout_;
+  // We don't actually use this for the timeout. We are just keeping this as
+  // book keeping for better debuggability.
+  Timestamp sent_time_ = Timestamp::InfFuture();
+  Waker waker_;
+  bool did_register_waker_ = false;
+  int number_of_acks_unprocessed_ = 0;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HTTP2_SETTINGS_PROMISES_H

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

@@ -23,6 +23,8 @@
 
 #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/lib/promise/mpsc.h"
 #include "src/core/lib/promise/party.h"
@@ -52,69 +54,95 @@ void InitLocalSettings(Http2Settings& settings, const bool is_client) {
 }
 
 void ReadSettingsFromChannelArgs(const ChannelArgs& channel_args,
-                                 Http2Settings& settings,
+                                 Http2Settings& local_settings,
+                                 chttp2::TransportFlowControl& flow_control,
                                  const bool is_client) {
   if (channel_args.Contains(GRPC_ARG_HTTP2_HPACK_TABLE_SIZE_DECODER)) {
-    settings.SetHeaderTableSize(
+    local_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(
+      local_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
+      // MAX_CONCURRENT_STREAMS for clients because we don't 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.
+    int value =
+        channel_args.GetInt(GRPC_ARG_HTTP2_STREAM_LOOKAHEAD_BYTES).value_or(-1);
+    if (value >= 0) {
+      local_settings.SetInitialWindowSize(value);
+      flow_control.set_target_initial_window_size(value);
+    }
   }
 
-  settings.SetMaxHeaderListSize(GetHardLimitFromChannelArgs(channel_args));
+  local_settings.SetMaxHeaderListSize(
+      GetHardLimitFromChannelArgs(channel_args));
 
   if (channel_args.Contains(GRPC_ARG_HTTP2_MAX_FRAME_SIZE)) {
-    settings.SetMaxFrameSize(
+    local_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);
+    local_settings.SetPreferredReceiveCryptoMessageSize(INT_MAX);
   }
 
   if (channel_args.Contains(GRPC_ARG_HTTP2_ENABLE_TRUE_BINARY)) {
-    settings.SetAllowTrueBinaryMetadata(
+    local_settings.SetAllowTrueBinaryMetadata(
         channel_args.GetInt(GRPC_ARG_HTTP2_ENABLE_TRUE_BINARY).value_or(-1) !=
         0);
   }
 
-  settings.SetAllowSecurityFrame(
+  local_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()
+      << "header_table_size: " << local_settings.header_table_size()
+      << ", max_concurrent_streams: " << local_settings.max_concurrent_streams()
+      << ", initial_window_size: " << local_settings.initial_window_size()
+      << ", max_frame_size: " << local_settings.max_frame_size()
+      << ", max_header_list_size: " << local_settings.max_header_list_size()
       << ", preferred_receive_crypto_message_size: "
-      << settings.preferred_receive_crypto_message_size()
-      << ", enable_push: " << settings.enable_push()
+      << local_settings.preferred_receive_crypto_message_size()
+      << ", enable_push: " << local_settings.enable_push()
       << ", allow_true_binary_metadata: "
-      << settings.allow_true_binary_metadata()
-      << ", allow_security_frame: " << settings.allow_security_frame() << "}";
+      << local_settings.allow_true_binary_metadata()
+      << ", allow_security_frame: " << local_settings.allow_security_frame()
+      << "}";
+}
+
+RefCountedPtr<channelz::SocketNode> CreateChannelzSocketNode(
+    std::shared_ptr<grpc_event_engine::experimental::EventEngine::Endpoint>
+        event_engine_endpoint,
+    const ChannelArgs& args) {
+  if (args.GetBool(GRPC_ARG_ENABLE_CHANNELZ)
+          .value_or(GRPC_ENABLE_CHANNELZ_DEFAULT)) {
+    auto local_addr = grpc_event_engine::experimental::ResolvedAddressToString(
+        event_engine_endpoint->GetLocalAddress());
+    auto peer_addr = grpc_event_engine::experimental::ResolvedAddressToString(
+        event_engine_endpoint->GetPeerAddress());
+    GRPC_HTTP2_COMMON_DLOG << "CreateChannelzSocketNode: local_addr: "
+                           << local_addr.value_or("unknown")
+                           << " peer_addr: " << peer_addr.value_or("unknown");
+    return MakeRefCounted<channelz::SocketNode>(
+        local_addr.value_or("unknown"), peer_addr.value_or("unknown"),
+        absl::StrCat("http2", " ", peer_addr.value_or("unknown")),
+        args.GetObjectRef<channelz::SocketNode::Security>());
+  }
+  return nullptr;
 }
 
 }  // namespace http2

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

@@ -24,8 +24,11 @@
 
 #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/http2_settings.h"
+#include "src/core/lib/event_engine/tcp_socket_utils.h"
 #include "src/core/lib/promise/mpsc.h"
 #include "src/core/lib/promise/party.h"
 #include "src/core/lib/transport/promise_endpoint.h"
@@ -49,12 +52,9 @@ namespace http2 {
 #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;
+// TODO(akshitpatel) : [PH2][P4] : Choose appropriate size later.
 constexpr uint32_t kStreamQueueSize = /*1 MB*/ 1024u * 1024u;
+constexpr uint32_t kMaxWriteSize = /*10 MB*/ 10u * 1024u * 1024u;
 
 enum class HttpStreamState : uint8_t {
   // https://www.rfc-editor.org/rfc/rfc9113.html#name-stream-states
@@ -68,7 +68,14 @@ enum class HttpStreamState : uint8_t {
 void InitLocalSettings(Http2Settings& settings, const bool is_client);
 
 void ReadSettingsFromChannelArgs(const ChannelArgs& channel_args,
-                                 Http2Settings& settings, const bool is_client);
+                                 Http2Settings& local_settings,
+                                 chttp2::TransportFlowControl& flow_control,
+                                 const bool is_client);
+
+RefCountedPtr<channelz::SocketNode> CreateChannelzSocketNode(
+    std::shared_ptr<grpc_event_engine::experimental::EventEngine::Endpoint>
+        event_engine_endpoint,
+    const ChannelArgs& args);
 
 }  // namespace http2
 }  // namespace grpc_core