grpc 1.69.0 → 1.70.1

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

@@ -26,90 +26,55 @@ namespace grpc_core {
 void ForwardCall(CallHandler call_handler, CallInitiator call_initiator,
                  absl::AnyInvocable<void(ServerMetadata&)>
                      on_server_trailing_metadata_from_initiator) {
+  call_handler.AddChildCall(call_initiator);
   // Read messages from handler into initiator.
-  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();
-                                               });
-              }
-            });
-      });
-  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_handler.SpawnInfallible("read_messages", [call_handler,
+                                                 call_initiator]() mutable {
+    return Seq(ForEach(MessagesFrom(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.SpawnPushMessage(std::move(msg));
+                       }),
+               [call_initiator](StatusFlag result) mutable {
+                 if (result.ok()) {
+                   call_initiator.SpawnFinishSends();
+                 }
+               });
+  });
   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.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.SpawnPushServerInitialMetadata(
+                                   std::move(*md));
+                               return ForEach(
+                                   MessagesFrom(call_initiator),
+                                   [call_handler](MessageHandle msg) mutable {
+                                     return call_handler.SpawnPushMessage(
+                                         std::move(msg));
+                                   });
+                             },
+                             []() -> StatusFlag { return Success{}; });
+                       })),
             call_initiator.PullServerTrailingMetadata(),
             [call_handler,
              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));
-                  });
+              call_handler.SpawnPushServerTrailingMetadata(std::move(md));
             });
       });
 }

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

@@ -105,6 +105,8 @@ class CallSpine final : public Party {
   }
 
   void PushServerTrailingMetadata(ServerMetadataHandle md) {
+    GRPC_TRACE_LOG(call_state, INFO)
+        << "[call_state] PushServerTrailingMetadata: " << md->DebugString();
     call_filters().PushServerTrailingMetadata(std::move(md));
   }
 
@@ -133,15 +135,20 @@ class CallSpine final : public Party {
     using P = promise_detail::PromiseLike<Promise>;
     using ResultType = typename P::Result;
     return Map(std::move(promise), [this](ResultType r) {
-      if (!IsStatusOk(r)) {
-        auto md = StatusCast<ServerMetadataHandle>(r);
-        md->Set(GrpcCallWasCancelled(), true);
-        PushServerTrailingMetadata(std::move(md));
-      }
+      CancelIfFailed(r);
       return r;
     });
   }
 
+  template <typename StatusType>
+  void CancelIfFailed(const StatusType& r) {
+    if (!IsStatusOk(r)) {
+      Cancel();
+    }
+  }
+
+  void Cancel() { call_filters().Cancel(); }
+
   // Spawn a promise that returns Empty{} and save some boilerplate handling
   // that detail.
   template <typename PromiseFactory>
@@ -191,6 +198,75 @@ class CallSpine final : public Party {
     });
   }
 
+  // Spawned operations: these are callable from /outside/ the call; they spawn
+  // an operation into the call and execute that operation.
+
+  void SpawnPushServerInitialMetadata(ServerMetadataHandle md) {
+    SpawnInfallible(
+        "push-server-initial-metadata",
+        [md = std::move(md), self = RefAsSubclass<CallSpine>()]() mutable {
+          self->CancelIfFailed(self->PushServerInitialMetadata(std::move(md)));
+        });
+  }
+
+  auto SpawnPushServerToClientMessage(MessageHandle msg) {
+    return SpawnWaitable(
+        "push-message",
+        [msg = std::move(msg), self = RefAsSubclass<CallSpine>()]() mutable {
+          return self->CancelIfFails(
+              self->PushServerToClientMessage(std::move(msg)));
+        });
+  }
+
+  auto SpawnPushClientToServerMessage(MessageHandle msg) {
+    return SpawnWaitable(
+        "push-message",
+        [msg = std::move(msg), self = RefAsSubclass<CallSpine>()]() mutable {
+          return self->CancelIfFails(
+              self->PushClientToServerMessage(std::move(msg)));
+        });
+  }
+
+  void SpawnFinishSends() {
+    SpawnInfallible("finish-sends", [self = RefAsSubclass<CallSpine>()]() {
+      self->FinishSends();
+      return Empty{};
+    });
+  }
+
+  void SpawnPushServerTrailingMetadata(ServerMetadataHandle md) {
+    SpawnInfallible(
+        "push-server-trailing-metadata",
+        [md = std::move(md), self = RefAsSubclass<CallSpine>()]() mutable {
+          self->PushServerTrailingMetadata(std::move(md));
+          return Empty{};
+        });
+  }
+
+  void SpawnCancel() {
+    SpawnInfallible("cancel", [self = RefAsSubclass<CallSpine>()]() {
+      self->call_filters().Cancel();
+    });
+  }
+
+  void AddChildCall(RefCountedPtr<CallSpine> child_call) {
+    child_calls_.push_back(std::move(child_call));
+    if (child_calls_.size() == 1) {
+      SpawnInfallible(
+          "check_cancellation", [self = RefAsSubclass<CallSpine>()]() mutable {
+            auto was_completed =
+                self->call_filters().ServerTrailingMetadataWasPushed();
+            return Map(std::move(was_completed),
+                       [self = std::move(self)](Empty) {
+                         for (auto& child : self->child_calls_) {
+                           child->SpawnCancel();
+                         }
+                         return Empty{};
+                       });
+          });
+    }
+  }
+
  private:
   friend class Arena;
   CallSpine(ClientMetadataHandle client_initial_metadata,
@@ -201,8 +277,12 @@ class CallSpine final : public Party {
   // Call filters/pipes part of the spine
   CallFilters call_filters_;
   absl::AnyInvocable<void(bool)> on_done_{nullptr};
+  // Call spines that should be cancelled if this spine is cancelled
+  absl::InlinedVector<RefCountedPtr<CallSpine>, 3> child_calls_;
 };
 
+class CallHandler;
+
 class CallInitiator {
  public:
   using NextMessage = ServerToClientNextMessage;
@@ -224,21 +304,38 @@ class CallInitiator {
     return spine_->PushClientToServerMessage(std::move(message));
   }
 
+  auto SpawnPushMessage(MessageHandle message) {
+    return spine_->SpawnPushClientToServerMessage(std::move(message));
+  }
+
   void FinishSends() { spine_->FinishSends(); }
 
+  void SpawnFinishSends() { spine_->SpawnFinishSends(); }
+
   auto PullMessage() { return spine_->PullServerToClientMessage(); }
 
   auto PullServerTrailingMetadata() {
     return spine_->PullServerTrailingMetadata();
   }
 
-  void Cancel(absl::Status error = absl::CancelledError()) {
+  void Cancel(absl::Status error) {
     CHECK(!error.ok());
     auto status = ServerMetadataFromStatus(error);
     status->Set(GrpcCallWasCancelled(), true);
     spine_->PushServerTrailingMetadata(std::move(status));
   }
 
+  void SpawnCancel(absl::Status error) {
+    CHECK(!error.ok());
+    auto status = ServerMetadataFromStatus(error);
+    status->Set(GrpcCallWasCancelled(), true);
+    spine_->SpawnPushServerTrailingMetadata(std::move(status));
+  }
+
+  void Cancel() { spine_->Cancel(); }
+
+  void SpawnCancel() { spine_->SpawnCancel(); }
+
   GRPC_MUST_USE_RESULT bool OnDone(absl::AnyInvocable<void(bool)> fn) {
     return spine_->OnDone(std::move(fn));
   }
@@ -272,6 +369,7 @@ class CallInitiator {
   Party* party() { return spine_.get(); }
 
  private:
+  friend class CallHandler;
   RefCountedPtr<CallSpine> spine_;
 };
 
@@ -290,10 +388,18 @@ class CallHandler {
     return spine_->PushServerInitialMetadata(std::move(md));
   }
 
+  void SpawnPushServerInitialMetadata(ServerMetadataHandle md) {
+    return spine_->SpawnPushServerInitialMetadata(std::move(md));
+  }
+
   void PushServerTrailingMetadata(ServerMetadataHandle status) {
     spine_->PushServerTrailingMetadata(std::move(status));
   }
 
+  void SpawnPushServerTrailingMetadata(ServerMetadataHandle status) {
+    spine_->SpawnPushServerTrailingMetadata(std::move(status));
+  }
+
   GRPC_MUST_USE_RESULT bool OnDone(absl::AnyInvocable<void(bool)> fn) {
     return spine_->OnDone(std::move(fn));
   }
@@ -307,6 +413,10 @@ class CallHandler {
     return spine_->PushServerToClientMessage(std::move(message));
   }
 
+  auto SpawnPushMessage(MessageHandle message) {
+    return spine_->SpawnPushServerToClientMessage(std::move(message));
+  }
+
   auto PullMessage() { return spine_->PullClientToServerMessage(); }
 
   auto WasCancelled() { return spine_->WasCancelled(); }
@@ -337,6 +447,11 @@ class CallHandler {
     return spine_->SpawnWaitable(name, std::move(promise_factory));
   }
 
+  void AddChildCall(const CallInitiator& initiator) {
+    CHECK(initiator.spine_ != nullptr);
+    spine_->AddChildCall(initiator.spine_);
+  }
+
   Arena* arena() { return spine_->arena(); }
   Party* party() { return spine_.get(); }
 
@@ -412,7 +527,7 @@ CallInitiatorAndHandler MakeCallPair(
     ClientMetadataHandle client_initial_metadata, RefCountedPtr<Arena> arena);
 
 template <typename CallHalf>
-auto OutgoingMessages(CallHalf h) {
+auto MessagesFrom(CallHalf h) {
   struct Wrapper {
     CallHalf h;
     auto Next() { return h.PullMessage(); }
@@ -420,6 +535,15 @@ auto OutgoingMessages(CallHalf h) {
   return Wrapper{std::move(h)};
 }
 
+template <typename CallHalf>
+auto MessagesFrom(CallHalf* h) {
+  struct Wrapper {
+    CallHalf* h;
+    auto Next() { return h->PullMessage(); }
+  };
+  return Wrapper{h};
+}
+
 // Forward a call from `call_handler` to `call_initiator` (with initial metadata
 // `client_initial_metadata`)
 // `on_server_trailing_metadata_from_initiator` is a callback that will be