grpc 1.71.0 → 1.73.0

data/src/core/lib/promise/loop.h

@@ -60,14 +60,17 @@ namespace grpc_core {
 // {
 //   std::string execution_order;
 //   int i = 0;
-//   Poll<int> retval = Loop([&execution_order, &i]() -> LoopCtl<int> {
-//     absl::StrAppend(&execution_order, i);
-//     i++;
-//     if (i < 5) return Continue();
-//     return i;
+//   Poll<int> retval = Loop([&execution_order, &i]() {
+//       return [&execution_order, &i]() -> LoopCtl<int> {
+//           absl::StrAppend(&execution_order, i);
+//           i++;
+//           if (i < 5) return Continue();
+//           return i;
+//       };
 //   })();
 //   EXPECT_TRUE(retval.ready());
 //   EXPECT_EQ(retval.value(), 5);
+//   EXPECT_EQ(i, 5);
 //   EXPECT_STREQ(execution_order.c_str(), "01234");
 // }
 

data/src/core/lib/promise/map.h

@@ -102,8 +102,34 @@ class FusedFns {
 }  // namespace promise_detail
 
 // Mapping combinator.
-// Takes a promise, and a synchronous function to mutate its result, and
-// returns a promise.
+//
+// Input:
+// 1. The first argument is a promise.
+// 2. The second argument is a synchronous function.
+// 3. The synchronous function MUST be callable with the result type of the
+// promise.
+// 4. If the promise returns void, the synchronous function MUST be callable
+// with Empty.
+//
+// Return:
+// Mapping combinator returns Poll<T> where T is the return type of the
+// synchronous function.
+// Note: If the synchronous function returns void, the result type of the
+// mapping combinator will be Poll<Empty>.
+//
+// Polling the mapping combinator works as follows:
+// 1. Poll the promise.
+// 2. If the promise is pending, return Pending{}.
+// 3. If the promise is ready, return the result of the synchronous function.
+// Note: If the first argument to the Map is a promise factory instead of a
+// promise, Map will pass the promise returned by the promise factory as a
+// parameter to the synchronous function.
+//
+// Example:
+// TEST(MapTest, Works) {
+//   Promise<int> x = Map([]() { return 42; }, [](int i) { return i / 2; });
+//   EXPECT_THAT(x(), IsReady(21));
+// }
 template <typename Promise, typename Fn>
 class Map {
   using PromiseType = promise_detail::PromiseLike<Promise>;
@@ -251,6 +277,60 @@ auto AddErrorPrefix(absl::string_view prefix, Promise promise) {
   });
 }
 
+template <typename Gen, typename Promise>
+auto AddGeneratedErrorPrefix(Gen prefix, Promise promise) {
+  return MapErrors(std::move(promise), [prefix](absl::Status status) {
+    absl::Status out(status.code(), absl::StrCat(prefix(), status.message()));
+    status.ForEachPayload(
+        [&out](absl::string_view name, const absl::Cord& value) {
+          out.SetPayload(name, value);
+        });
+    return out;
+  });
+}
+
+// Input : A promise that resolves to Type T
+// Returns : A Map promise which contains the input promise and then discards
+// the return value of the input promise. the main use case for DiscardResult is
+// when you need to pass a promise as a parameter, and it returns a status or
+// some value which cannot be discarded. If this value is not used, the compiler
+// gives an error. DiscardResult helps to discard the return value of the
+// promise.
+template <typename Promise>
+auto DiscardResult(Promise promise) {
+  return Map(std::move(promise), [](auto) {});
+}
+
+// Given a promise, and N values, return a tuple with the resolved promise
+// first, and then the N values stapled to it.
+template <typename Promise, typename... Values>
+auto Staple(Promise promise, Values&&... values) {
+  return Map(std::move(promise), [values = std::tuple(std::forward<Values>(
+                                      values)...)](auto first_value) mutable {
+    return std::tuple_cat(std::tuple(std::move(first_value)),
+                          std::move(values));
+  });
+}
+
+// Same as Staple, but assumes a StatusOr<X>, and returns X, Values.
+template <typename Promise, typename... Values>
+auto TryStaple(Promise promise, Values&&... values) {
+  return Map(
+      std::move(promise),
+      [values = std::tuple(std::forward<std::remove_reference_t<Values>>(
+           values)...)](auto first_value) mutable
+          -> absl::StatusOr<
+              std::tuple<std::remove_reference_t<decltype(*first_value)>,
+                         std::remove_reference_t<Values>...>> {
+        using FirstValueType = std::remove_reference_t<decltype(*first_value)>;
+        if (!first_value.ok()) return first_value.status();
+        return absl::StatusOr<
+            std::tuple<FirstValueType, std::remove_reference_t<Values>...>>(
+            std::tuple_cat(std::tuple<FirstValueType>(std::move(*first_value)),
+                           std::move(values)));
+      });
+}
+
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_LIB_PROMISE_MAP_H

data/src/core/lib/promise/party.h

@@ -35,6 +35,7 @@
 #include "src/core/lib/promise/detail/promise_factory.h"
 #include "src/core/lib/promise/poll.h"
 #include "src/core/lib/resource_quota/arena.h"
+#include "src/core/util/check_class_size.h"
 #include "src/core/util/construct_destruct.h"
 #include "src/core/util/crash.h"
 #include "src/core/util/ref_counted.h"
@@ -305,7 +306,8 @@ class Party : public Activity, private Wakeable {
   // The party can poll the promise until it is resolved, or until the party is
   // shut down.
   // The on_complete callback will be called with the result of the
-  // promise if it completes.
+  // promise if it completes. Even if the promise returns a failed status,
+  // on_complete will be called.
   // promise_factory called to create the promise with the party lock taken;
   // after the promise is created the factory is destroyed. This means that
   // pointers or references to factory members will be invalidated after the
@@ -637,6 +639,8 @@ class Party : public Activity, private Wakeable {
   RefCountedPtr<Arena> arena_;
 };
 
+GRPC_CHECK_CLASS_SIZE(Party, 180);
+
 template <>
 struct ContextSubclass<Party> {
   using Base = Activity;

data/src/core/lib/promise/poll.h

@@ -23,6 +23,7 @@
 
 #include "absl/log/check.h"
 #include "absl/strings/str_format.h"
+#include "absl/strings/str_join.h"
 #include "src/core/util/construct_destruct.h"
 
 namespace grpc_core {
@@ -281,39 +282,40 @@ std::string PollToString(
 }
 
 template <typename Sink, typename T>
-void AbslStringify(Sink& sink, const Poll<T>& poll) {
-  if (poll.pending()) {
-    absl::Format(&sink, "<<pending>>");
+void PollValueStringify(Sink& sink, const T& value) {
+  absl::Format(&sink, "%v", value);
+}
+
+template <typename Sink, typename... Ts>
+void PollValueStringify(Sink& sink, const std::tuple<Ts...>& values) {
+  absl::Format(&sink, "(%v)", absl::StrJoin(values, ", "));
+}
+
+template <typename Sink, typename T>
+void PollValueStringify(Sink& sink, const std::optional<T>& value) {
+  if (!value.has_value()) {
+    sink.Append("nullopt");
     return;
   }
-  absl::Format(&sink, "%v", poll.value());
+  PollValueStringify(sink, *value);
 }
 
 template <typename Sink, typename T>
-void AbslStringify(Sink& sink, const Poll<absl::StatusOr<T>>& poll) {
-  if (poll.pending()) {
-    absl::Format(&sink, "<<pending>>");
+void PollValueStringify(Sink& sink, const absl::StatusOr<T>& value) {
+  if (!value.ok()) {
+    PollValueStringify(sink, value.status());
     return;
   }
-  if (poll.value().ok()) {
-    absl::Format(&sink, "%v", *poll.value());
-  } else {
-    absl::Format(&sink, "%v", poll.value().status());
-  }
+  PollValueStringify(sink, *value);
 }
 
 template <typename Sink, typename T>
-void AbslStringify(Sink& sink, const Poll<std::optional<T>>& poll) {
+void AbslStringify(Sink& sink, const Poll<T>& poll) {
   if (poll.pending()) {
     absl::Format(&sink, "<<pending>>");
     return;
   }
-  const auto& value = poll.value();
-  if (value.has_value()) {
-    absl::Format(&sink, "%v", value);
-  } else {
-    sink.append("nullopt");
-  }
+  PollValueStringify(sink, poll.value());
 }
 
 // Hack to get metadata printing
@@ -326,7 +328,7 @@ void AbslStringify(
   }
   const auto& value = poll.value();
   if (value.has_value()) {
-    absl::Format(&sink, "%v", *value);
+    PollValueStringify(sink, *value);
   } else {
     sink.Append("nullopt");
   }

data/src/core/lib/promise/promise.h

@@ -24,6 +24,8 @@
 #include "absl/status/status.h"
 #include "src/core/lib/promise/detail/promise_like.h"
 #include "src/core/lib/promise/poll.h"
+#include "src/core/util/function_signature.h"
+#include "src/core/util/json/json.h"
 
 namespace grpc_core {
 
@@ -83,12 +85,12 @@ struct ImmediateOkStatus {
 };
 
 // Typecheck that a promise returns the expected return type.
-// usage: auto promise = WithResult<int>([]() { return 3; });
+// usage: auto promise = AssertResultType<int>([]() { return 3; });
 // NOTE: there are tests in promise_test.cc that are commented out because they
 // should fail to compile. When modifying this code these should be uncommented
 // and their miscompilation verified.
 template <typename T, typename F>
-GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline auto WithResult(F f) ->
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline auto AssertResultType(F f) ->
     typename std::enable_if<std::is_same<decltype(f()), Poll<T>>::value,
                             F>::type {
   return f;

data/src/core/lib/promise/seq.h

@@ -108,6 +108,8 @@ class Seq {
     return state_.PollOnce();
   }
 
+  Json ToJson() const { return state_.ToJson("Seq"); }
+
  private:
   SeqState<SeqTraits, P, Fs...> state_;
 };

data/src/core/lib/promise/sleep.cc

@@ -37,9 +37,12 @@ Sleep::~Sleep() {
 }
 
 Poll<absl::Status> Sleep::operator()() {
-  // Invalidate now so that we see a fresh version of the time.
-  // TODO(ctiller): the following can be safely removed when we remove ExecCtx.
-  ExecCtx::Get()->InvalidateNow();
+  if (!IsSleepPromiseExecCtxRemovalEnabled()) {
+    // Invalidate now so that we see a fresh version of the time.
+    // TODO(ctiller): the following can be safely removed when we remove
+    // ExecCtx.
+    ExecCtx::Get()->InvalidateNow();
+  }
   const auto now = Timestamp::Now();
   // If the deadline is earlier than now we can just return.
   if (deadline_ <= now) return absl::OkStatus();

data/src/core/lib/promise/status_flag.h

@@ -24,6 +24,7 @@
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
+#include "absl/strings/str_join.h"
 #include "src/core/lib/promise/detail/status.h"
 
 namespace grpc_core {
@@ -274,17 +275,6 @@ class ValueOrFailure {
     return value_ != other;
   }
 
-  template <typename Sink>
-  friend void AbslStringify(Sink& sink, const ValueOrFailure& value) {
-    if (value.ok()) {
-      sink.Append("Success(");
-      sink.Append(absl::StrCat(*value));
-      sink.Append(")");
-    } else {
-      sink.Append("Failure");
-    }
-  }
-
  private:
   std::optional<T> value_;
 };
@@ -299,6 +289,28 @@ inline std::ostream& operator<<(std::ostream& os,
   }
 }
 
+template <typename Sink, typename T>
+void AbslStringify(Sink& sink, const ValueOrFailure<T>& value) {
+  if (value.ok()) {
+    sink.Append("Success(");
+    sink.Append(absl::StrCat(*value));
+    sink.Append(")");
+  } else {
+    sink.Append("Failure");
+  }
+}
+
+template <typename Sink, typename... Ts>
+void AbslStringify(Sink& sink, const ValueOrFailure<std::tuple<Ts...>>& value) {
+  if (value.ok()) {
+    sink.Append("Success(");
+    sink.Append(absl::StrCat("(", absl::StrJoin(*value, ", "), ")"));
+    sink.Append(")");
+  } else {
+    sink.Append("Failure");
+  }
+}
+
 template <typename T>
 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline bool IsStatusOk(
     const ValueOrFailure<T>& value) {

data/src/core/lib/promise/try_seq.h

@@ -263,6 +263,8 @@ class TrySeq {
     return state_.PollOnce();
   }
 
+  Json ToJson() const { return state_.ToJson("TrySeq"); }
+
  private:
   SeqState<TrySeqTraits, P, Fs...> state_;
 };

data/src/core/lib/resource_quota/memory_quota.cc

@@ -152,6 +152,15 @@ ReclamationSweep::~ReclamationSweep() {
   }
 }
 
+void ReclamationSweep::Finish() {
+  auto memory_quota = std::move(memory_quota_);
+  if (memory_quota != nullptr) {
+    auto sweep_token = sweep_token_;
+    auto waker = std::move(waker_);
+    memory_quota->FinishReclamation(sweep_token, std::move(waker));
+  }
+}
+
 //
 // ReclaimerQueue
 //

data/src/core/lib/resource_quota/memory_quota.h

@@ -112,9 +112,7 @@ class ReclamationSweep {
   // Explicit finish for users that wish to write it.
   // Just destroying the object is enough, but sometimes the additional
   // explicitness is warranted.
-  void Finish() {
-    [](ReclamationSweep) {}(std::move(*this));
-  }
+  void Finish();
 
  private:
   std::shared_ptr<BasicMemoryQuota> memory_quota_;

data/src/core/lib/security/authorization/evaluate_args.cc

@@ -23,9 +23,9 @@
 #include "absl/status/statusor.h"
 #include "absl/strings/match.h"
 #include "absl/strings/numbers.h"
+#include "src/core/credentials/transport/tls/tls_utils.h"
 #include "src/core/handshaker/endpoint_info/endpoint_info_handshaker.h"
 #include "src/core/lib/address_utils/parse_address.h"
-#include "src/core/lib/security/credentials/tls/tls_utils.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/util/host_port.h"
 #include "src/core/util/uri.h"

data/src/core/lib/security/authorization/evaluate_args.h

@@ -23,9 +23,9 @@
 #include <vector>
 
 #include "absl/strings/string_view.h"
+#include "src/core/call/metadata_batch.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/iomgr/resolved_address.h"
-#include "src/core/lib/transport/metadata_batch.h"
 
 namespace grpc_core {
 

data/src/core/lib/security/authorization/grpc_server_authz_filter.cc

@@ -24,13 +24,13 @@
 #include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_join.h"
+#include "src/core/call/metadata_batch.h"
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/channel/promise_based_filter.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/promise/promise.h"
 #include "src/core/lib/security/authorization/authorization_engine.h"
 #include "src/core/lib/security/authorization/evaluate_args.h"
-#include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/lib/transport/transport.h"
 #include "src/core/util/latent_see.h"
 

data/src/core/lib/security/authorization/grpc_server_authz_filter.h

@@ -25,8 +25,8 @@
 #include "src/core/lib/promise/arena_promise.h"
 #include "src/core/lib/security/authorization/authorization_policy_provider.h"
 #include "src/core/lib/security/authorization/evaluate_args.h"
-#include "src/core/lib/security/context/security_context.h"
 #include "src/core/lib/transport/transport.h"
+#include "src/core/transport/auth_context.h"
 #include "src/core/util/ref_counted_ptr.h"
 
 namespace grpc_core {

data/src/core/lib/slice/slice.h

@@ -432,6 +432,12 @@ class GPR_MSVC_EMPTY_BASE_CLASS_WORKAROUND Slice
   static Slice FromExternalString(absl::string_view str) {
     return FromStaticString(str);
   }
+
+  static Slice ZeroContentsWithLength(size_t length) {
+    grpc_slice backing = grpc_slice_malloc(length);
+    memset(GRPC_SLICE_START_PTR(backing), 0, length);
+    return Slice(backing);
+  }
 };
 
 }  // namespace grpc_core

data/src/core/lib/slice/slice_buffer.h

@@ -112,6 +112,12 @@ class SliceBuffer {
     grpc_slice_buffer_move_first_into_buffer(&slice_buffer_, n, dst);
   }
 
+  /// Copy the first n bytes of the SliceBuffer into a memory pointed to by
+  /// dst. The original SliceBuffer remains unchanged.
+  void CopyFirstNBytesIntoBuffer(size_t n, void* dst) {
+    grpc_slice_buffer_copy_first_into_buffer(&slice_buffer_, n, dst);
+  }
+
   /// Removes/deletes the last n bytes in the SliceBuffer and add it to the
   /// other SliceBuffer
   void MoveLastNBytesIntoSliceBuffer(size_t n, SliceBuffer& other) {

data/src/core/lib/surface/call.cc

@@ -55,10 +55,12 @@
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_join.h"
 #include "absl/strings/string_view.h"
+#include "src/core/call/call_finalization.h"
+#include "src/core/call/metadata.h"
+#include "src/core/call/metadata_batch.h"
+#include "src/core/call/status_util.h"
 #include "src/core/channelz/channelz.h"
-#include "src/core/lib/channel/call_finalization.h"
 #include "src/core/lib/channel/channel_stack.h"
-#include "src/core/lib/channel/status_util.h"
 #include "src/core/lib/compression/compression_internal.h"
 #include "src/core/lib/event_engine/event_engine_context.h"
 #include "src/core/lib/experiments/experiments.h"
@@ -86,8 +88,6 @@
 #include "src/core/lib/surface/completion_queue.h"
 #include "src/core/lib/surface/validate_metadata.h"
 #include "src/core/lib/transport/error_utils.h"
-#include "src/core/lib/transport/metadata.h"
-#include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/lib/transport/transport.h"
 #include "src/core/server/server_interface.h"
 #include "src/core/telemetry/call_tracer.h"
@@ -191,7 +191,7 @@ void Call::PublishToParent(Call* parent) {
         cc->sibling_prev->child_->sibling_next = this;
   }
   if (parent->Completed()) {
-    CancelWithError(absl::CancelledError());
+    CancelWithError(absl::CancelledError("CANCELLED"));
   }
 }
 
@@ -215,16 +215,20 @@ void Call::MaybeUnpublishFromParent() {
 }
 
 void Call::CancelWithStatus(grpc_status_code status, const char* description) {
-  // copying 'description' is needed to ensure the grpc_call_cancel_with_status
-  // guarantee that can be short-lived.
-  // TODO(ctiller): change to
-  // absl::Status(static_cast<absl::StatusCode>(status), description)
-  // (ie remove the set_int, set_str).
-  CancelWithError(grpc_error_set_int(
-      grpc_error_set_str(
-          absl::Status(static_cast<absl::StatusCode>(status), description),
-          StatusStrProperty::kGrpcMessage, description),
-      StatusIntProperty::kRpcStatus, status));
+  if (!IsErrorFlattenEnabled()) {
+    CancelWithError(grpc_error_set_int(
+        grpc_error_set_str(
+            absl::Status(static_cast<absl::StatusCode>(status), description),
+            StatusStrProperty::kGrpcMessage, description),
+        StatusIntProperty::kRpcStatus, status));
+    return;
+  }
+  if (status == GRPC_STATUS_OK) {
+    VLOG(2) << "CancelWithStatus() called with OK status, using UNKNOWN";
+    status = GRPC_STATUS_UNKNOWN;
+  }
+  CancelWithError(
+      absl::Status(static_cast<absl::StatusCode>(status), description));
 }
 
 void Call::PropagateCancellationToChildren() {
@@ -238,7 +242,7 @@ void Call::PropagateCancellationToChildren() {
         Call* next_child_call = child->child_->sibling_next;
         if (child->cancellation_is_inherited_) {
           child->InternalRef("propagate_cancel");
-          child->CancelWithError(absl::CancelledError());
+          child->CancelWithError(absl::CancelledError("CANCELLED"));
           child->InternalUnref("propagate_cancel");
         }
         child = next_child_call;
@@ -414,7 +418,8 @@ grpc_call_error grpc_call_cancel(grpc_call* call, void* reserved) {
     return GRPC_CALL_ERROR;
   }
   grpc_core::ExecCtx exec_ctx;
-  grpc_core::Call::FromC(call)->CancelWithError(absl::CancelledError());
+  grpc_core::Call::FromC(call)->CancelWithError(
+      absl::CancelledError("CANCELLED"));
   return GRPC_CALL_OK;
 }
 
@@ -435,7 +440,8 @@ grpc_call_error grpc_call_cancel_with_status(grpc_call* c,
 }
 
 void grpc_call_cancel_internal(grpc_call* call) {
-  grpc_core::Call::FromC(call)->CancelWithError(absl::CancelledError());
+  grpc_core::Call::FromC(call)->CancelWithError(
+      absl::CancelledError("CANCELLED"));
 }
 
 grpc_compression_algorithm grpc_call_test_only_get_compression_algorithm(

data/src/core/lib/surface/call_utils.cc

@@ -46,7 +46,9 @@
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/string_view.h"
-#include "src/core/lib/channel/status_util.h"
+#include "src/core/call/metadata.h"
+#include "src/core/call/metadata_batch.h"
+#include "src/core/call/status_util.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/promise/activity.h"
 #include "src/core/lib/promise/context.h"
@@ -56,8 +58,6 @@
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/surface/completion_queue.h"
 #include "src/core/lib/surface/validate_metadata.h"
-#include "src/core/lib/transport/metadata.h"
-#include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/util/crash.h"
 #include "src/core/util/debug_location.h"
 #include "src/core/util/match.h"

data/src/core/lib/surface/call_utils.h

@@ -44,6 +44,9 @@
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
+#include "src/core/call/message.h"
+#include "src/core/call/metadata.h"
+#include "src/core/call/metadata_batch.h"
 #include "src/core/lib/promise/activity.h"
 #include "src/core/lib/promise/cancel_callback.h"
 #include "src/core/lib/promise/map.h"
@@ -51,9 +54,6 @@
 #include "src/core/lib/promise/seq.h"
 #include "src/core/lib/promise/status_flag.h"
 #include "src/core/lib/surface/completion_queue.h"
-#include "src/core/lib/transport/message.h"
-#include "src/core/lib/transport/metadata.h"
-#include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/util/crash.h"
 
 namespace grpc_core {

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

@@ -30,6 +30,8 @@
 #include "absl/base/thread_annotations.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
+#include "src/core/call/call_arena_allocator.h"
+#include "src/core/call/call_destination.h"
 #include "src/core/channelz/channelz.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/iomgr/iomgr_fwd.h"
@@ -37,8 +39,6 @@
 #include "src/core/lib/resource_quota/resource_quota.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/surface/channel_stack_type.h"
-#include "src/core/lib/transport/call_arena_allocator.h"
-#include "src/core/lib/transport/call_destination.h"
 #include "src/core/lib/transport/connectivity_state.h"
 #include "src/core/util/cpp_impl_of.h"
 #include "src/core/util/ref_counted.h"