grpc 1.65.2 → 1.66.0.pre3

data/src/core/lib/transport/call_spine.cc

@@ -14,91 +14,118 @@
 
 #include "src/core/lib/transport/call_spine.h"
 
+#include "absl/functional/any_invocable.h"
+
 #include <grpc/support/port_platform.h>
 
+#include "src/core/lib/event_engine/event_engine_context.h"
 #include "src/core/lib/promise/for_each.h"
 #include "src/core/lib/promise/try_seq.h"
 
 namespace grpc_core {
 
-void ForwardCall(CallHandler call_handler, CallInitiator call_initiator) {
+void ForwardCall(CallHandler call_handler, CallInitiator call_initiator,
+                 absl::AnyInvocable<void(ServerMetadata&)>
+                     on_server_trailing_metadata_from_initiator) {
   // Read messages from handler into initiator.
-  call_handler.SpawnGuarded("read_messages", [call_handler,
-                                              call_initiator]() mutable {
-    return Seq(ForEach(OutgoingMessages(call_handler),
-                       [call_initiator](MessageHandle msg) mutable {
-                         // Need to spawn a job into the initiator's activity to
-                         // push the message in.
-                         return call_initiator.SpawnWaitable(
-                             "send_message",
-                             [msg = std::move(msg), call_initiator]() mutable {
-                               return call_initiator.CancelIfFails(
-                                   call_initiator.PushMessage(std::move(msg)));
-                             });
-                       }),
-               [call_initiator](StatusFlag result) mutable {
-                 if (result.ok()) {
-                   call_initiator.SpawnInfallible(
-                       "finish-downstream-ok", [call_initiator]() mutable {
-                         call_initiator.FinishSends();
-                         return Empty{};
-                       });
-                 } else {
-                   call_initiator.SpawnInfallible("finish-downstream-fail",
-                                                  [call_initiator]() mutable {
-                                                    call_initiator.Cancel();
-                                                    return Empty{};
-                                                  });
-                 }
-                 return result;
-               });
-  });
-  call_initiator.SpawnInfallible("read_the_things", [call_initiator,
-                                                     call_handler]() mutable {
-    return Seq(
-        call_initiator.CancelIfFails(TrySeq(
-            call_initiator.PullServerInitialMetadata(),
+  call_handler.SpawnInfallible(
+      "read_messages", [call_handler, call_initiator]() mutable {
+        return Seq(
+            ForEach(OutgoingMessages(call_handler),
+                    [call_initiator](MessageHandle msg) mutable {
+                      // Need to spawn a job into the initiator's activity to
+                      // push the message in.
+                      return call_initiator.SpawnWaitable(
+                          "send_message",
+                          [msg = std::move(msg), call_initiator]() mutable {
+                            return call_initiator.PushMessage(std::move(msg));
+                          });
+                    }),
+            [call_initiator](StatusFlag result) mutable {
+              if (result.ok()) {
+                call_initiator.SpawnInfallible("finish-downstream-ok",
+                                               [call_initiator]() mutable {
+                                                 call_initiator.FinishSends();
+                                                 return Empty{};
+                                               });
+              }
+              return Empty{};
+            });
+      });
+  call_handler.SpawnInfallible(
+      "check_cancellation", [call_handler, call_initiator]() mutable {
+        return Map(call_handler.WasCancelled(), [call_initiator =
+                                                     std::move(call_initiator)](
+                                                    bool cancelled) mutable {
+          if (cancelled) {
+            call_initiator.SpawnInfallible("propagate_handler_cancel",
+                                           [call_initiator]() mutable {
+                                             call_initiator.Cancel();
+                                             return Empty();
+                                           });
+          }
+          return Empty();
+        });
+      });
+  call_initiator.SpawnInfallible(
+      "read_the_things",
+      [call_initiator, call_handler,
+       on_server_trailing_metadata_from_initiator =
+           std::move(on_server_trailing_metadata_from_initiator)]() mutable {
+        return Seq(
+            call_initiator.CancelIfFails(TrySeq(
+                call_initiator.PullServerInitialMetadata(),
+                [call_handler, call_initiator](
+                    absl::optional<ServerMetadataHandle> md) mutable {
+                  const bool has_md = md.has_value();
+                  return If(
+                      has_md,
+                      [&call_handler, &call_initiator,
+                       md = std::move(md)]() mutable {
+                        call_handler.SpawnGuarded(
+                            "recv_initial_metadata",
+                            [md = std::move(*md), call_handler]() mutable {
+                              return call_handler.PushServerInitialMetadata(
+                                  std::move(md));
+                            });
+                        return ForEach(
+                            OutgoingMessages(call_initiator),
+                            [call_handler](MessageHandle msg) mutable {
+                              return call_handler.SpawnWaitable(
+                                  "recv_message", [msg = std::move(msg),
+                                                   call_handler]() mutable {
+                                    return call_handler.CancelIfFails(
+                                        call_handler.PushMessage(
+                                            std::move(msg)));
+                                  });
+                            });
+                      },
+                      []() -> StatusFlag { return Success{}; });
+                })),
+            call_initiator.PullServerTrailingMetadata(),
             [call_handler,
-             call_initiator](absl::optional<ServerMetadataHandle> md) mutable {
-              const bool has_md = md.has_value();
-              call_handler.SpawnGuarded(
-                  "recv_initial_metadata",
-                  [md = std::move(md), call_handler]() mutable {
-                    return call_handler.PushServerInitialMetadata(
-                        std::move(md));
+             on_server_trailing_metadata_from_initiator =
+                 std::move(on_server_trailing_metadata_from_initiator)](
+                ServerMetadataHandle md) mutable {
+              on_server_trailing_metadata_from_initiator(*md);
+              call_handler.SpawnInfallible(
+                  "recv_trailing",
+                  [call_handler, md = std::move(md)]() mutable {
+                    call_handler.PushServerTrailingMetadata(std::move(md));
+                    return Empty{};
                   });
-              return If(
-                  has_md,
-                  ForEach(OutgoingMessages(call_initiator),
-                          [call_handler](MessageHandle msg) mutable {
-                            return call_handler.SpawnWaitable(
-                                "recv_message",
-                                [msg = std::move(msg), call_handler]() mutable {
-                                  return call_handler.CancelIfFails(
-                                      call_handler.PushMessage(std::move(msg)));
-                                });
-                          }),
-                  []() -> StatusFlag { return Success{}; });
-            })),
-        call_initiator.PullServerTrailingMetadata(),
-        [call_handler](ServerMetadataHandle md) mutable {
-          call_handler.SpawnInfallible(
-              "recv_trailing", [call_handler, md = std::move(md)]() mutable {
-                call_handler.PushServerTrailingMetadata(std::move(md));
-                return Empty{};
-              });
-          return Empty{};
-        });
-  });
+              return Empty{};
+            });
+      });
 }
 
 CallInitiatorAndHandler MakeCallPair(
-    ClientMetadataHandle client_initial_metadata,
-    grpc_event_engine::experimental::EventEngine* event_engine,
-    RefCountedPtr<Arena> arena) {
-  CHECK_NE(arena.get(), nullptr);
-  auto spine = CallSpine::Create(std::move(client_initial_metadata),
-                                 event_engine, std::move(arena));
+    ClientMetadataHandle client_initial_metadata, RefCountedPtr<Arena> arena) {
+  DCHECK_NE(arena.get(), nullptr);
+  DCHECK_NE(arena->GetContext<grpc_event_engine::experimental::EventEngine>(),
+            nullptr);
+  auto spine =
+      CallSpine::Create(std::move(client_initial_metadata), std::move(arena));
   return {CallInitiator(spine), UnstartedCallHandler(spine)};
 }
 

data/src/core/lib/transport/call_spine.h

@@ -45,17 +45,15 @@ class CallSpine final : public Party {
  public:
   static RefCountedPtr<CallSpine> Create(
       ClientMetadataHandle client_initial_metadata,
-      grpc_event_engine::experimental::EventEngine* event_engine,
       RefCountedPtr<Arena> arena) {
     Arena* arena_ptr = arena.get();
     return RefCountedPtr<CallSpine>(arena_ptr->New<CallSpine>(
-        std::move(client_initial_metadata), event_engine, std::move(arena)));
+        std::move(client_initial_metadata), std::move(arena)));
   }
 
   ~CallSpine() override {}
 
   CallFilters& call_filters() { return call_filters_; }
-  Arena* arena() { return arena_.get(); }
 
   // Add a callback to be called when server trailing metadata is received.
   void OnDone(absl::AnyInvocable<void()> fn) {
@@ -106,17 +104,8 @@ class CallSpine final : public Party {
     return call_filters().PullClientInitialMetadata();
   }
 
-  auto PushServerInitialMetadata(absl::optional<ServerMetadataHandle> md) {
-    bool has_md = md.has_value();
-    return If(
-        has_md,
-        [this, md = std::move(md)]() mutable {
-          return call_filters().PushServerInitialMetadata(std::move(*md));
-        },
-        [this]() {
-          call_filters().NoServerInitialMetadata();
-          return Immediate<StatusFlag>(Success{});
-        });
+  StatusFlag PushServerInitialMetadata(ServerMetadataHandle md) {
+    return call_filters().PushServerInitialMetadata(std::move(md));
   }
 
   auto WasCancelled() { return call_filters().WasCancelled(); }
@@ -125,10 +114,6 @@ class CallSpine final : public Party {
     return *call_filters().unprocessed_client_initial_metadata();
   }
 
-  grpc_event_engine::experimental::EventEngine* event_engine() const override {
-    return event_engine_;
-  }
-
   // Wrap a promise so that if it returns failure it automatically cancels
   // the rest of the call.
   // The resulting (returned) promise will resolve to Empty.
@@ -139,7 +124,9 @@ class CallSpine final : public Party {
     using ResultType = typename P::Result;
     return Map(std::move(promise), [this](ResultType r) {
       if (!IsStatusOk(r)) {
-        PushServerTrailingMetadata(StatusCast<ServerMetadataHandle>(r));
+        auto md = StatusCast<ServerMetadataHandle>(r);
+        md->Set(GrpcCallWasCancelled(), true);
+        PushServerTrailingMetadata(std::move(md));
       }
       return r;
     });
@@ -197,45 +184,12 @@ class CallSpine final : public Party {
  private:
   friend class Arena;
   CallSpine(ClientMetadataHandle client_initial_metadata,
-            grpc_event_engine::experimental::EventEngine* event_engine,
             RefCountedPtr<Arena> arena)
-      : Party(1),
-        arena_(std::move(arena)),
-        call_filters_(std::move(client_initial_metadata)),
-        event_engine_(event_engine) {}
-
-  class ScopedContext : public ScopedActivity,
-                        public promise_detail::Context<Arena>,
-                        public promise_detail::Context<
-                            grpc_event_engine::experimental::EventEngine> {
-   public:
-    explicit ScopedContext(CallSpine* spine)
-        : ScopedActivity(spine),
-          Context<Arena>(spine->arena_.get()),
-          Context<grpc_event_engine::experimental::EventEngine>(
-              spine->event_engine()) {}
-  };
-
-  bool RunParty() override {
-    ScopedContext context(this);
-    return Party::RunParty();
-  }
-
-  void PartyOver() override {
-    auto arena = arena_;
-    {
-      ScopedContext context(this);
-      CancelRemainingParticipants();
-      arena->DestroyManagedNewObjects();
-    }
-    this->~CallSpine();
-  }
+      : Party(std::move(arena)),
+        call_filters_(std::move(client_initial_metadata)) {}
 
-  const RefCountedPtr<Arena> arena_;
   // Call filters/pipes part of the spine
   CallFilters call_filters_;
-  // Event engine associated with this call
-  grpc_event_engine::experimental::EventEngine* const event_engine_;
   absl::AnyInvocable<void()> on_done_{nullptr};
 };
 
@@ -297,10 +251,7 @@ class CallInitiator {
   }
 
   Arena* arena() { return spine_->arena(); }
-
-  grpc_event_engine::experimental::EventEngine* event_engine() const {
-    return spine_->event_engine();
-  }
+  Party* party() { return spine_.get(); }
 
  private:
   RefCountedPtr<CallSpine> spine_;
@@ -315,7 +266,7 @@ class CallHandler {
     return spine_->PullClientInitialMetadata();
   }
 
-  auto PushServerInitialMetadata(absl::optional<ServerMetadataHandle> md) {
+  auto PushServerInitialMetadata(ServerMetadataHandle md) {
     return spine_->PushServerInitialMetadata(std::move(md));
   }
 
@@ -361,10 +312,7 @@ class CallHandler {
   }
 
   Arena* arena() { return spine_->arena(); }
-
-  grpc_event_engine::experimental::EventEngine* event_engine() const {
-    return spine_->event_engine();
-  }
+  Party* party() { return spine_.get(); }
 
  private:
   RefCountedPtr<CallSpine> spine_;
@@ -412,14 +360,12 @@ class UnstartedCallHandler {
     return spine_->UnprocessedClientInitialMetadata();
   }
 
-  // Helper for the very common situation in tests where we want to start a call
-  // with an empty filter stack.
-  CallHandler StartWithEmptyFilterStack() {
-    return StartCall(CallFilters::StackBuilder().Build());
+  void AddCallStack(RefCountedPtr<CallFilters::Stack> call_filters) {
+    spine_->call_filters().AddStack(std::move(call_filters));
   }
 
-  CallHandler StartCall(RefCountedPtr<CallFilters::Stack> call_filters) {
-    spine_->call_filters().SetStack(std::move(call_filters));
+  CallHandler StartCall() {
+    spine_->call_filters().Start();
     return CallHandler(std::move(spine_));
   }
 
@@ -435,9 +381,7 @@ struct CallInitiatorAndHandler {
 };
 
 CallInitiatorAndHandler MakeCallPair(
-    ClientMetadataHandle client_initial_metadata,
-    grpc_event_engine::experimental::EventEngine* event_engine,
-    RefCountedPtr<Arena> arena);
+    ClientMetadataHandle client_initial_metadata, RefCountedPtr<Arena> arena);
 
 template <typename CallHalf>
 auto OutgoingMessages(CallHalf h) {
@@ -450,7 +394,13 @@ auto OutgoingMessages(CallHalf h) {
 
 // Forward a call from `call_handler` to `call_initiator` (with initial metadata
 // `client_initial_metadata`)
-void ForwardCall(CallHandler call_handler, CallInitiator call_initiator);
+// `on_server_trailing_metadata_from_initiator` is a callback that will be
+// called with the server trailing metadata received by the initiator, and can
+// be used to mutate that metadata if desired.
+void ForwardCall(
+    CallHandler call_handler, CallInitiator call_initiator,
+    absl::AnyInvocable<void(ServerMetadata&)>
+        on_server_trailing_metadata_from_initiator = [](ServerMetadata&) {});
 
 }  // namespace grpc_core
 

data/src/core/lib/transport/call_state.cc

@@ -0,0 +1,39 @@
+// Copyright 2024 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.
+
+#include "src/core/lib/transport/call_state.h"
+
+namespace grpc_core {
+
+std::string CallState::DebugString() const {
+  return absl::StrCat(
+      "client_to_server_pull_state:", client_to_server_pull_state_,
+      " client_to_server_push_state:", client_to_server_push_state_,
+      " server_to_client_pull_state:", server_to_client_pull_state_,
+      " server_to_client_message_push_state:", server_to_client_push_state_,
+      " server_trailing_metadata_state:", server_trailing_metadata_state_,
+      client_to_server_push_waiter_.DebugString(),
+      " server_to_client_push_waiter:",
+      server_to_client_push_waiter_.DebugString(),
+      " client_to_server_pull_waiter:",
+      client_to_server_pull_waiter_.DebugString(),
+      " server_to_client_pull_waiter:",
+      server_to_client_pull_waiter_.DebugString(),
+      " server_trailing_metadata_waiter:",
+      server_trailing_metadata_waiter_.DebugString());
+}
+
+static_assert(sizeof(CallState) <= 16, "CallState too large");
+
+}  // namespace grpc_core