grpc 1.83.1 → 1.84.0

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

@@ -44,6 +44,7 @@
 #include "src/core/util/ref_counted_ptr.h"
 #include "absl/log/log.h"
 #include "absl/status/status.h"
+#include "absl/strings/str_cat.h"
 
 namespace grpc_core {
 namespace http2 {
@@ -209,6 +210,16 @@ class StreamState {
   std::atomic<bool> writes_closed_{false};
 };
 
+// Lifecycle state of a stream undergoing tarpitting.
+enum class TarpitState : uint8_t {
+  // Stream has never been tarpitted.
+  kNone = 0,
+  // Stream is actively tarpitted (timer running in queue).
+  kActive = 1,
+  // Tarpit timer expired; executing final post-tarpit action.
+  kCompleted = 2,
+};
+
 // Managing the streams
 class Stream : public RefCounted<Stream> {
  public:
@@ -217,14 +228,9 @@ class Stream : public RefCounted<Stream> {
       : flow_control_(&transport_flow_control),
         call_(std::move(call_handler)),
         state_(/*started=*/false),
-        stream_id_(kInvalidStreamId),
-        did_receive_initial_metadata_(false),
-        did_receive_trailing_metadata_(false),
-        did_push_server_trailing_metadata_(false),
-        did_cancel_(false),
         data_queue_(MakeRefCounted<StreamDataQueue<ClientMetadataHandle>>(
-            std::get<CallHandler>(call_).arena(), /*is_client*/ true,
-            /*queue_size*/ kStreamQueueSize)) {}
+            std::get<CallHandler>(call_).arena(), /*is_client=*/true,
+            /*queue_size=*/kStreamQueueSize)) {}
 
   explicit Stream(CallInitiator call_initiator,
                   chttp2::TransportFlowControl& transport_flow_control,
@@ -234,13 +240,9 @@ class Stream : public RefCounted<Stream> {
         call_(std::move(call_initiator)),
         state_(/*started=*/true),
         stream_id_(stream_id),
-        did_receive_initial_metadata_(false),
-        did_receive_trailing_metadata_(false),
-        did_push_server_trailing_metadata_(false),
-        did_cancel_(false),
         data_queue_(MakeRefCounted<StreamDataQueue<ClientMetadataHandle>>(
-            std::get<CallInitiator>(call_).arena(), /*is_client*/ false,
-            /*queue_size*/ kStreamQueueSize)) {
+            std::get<CallInitiator>(call_).arena(), /*is_client=*/false,
+            /*queue_size=*/kStreamQueueSize)) {
     InitializeStream(allow_true_binary_metadata_peer);
   }
 
@@ -331,6 +333,44 @@ class Stream : public RefCounted<Stream> {
   // gRPC stream state
   bool IsClosedForReads() const { return state_.reads_closed(); }
   bool IsClosedForWrites() const { return state_.writes_closed(); }
+  // Returns the current tarpit lifecycle state of the stream.
+  TarpitState GetTarpitState() const {
+    return tarpit_state_.load(std::memory_order_relaxed);
+  }
+  // Returns true if the stream has never entered the tarpit lifecycle.
+  bool WasNeverTarpitted() const {
+    return tarpit_state_.load(std::memory_order_relaxed) == TarpitState::kNone;
+  }
+  // Returns true if the stream is either actively tarpitted or has completed
+  // tarpitting.
+  bool IsTarpitted() const {
+    return tarpit_state_.load(std::memory_order_relaxed) != TarpitState::kNone;
+  }
+  // Returns true only while the tarpit timer is actively running.
+  bool IsTarpitTimerActive() const {
+    return tarpit_state_.load(std::memory_order_relaxed) ==
+           TarpitState::kActive;
+  }
+  // Returns true if tarpitting has completed. The stream may not yet be closed,
+  // but stream closure is imminent.
+  bool IsTarpitCompleted() const {
+    return tarpit_state_.load(std::memory_order_relaxed) ==
+           TarpitState::kCompleted;
+  }
+
+  // Transitions tarpit state from kNone to kActive.
+  void SetTarpitActive() {
+    GRPC_DCHECK(tarpit_state_.load(std::memory_order_relaxed) ==
+                TarpitState::kNone);
+    tarpit_state_.store(TarpitState::kActive, std::memory_order_relaxed);
+  }
+
+  // Transitions tarpit state from kActive to kCompleted.
+  void SetTarpitCompleted() {
+    GRPC_DCHECK(tarpit_state_.load(std::memory_order_relaxed) ==
+                TarpitState::kActive);
+    tarpit_state_.store(TarpitState::kCompleted, std::memory_order_relaxed);
+  }
 
   // Semantic state transitions
   void OnInitialMetadataSent() {
@@ -388,6 +428,7 @@ class Stream : public RefCounted<Stream> {
   }
 
   StreamStateChange OnInitiateReset(absl::Status status) {
+    GRPC_DCHECK(!status.ok());
     const StreamStateChange change = state_.OnInitiateReset();
     CancelCall(std::move(status));
     return change;
@@ -399,14 +440,14 @@ class Stream : public RefCounted<Stream> {
     return change;
   }
 
-  inline uint32_t GetStreamId() const { return stream_id_; }
+  uint32_t GetStreamId() const { return stream_id_; }
 
-  inline bool CanSendWindowUpdateFrames() const {
+  bool CanSendWindowUpdateFrames() const {
     return IsOpen() || IsHalfClosedLocal();
   }
 
-  inline Http2Status CanStreamReceiveDataFrames() const {
-    if (IsStreamHalfClosedRemote()) {
+  Http2Status CanStreamReceiveDataFrames() const {
+    if (IsClosedForReads()) {
       return Http2Status::Http2StreamError(
           Http2ErrorCode::kStreamClosed,
           std::string(RFC9113::kHalfClosedRemoteState));
@@ -497,7 +538,7 @@ class Stream : public RefCounted<Stream> {
   void InitializeStream(const bool allow_true_binary_metadata_peer) {
     GRPC_HTTP2_STREAM_LOG << "Stream::InitializeStream stream_id="
                           << stream_id_;
-    GRPC_DCHECK_GE(stream_id_, 0u);
+    GRPC_DCHECK_NE(stream_id_, kInvalidStreamId);
     data_queue_->SetStreamId(stream_id_, allow_true_binary_metadata_peer);
   }
 
@@ -517,11 +558,12 @@ class Stream : public RefCounted<Stream> {
   }
 
   StreamState state_;
-  uint32_t stream_id_;
-  bool did_receive_initial_metadata_;
-  bool did_receive_trailing_metadata_;
-  bool did_push_server_trailing_metadata_;
-  bool did_cancel_;
+  uint32_t stream_id_ = kInvalidStreamId;
+  bool did_receive_initial_metadata_ = false;
+  bool did_receive_trailing_metadata_ = false;
+  bool did_push_server_trailing_metadata_ = false;
+  bool did_cancel_ = false;
+  std::atomic<TarpitState> tarpit_state_{TarpitState::kNone};
   // Change this if ClientMetadataHandle and ServerMetadataHandle are changed
   // to different types.
   RefCountedPtr<StreamDataQueue<Arena::PoolPtr<grpc_metadata_batch>>>

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

@@ -105,9 +105,6 @@ static grpc_core::Duration NextAllowedPingInterval(grpc_chttp2_transport* t) {
     // The gRPC keepalive spec doesn't call for any throttling on the server
     // side, but we are adding some throttling for protection anyway, unless
     // we are doing a graceful GOAWAY in which case we don't want to wait.
-    if (grpc_core::IsMultipingEnabled()) {
-      return grpc_core::Duration::Seconds(1);
-    }
     return t->keepalive_time == grpc_core::Duration::Infinity()
                ? grpc_core::Duration::Seconds(20)
                : t->keepalive_time / 2;

data/src/core/ext/transport/inproc/inproc_transport.cc

@@ -252,11 +252,7 @@ InprocServerTransport::MakeClientTransport() {
 RefCountedPtr<Channel> MakeLameChannel(absl::string_view why,
                                        absl::Status error) {
   LOG(ERROR) << why << ": " << error.message();
-  intptr_t integer;
-  grpc_status_code status = GRPC_STATUS_INTERNAL;
-  if (grpc_error_get_int(error, StatusIntProperty::kRpcStatus, &integer)) {
-    status = static_cast<grpc_status_code>(integer);
-  }
+  grpc_status_code status = static_cast<grpc_status_code>(error.code());
   return RefCountedPtr<Channel>(Channel::FromC(grpc_lame_client_channel_create(
       nullptr, status, std::string(why).c_str())));
 }

data/src/core/ext/transport/inproc/legacy_inproc_transport.cc

@@ -1156,11 +1156,8 @@ void close_transport_locked(inproc_transport* t) {
     // Also end all streams on this transport
     while (t->stream_list != nullptr) {
       // cancel_stream_locked also adjusts stream list
-      cancel_stream_locked(
-          t->stream_list,
-          grpc_error_set_int(GRPC_ERROR_CREATE("Transport closed"),
-                             grpc_core::StatusIntProperty::kRpcStatus,
-                             GRPC_STATUS_UNAVAILABLE));
+      cancel_stream_locked(t->stream_list,
+                           absl::UnavailableError("Transport closed"));
     }
   }
 }
@@ -1295,12 +1292,7 @@ grpc_channel* grpc_legacy_inproc_channel_create(grpc_server* server,
       GRPC_CHECK(!channel);
       LOG(ERROR) << "Failed to create client channel: "
                  << grpc_core::StatusToString(error);
-      intptr_t integer;
-      grpc_status_code status = GRPC_STATUS_INTERNAL;
-      if (grpc_error_get_int(error, grpc_core::StatusIntProperty::kRpcStatus,
-                             &integer)) {
-        status = static_cast<grpc_status_code>(integer);
-      }
+      grpc_status_code status = static_cast<grpc_status_code>(error.code());
       // client_transport was destroyed when grpc_channel_create_internal saw an
       // error.
       server_transport->Orphan();
@@ -1313,12 +1305,7 @@ grpc_channel* grpc_legacy_inproc_channel_create(grpc_server* server,
     GRPC_CHECK(!channel);
     LOG(ERROR) << "Failed to create server channel: "
                << grpc_core::StatusToString(error);
-    intptr_t integer;
-    grpc_status_code status = GRPC_STATUS_INTERNAL;
-    if (grpc_error_get_int(error, grpc_core::StatusIntProperty::kRpcStatus,
-                           &integer)) {
-      status = static_cast<grpc_status_code>(integer);
-    }
+    grpc_status_code status = static_cast<grpc_status_code>(error.code());
     client_transport->Orphan();
     server_transport->Orphan();
     channel = grpc_lame_client_channel_create(