grpc 1.83.0 → 1.84.0.pre1

data/src/core/lib/channel/promise_based_filter.cc

@@ -19,6 +19,7 @@
 
 #include <algorithm>
 #include <memory>
+#include <optional>
 #include <string>
 #include <utility>
 #include <vector>
@@ -74,10 +75,8 @@ absl::Status StatusFromMetadata(const ServerMetadata& md) {
     return absl::OkStatus();
   }
   const auto* message = md.get_pointer(GrpcMessageMetadata());
-  return grpc_error_set_int(
-      absl::Status(static_cast<absl::StatusCode>(status_code),
-                   message == nullptr ? "" : message->as_string_view()),
-      StatusIntProperty::kRpcStatus, status_code);
+  return absl::Status(static_cast<absl::StatusCode>(status_code),
+                      message == nullptr ? "" : message->as_string_view());
 }
 }  // namespace
 
@@ -831,7 +830,8 @@ void BaseCallData::ReceiveMessage::OnComplete(absl::Status status) {
 }
 
 void BaseCallData::ReceiveMessage::Done(const ServerMetadata& metadata,
-                                        Flusher* flusher) {
+                                        Flusher* flusher,
+                                        bool discard_buffered_message) {
   GRPC_TRACE_LOG(channel, INFO)
       << base_->LogTag() << " ReceiveMessage.Done st=" << StateString(state_)
       << " md=" << metadata.DebugString();
@@ -849,16 +849,36 @@ void BaseCallData::ReceiveMessage::Done(const ServerMetadata& metadata,
       state_ = State::kCancelledWhilstForwardingNoPipe;
       break;
     case State::kCompletedWhileBatchCompleted:
-    case State::kBatchCompleted:
-      state_ = State::kCompletedWhileBatchCompleted;
-      break;
+    case State::kBatchCompleted: {
+      if (IsRecvMessageFilterBypassFixEnabled() && discard_buffered_message) {
+        state_ = State::kBatchCompletedButCancelled;
+        // Store the cancellation status so that WakeInsideCombiner() can
+        // propagate it to the application's message ready callback instead of
+        // defaulting to OK.
+        completed_status_ = StatusFromMetadata(metadata);
+        // Drop the buffered message here so it cannot bypass the trailing
+        // metadata; WakeInsideCombiner() just fires the completion.
+        if (intercepted_slice_buffer_ != nullptr) {
+          *intercepted_slice_buffer_ = std::nullopt;
+        }
+      } else {
+        state_ = State::kCompletedWhileBatchCompleted;
+      }
+    } break;
     case State::kCompletedWhilePulledFromPipe:
     case State::kCompletedWhilePushedToPipe:
     case State::kPulledFromPipe:
     case State::kPushedToPipe: {
-      auto status_code =
-          metadata.get(GrpcStatusMetadata()).value_or(GRPC_STATUS_UNKNOWN);
-      if (status_code == GRPC_STATUS_OK) {
+      // Discard the buffered message only when the call is being torn down
+      // (short-circuit / cancellation / server-initiated non-OK);
+      // With the feature disabled, fall back to keying the discard off a
+      // non-OK trailing status.
+      bool discard =
+          IsRecvMessageFilterBypassFixEnabled()
+              ? discard_buffered_message
+              : metadata.get(GrpcStatusMetadata())
+                        .value_or(GRPC_STATUS_UNKNOWN) != GRPC_STATUS_OK;
+      if (!discard) {
         if (state_ == State::kCompletedWhilePulledFromPipe ||
             state_ == State::kPulledFromPipe) {
           state_ = State::kCompletedWhilePulledFromPipe;
@@ -868,12 +888,31 @@ void BaseCallData::ReceiveMessage::Done(const ServerMetadata& metadata,
       } else {
         push_.reset();
         next_.reset();
-        flusher->AddClosure(intercepted_on_complete_,
-                            StatusFromMetadata(metadata), "recv_message_done");
+        if (IsRecvMessageFilterBypassFixEnabled()) {
+          completed_status_ = StatusFromMetadata(metadata);
+          if (intercepted_slice_buffer_ != nullptr) {
+            *intercepted_slice_buffer_ = std::nullopt;
+          }
+        } else {
+          completed_status_ = StatusFromMetadata(metadata);
+        }
+        flusher->AddClosure(intercepted_on_complete_, completed_status_,
+                            "recv_message_done");
         state_ = State::kCancelled;
       }
     } break;
     case State::kBatchCompletedNoPipe:
+      if (IsRecvMessageFilterBypassFixEnabled() && discard_buffered_message) {
+        // Store the cancellation status so that WakeInsideCombiner() can
+        // propagate it to the application's message ready callback instead of
+        // defaulting to OK.
+        completed_status_ = StatusFromMetadata(metadata);
+        // Drop the buffered message here so it cannot bypass the trailing
+        // metadata; WakeInsideCombiner() just fires the completion.
+        if (intercepted_slice_buffer_ != nullptr) {
+          *intercepted_slice_buffer_ = std::nullopt;
+        }
+      }
       state_ = State::kBatchCompletedButCancelledNoPipe;
       break;
     case State::kBatchCompletedButCancelled:
@@ -887,6 +926,18 @@ void BaseCallData::ReceiveMessage::Done(const ServerMetadata& metadata,
   }
 }
 
+bool BaseCallData::ReceiveMessage::IsIdle() const {
+  switch (state_) {
+    case State::kInitial:
+    case State::kIdle:
+    case State::kCancelled:
+    case State::kCancelledWhilstIdle:
+      return true;
+    default:
+      return false;
+  }
+}
+
 void BaseCallData::ReceiveMessage::WakeInsideCombiner(Flusher* flusher,
                                                       bool allow_push_to_pipe) {
   GRPC_TRACE_LOG(channel, INFO)
@@ -910,7 +961,6 @@ void BaseCallData::ReceiveMessage::WakeInsideCombiner(Flusher* flusher,
       state_ = State::kCancelled;
       break;
     case State::kBatchCompletedButCancelled:
-    case State::kCompletedWhileBatchCompleted:
       interceptor()->Push()->Close();
       state_ = State::kCancelled;
       flusher->AddClosure(std::exchange(intercepted_on_complete_, nullptr),
@@ -921,6 +971,16 @@ void BaseCallData::ReceiveMessage::WakeInsideCombiner(Flusher* flusher,
       flusher->AddClosure(std::exchange(intercepted_on_complete_, nullptr),
                           completed_status_, "recv_message");
       break;
+    case State::kCompletedWhileBatchCompleted:
+      if (!IsRecvMessageFilterBypassFixEnabled()) {
+        // existing behavior
+        interceptor()->Push()->Close();
+        state_ = State::kCancelled;
+        flusher->AddClosure(std::exchange(intercepted_on_complete_, nullptr),
+                            completed_status_, "recv_message");
+        break;
+      }
+      [[fallthrough]];
     case State::kBatchCompleted:
       if (completed_status_.ok() && intercepted_slice_buffer_->has_value()) {
         if (!allow_push_to_pipe) break;
@@ -1122,6 +1182,14 @@ class ClientCallData::PollContext {
           flusher_, self_->recv_initial_metadata_ == nullptr
                         ? true
                         : self_->recv_initial_metadata_->AllowRecvMessage());
+      if (self_->recv_trailing_state_ ==
+              RecvTrailingState::kCompletedQueuedBehindReceiveMessage &&
+          self_->receive_message()->IsIdle()) {
+        // Now that the receive message pump is idle (finished processing all
+        // in-flight messages), we can finally release the trailing metadata.
+        self_->recv_trailing_state_ = RecvTrailingState::kComplete;
+        repoll_ = true;
+      }
     }
     if (self_->server_initial_metadata_pipe() != nullptr) {
       if (self_->recv_initial_metadata_->metadata_push_.has_value()) {
@@ -1208,7 +1276,34 @@ class ClientCallData::PollContext {
             self_->send_message()->Done(*md, flusher_);
           }
           if (self_->receive_message() != nullptr) {
-            self_->receive_message()->Done(*md, flusher_);
+            if (IsRecvMessageFilterBypassFixEnabled()) {
+              // The promise produced its own terminal metadata while a
+              // message was still in flight: the call is being
+              // short-circuited, so that message is discarded rather than
+              // delivered.
+              self_->receive_message()->Done(*md, flusher_,
+                                             /*discard_buffered_message=*/true);
+              // Done() defers the completion closure to WakeInsideCombiner,
+              // which already ran this poll. If the pump isn't idle, repoll to
+              // drain it, else the call stalls.
+              if (!self_->receive_message()->IsIdle()) {
+                repoll_ = true;
+              }
+              // The promise terminated with its own (error) metadata while the
+              // transport's trailing metadata was queued behind the receive
+              // message pump. The buffered message was discarded above; since
+              // receive_message()->IsIdle() will not become true until the
+              // pending message completion callbacks execute, immediately
+              // promote the queued trailing metadata to kComplete so the
+              // synchronous handling below picks it up within this polling
+              // pass.
+              if (self_->recv_trailing_state_ ==
+                  RecvTrailingState::kCompletedQueuedBehindReceiveMessage) {
+                self_->recv_trailing_state_ = RecvTrailingState::kComplete;
+              }
+            } else {
+              self_->receive_message()->Done(*md, flusher_);
+            }
           }
           if (self_->recv_trailing_state_ == RecvTrailingState::kComplete) {
             if (self_->recv_trailing_metadata_ != md.get()) {
@@ -1438,6 +1533,8 @@ const char* ClientCallData::StateString(RecvTrailingState state) {
       return "INITIAL";
     case RecvTrailingState::kQueued:
       return "QUEUED";
+    case RecvTrailingState::kCompletedQueuedBehindReceiveMessage:
+      return "QUEUED_BEHIND_RECEIVE_MESSAGE";
     case RecvTrailingState::kComplete:
       return "COMPLETE";
     case RecvTrailingState::kForwarded:
@@ -1645,7 +1742,8 @@ void ClientCallData::Cancel(grpc_error_handle error, Flusher* flusher) {
     send_message()->Done(*ServerMetadataFromStatus(error), flusher);
   }
   if (receive_message() != nullptr) {
-    receive_message()->Done(*ServerMetadataFromStatus(error), flusher);
+    receive_message()->Done(*ServerMetadataFromStatus(error), flusher,
+                            /*discard_buffered_message=*/true);
   }
 }
 
@@ -1838,6 +1936,7 @@ Poll<ServerMetadataHandle> ClientCallData::PollTrailingMetadata() {
     case RecvTrailingState::kInitial:
     case RecvTrailingState::kQueued:
     case RecvTrailingState::kForwarded:
+    case RecvTrailingState::kCompletedQueuedBehindReceiveMessage:
       // No trailing metadata yet: we are pending.
       // We return that and expect the promise to be repolled later (if it's
       // not cancelled).
@@ -1892,9 +1991,19 @@ void ClientCallData::RecvTrailingMetadataReady(grpc_error_handle error) {
   }
   // Record that we've got the callback.
   GRPC_CHECK(recv_trailing_state_ == RecvTrailingState::kForwarded);
-  recv_trailing_state_ = RecvTrailingState::kComplete;
+  if (IsRecvMessageFilterBypassFixEnabled() && receive_message() != nullptr &&
+      !receive_message()->IsIdle()) {
+    // If the receive message pump is still active processing a message,
+    // queue the trailing metadata until the pump goes idle to avoid bypassing
+    // the message interceptors of filters higher in the stack.
+    recv_trailing_state_ =
+        RecvTrailingState::kCompletedQueuedBehindReceiveMessage;
+  } else {
+    recv_trailing_state_ = RecvTrailingState::kComplete;
+  }
   if (receive_message() != nullptr) {
-    receive_message()->Done(*recv_trailing_metadata_, &flusher);
+    receive_message()->Done(*recv_trailing_metadata_, &flusher,
+                            /*discard_buffered_message=*/!error.ok());
   }
   if (send_message() != nullptr) {
     send_message()->Done(*recv_trailing_metadata_, &flusher);
@@ -2208,13 +2317,15 @@ void ServerCallData::StartBatch(grpc_transport_stream_op_batch* b) {
     switch (send_trailing_state_) {
       case SendTrailingState::kInitial:
         send_trailing_metadata_batch_ = batch;
+        // Server ends the RPC non-OK, so the app is done reading: any buffered
+        // inbound (client->server) message has no consumer. Drop it.
         if (receive_message() != nullptr &&
             batch->payload->send_trailing_metadata.send_trailing_metadata
                     ->get(GrpcStatusMetadata())
                     .value_or(GRPC_STATUS_UNKNOWN) != GRPC_STATUS_OK) {
           receive_message()->Done(
               *batch->payload->send_trailing_metadata.send_trailing_metadata,
-              &flusher);
+              &flusher, /* discard_buffered_message */ true);
         }
         if (send_message() != nullptr && !send_message()->IsIdle()) {
           send_trailing_state_ = SendTrailingState::kQueuedBehindSendMessage;
@@ -2317,7 +2428,8 @@ void ServerCallData::Completed(grpc_error_handle error,
     send_message()->Done(*ServerMetadataFromStatus(error), flusher);
   }
   if (receive_message() != nullptr) {
-    receive_message()->Done(*ServerMetadataFromStatus(error), flusher);
+    receive_message()->Done(*ServerMetadataFromStatus(error), flusher,
+                            /* discard_buffered_message */ true);
   }
 }
 

data/src/core/lib/channel/promise_based_filter.h

@@ -1175,7 +1175,8 @@ MakeFilterCall(Derived* derived) {
 //   failure (in which case the call will be aborted).
 //   useful for cases where the exact metadata returned needs to be customized.
 // It's also acceptable to return a promise that resolves to the
-// relevant return type listed above.
+// relevant return type listed above (except for OnClientToServerHalfClose
+// and OnServerTrailingMetadata, which must be synchronous).
 // Finally, OnFinalize can be added to intercept call finalization.
 // It must have one of the signatures:
 // - static inline const NoInterceptor OnFinalize:
@@ -1239,10 +1240,18 @@ struct ArenaContextType<V3InterceptorToV2State> {
 // Note that this bridge does not support the full functionality of the
 // v3 interceptor API.  In particular, it assumes that the interceptor
 // will create exactly one child call.
+//
+// When not running in a v3 stack, the interceptor's Init() method will
+// not be called, but the wrapped destination will be set before the
+// ctor runs, so implementations must perform any necessary initialization
+// in their ctor instead.
 template <typename Derived>
 class V3InterceptorToV2Bridge : public ChannelFilter, public Interceptor {
  public:
-  V3InterceptorToV2Bridge() {
+  explicit V3InterceptorToV2Bridge(ChannelArgs args) {
+    // If running in a v3 stack, disable the bridge.  The interceptor
+    // will be used normally.
+    if (args.GetBool(GRPC_ARG_USE_V3_STACK).value_or(false)) return;
     // Insert CallDestinationToNextV2Filter as the wrapped destination in
     // Interceptor, so that we can route the server side of the
     // interceptor back into the v2 filter chain.
@@ -1486,12 +1495,28 @@ class V3InterceptorToV2Bridge : public ChannelFilter, public Interceptor {
                         call_args.client_initial_metadata = std::move(metadata);
                         return Seq(
                             next_promise_factory(std::move(call_args)),
-                            [handler](ServerMetadataHandle metadata) mutable
-                                -> Poll<ServerMetadataHandle> {
+                            [handler](ServerMetadataHandle metadata) mutable {
                               handler.SpawnPushServerTrailingMetadata(
                                   std::move(metadata));
+                              // We return a lambda (promise) here instead of
+                              // returning `Pending{}` directly to make this
+                              // step safe for subsequent polls. During V2 call
+                              // teardown, cancellation of active streams
+                              // propagates through the V2 filter stack, which
+                              // wakes up this activity and triggers re-polls of
+                              // the bridge promise. If we returned `Pending{}`
+                              // directly, this factory lambda would be
+                              // re-evaluated on every poll, causing duplicate
+                              // calls to `SpawnPushServerTrailingMetadata` and
+                              // attempting to move from the already-moved
+                              // `metadata` parameter (leading to
+                              // crashes/undefined behavior). Returning the
+                              // inner lambda ensures that the side-effects in
+                              // this factory run exactly once, and subsequent
+                              // polls only execute the trivial,
+                              // side-effect-free inner lambda.
                               // We always lose the race.
-                              return Pending{};
+                              return Never<ServerMetadataHandle>();
                             });
                       });
                 })),
@@ -1512,11 +1537,6 @@ class V3InterceptorToV2Bridge : public ChannelFilter, public Interceptor {
         });
   }
 
- protected:
-  RefCountedPtr<UnstartedCallDestination> wrapped_destination() const {
-    return wrapped_destination_;  // From Interceptor class.
-  }
-
  private:
   // A custom UnstartedCallDestination that starts the call and returns
   // the resulting handler via a latch obtained from call context.
@@ -1867,7 +1887,14 @@ class BaseCallData : public Activity,
     // work.
     void WakeInsideCombiner(Flusher* flusher, bool allow_push_to_pipe);
     // Call is completed, we have trailing metadata. Close things out.
-    void Done(const ServerMetadata& metadata, Flusher* flusher);
+    // discard_buffered_message: the call is being torn down (the promise
+    // produced its own terminal metadata, an out-of-band cancellation, or a
+    // server-initiated non-OK termination) and the receiver has stopped
+    // reading, so drop any message buffered here instead of delivering it up
+    // the stack.
+    void Done(const ServerMetadata& metadata, Flusher* flusher,
+              bool discard_buffered_message = false);
+    bool IsIdle() const;
 
     channelz::PropertyList ChannelzProperties() {
       return channelz::PropertyList().Set("state", StateString(state_));
@@ -2026,6 +2053,9 @@ class ClientCallData : public BaseCallData {
     kQueued,
     // We've forwarded the op to the next filter.
     kForwarded,
+    // Trailing metadata is received, but we queue it until the in-progress
+    // receive message operation finishes.
+    kCompletedQueuedBehindReceiveMessage,
     // The op has completed from below, but we haven't yet forwarded it up
     // (the promise gets to interject and mutate it).
     kComplete,
@@ -2324,7 +2354,7 @@ struct ChannelFilterWithFlagsMethods {
                                       args->config));
     if (!status.ok()) {
       new (elem->channel_data) F*(nullptr);
-      return absl_status_to_grpc_error(status.status());
+      return status.status();
     }
     new (elem->channel_data) F*(status->release());
     return absl::OkStatus();

data/src/core/lib/compression/compression_internal.cc

@@ -250,15 +250,14 @@ grpc_compression_options CompressionOptionsFromChannelArgs(
             Clamp(*default_level, static_cast<int>(GRPC_COMPRESS_LEVEL_NONE),
                   static_cast<int>(GRPC_COMPRESS_LEVEL_COUNT - 1)));
   }
-  auto default_algorithm =
+  std::optional<int> default_algorithm =
       args.GetInt(GRPC_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM);
   if (default_algorithm.has_value()) {
     compression_options.default_algorithm.is_set = true;
     compression_options.default_algorithm.algorithm =
-        Clamp(static_cast<grpc_compression_algorithm>(*default_algorithm),
-              GRPC_COMPRESS_NONE,
-              static_cast<grpc_compression_algorithm>(
-                  GRPC_COMPRESS_ALGORITHMS_COUNT - 1));
+        static_cast<grpc_compression_algorithm>(
+            Clamp(*default_algorithm, static_cast<int>(GRPC_COMPRESS_NONE),
+                  static_cast<int>(GRPC_COMPRESS_ALGORITHMS_COUNT - 1)));
   }
   auto enabled_algorithms_bitset =
       args.GetInt(GRPC_COMPRESSION_CHANNEL_ENABLED_ALGORITHMS_BITSET);