grpc 1.60.0 → 1.62.0

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

@@ -0,0 +1,226 @@
+// Copyright 2023 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.
+
+#ifndef GRPC_SRC_CORE_LIB_PROMISE_STATUS_FLAG_H
+#define GRPC_SRC_CORE_LIB_PROMISE_STATUS_FLAG_H
+
+#include <grpc/support/port_platform.h>
+
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+#include "absl/types/optional.h"
+
+#include <grpc/support/log.h>
+
+#include "src/core/lib/promise/detail/status.h"
+
+namespace grpc_core {
+
+struct Failure {
+  template <typename Sink>
+  friend void AbslStringify(Sink& sink, Failure) {
+    sink.Append("failed");
+  }
+};
+struct Success {
+  template <typename Sink>
+  friend void AbslStringify(Sink& sink, Success) {
+    sink.Append("ok");
+  }
+};
+
+inline bool IsStatusOk(Failure) { return false; }
+inline bool IsStatusOk(Success) { return true; }
+
+template <>
+struct StatusCastImpl<absl::Status, Success> {
+  static absl::Status Cast(Success) { return absl::OkStatus(); }
+};
+
+template <>
+struct StatusCastImpl<absl::Status, const Success&> {
+  static absl::Status Cast(Success) { return absl::OkStatus(); }
+};
+
+template <>
+struct StatusCastImpl<absl::Status, Failure> {
+  static absl::Status Cast(Failure) { return absl::CancelledError(); }
+};
+
+template <typename T>
+struct StatusCastImpl<absl::StatusOr<T>, Failure> {
+  static absl::StatusOr<T> Cast(Failure) { return absl::CancelledError(); }
+};
+
+// A boolean representing whether an operation succeeded (true) or failed
+// (false).
+class StatusFlag {
+ public:
+  StatusFlag() : value_(true) {}
+  explicit StatusFlag(bool value) : value_(value) {}
+  // NOLINTNEXTLINE(google-explicit-constructor)
+  StatusFlag(Failure) : value_(false) {}
+  // NOLINTNEXTLINE(google-explicit-constructor)
+  StatusFlag(Success) : value_(true) {}
+
+  bool ok() const { return value_; }
+
+  bool operator==(StatusFlag other) const { return value_ == other.value_; }
+  std::string ToString() const { return value_ ? "ok" : "failed"; }
+
+  template <typename Sink>
+  friend void AbslStringify(Sink& sink, StatusFlag flag) {
+    if (flag.ok()) {
+      sink.Append("ok");
+    } else {
+      sink.Append("failed");
+    }
+  }
+
+ private:
+  bool value_;
+};
+
+inline bool operator==(StatusFlag flag, Failure) { return !flag.ok(); }
+inline bool operator==(Failure, StatusFlag flag) { return !flag.ok(); }
+inline bool operator==(StatusFlag flag, Success) { return flag.ok(); }
+inline bool operator==(Success, StatusFlag flag) { return flag.ok(); }
+
+inline bool operator!=(StatusFlag flag, Failure) { return flag.ok(); }
+inline bool operator!=(Failure, StatusFlag flag) { return flag.ok(); }
+inline bool operator!=(StatusFlag flag, Success) { return !flag.ok(); }
+inline bool operator!=(Success, StatusFlag flag) { return !flag.ok(); }
+
+inline bool IsStatusOk(const StatusFlag& flag) { return flag.ok(); }
+
+template <>
+struct StatusCastImpl<absl::Status, StatusFlag> {
+  static absl::Status Cast(StatusFlag flag) {
+    return flag.ok() ? absl::OkStatus() : absl::CancelledError();
+  }
+};
+
+template <>
+struct StatusCastImpl<absl::Status, StatusFlag&> {
+  static absl::Status Cast(StatusFlag flag) {
+    return flag.ok() ? absl::OkStatus() : absl::CancelledError();
+  }
+};
+
+template <>
+struct StatusCastImpl<absl::Status, const StatusFlag&> {
+  static absl::Status Cast(StatusFlag flag) {
+    return flag.ok() ? absl::OkStatus() : absl::CancelledError();
+  }
+};
+
+template <typename T>
+struct FailureStatusCastImpl<absl::StatusOr<T>, StatusFlag> {
+  static absl::StatusOr<T> Cast(StatusFlag flag) {
+    GPR_DEBUG_ASSERT(!flag.ok());
+    return absl::CancelledError();
+  }
+};
+
+template <typename T>
+struct FailureStatusCastImpl<absl::StatusOr<T>, StatusFlag&> {
+  static absl::StatusOr<T> Cast(StatusFlag flag) {
+    GPR_DEBUG_ASSERT(!flag.ok());
+    return absl::CancelledError();
+  }
+};
+
+template <typename T>
+struct FailureStatusCastImpl<absl::StatusOr<T>, const StatusFlag&> {
+  static absl::StatusOr<T> Cast(StatusFlag flag) {
+    GPR_DEBUG_ASSERT(!flag.ok());
+    return absl::CancelledError();
+  }
+};
+
+// A value if an operation was successful, or a failure flag if not.
+template <typename T>
+class ValueOrFailure {
+ public:
+  // NOLINTNEXTLINE(google-explicit-constructor)
+  ValueOrFailure(T value) : value_(std::move(value)) {}
+  // NOLINTNEXTLINE(google-explicit-constructor)
+  ValueOrFailure(Failure) {}
+  // NOLINTNEXTLINE(google-explicit-constructor)
+  ValueOrFailure(StatusFlag status) { GPR_ASSERT(!status.ok()); }
+
+  static ValueOrFailure FromOptional(absl::optional<T> value) {
+    return ValueOrFailure{std::move(value)};
+  }
+
+  bool ok() const { return value_.has_value(); }
+  StatusFlag status() const { return StatusFlag(ok()); }
+
+  const T& value() const { return value_.value(); }
+  T& value() { return value_.value(); }
+  const T& operator*() const { return *value_; }
+  T& operator*() { return *value_; }
+
+  bool operator==(const ValueOrFailure& other) const {
+    return value_ == other.value_;
+  }
+
+ private:
+  absl::optional<T> value_;
+};
+
+template <typename T>
+inline bool IsStatusOk(const ValueOrFailure<T>& value) {
+  return value.ok();
+}
+
+template <typename T>
+inline T TakeValue(ValueOrFailure<T>&& value) {
+  return std::move(value.value());
+}
+
+template <typename T>
+struct StatusCastImpl<absl::StatusOr<T>, ValueOrFailure<T>> {
+  static absl::StatusOr<T> Cast(ValueOrFailure<T> value) {
+    return value.ok() ? absl::StatusOr<T>(std::move(value.value()))
+                      : absl::CancelledError();
+  }
+};
+
+template <typename T>
+struct StatusCastImpl<ValueOrFailure<T>, Failure> {
+  static ValueOrFailure<T> Cast(Failure) {
+    return ValueOrFailure<T>(Failure{});
+  }
+};
+
+template <typename T>
+struct StatusCastImpl<ValueOrFailure<T>, StatusFlag&> {
+  static ValueOrFailure<T> Cast(StatusFlag f) {
+    GPR_ASSERT(!f.ok());
+    return ValueOrFailure<T>(Failure{});
+  }
+};
+
+template <typename T>
+struct StatusCastImpl<ValueOrFailure<T>, StatusFlag> {
+  static ValueOrFailure<T> Cast(StatusFlag f) {
+    GPR_ASSERT(!f.ok());
+    return ValueOrFailure<T>(Failure{});
+  }
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_LIB_PROMISE_STATUS_FLAG_H

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

@@ -0,0 +1,132 @@
+// Copyright 2021 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.
+
+#ifndef GRPC_SRC_CORE_LIB_PROMISE_TRY_JOIN_H
+#define GRPC_SRC_CORE_LIB_PROMISE_TRY_JOIN_H
+
+#include <grpc/support/port_platform.h>
+
+#include <tuple>
+#include <variant>
+
+#include "absl/meta/type_traits.h"
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+
+#include "src/core/lib/promise/detail/join_state.h"
+#include "src/core/lib/promise/map.h"
+#include "src/core/lib/promise/poll.h"
+#include "src/core/lib/promise/status_flag.h"
+
+namespace grpc_core {
+
+namespace promise_detail {
+
+// Extract the T from a StatusOr<T>
+template <typename T>
+T IntoResult(absl::StatusOr<T>* status) {
+  return std::move(**status);
+}
+
+// TryJoin returns a StatusOr<tuple<A,B,C>> for f()->Poll<StatusOr<A>>,
+// g()->Poll<StatusOr<B>>, h()->Poll<StatusOr<C>>. If one of those should be a
+// Status instead, we need a placeholder type to return, and this is it.
+inline Empty IntoResult(absl::Status*) { return Empty{}; }
+
+// Traits object to pass to BasicJoin
+template <template <typename> class Result>
+struct TryJoinTraits {
+  template <typename T>
+  using ResultType = Result<absl::remove_reference_t<T>>;
+  template <typename T>
+  static bool IsOk(const absl::StatusOr<T>& x) {
+    return x.ok();
+  }
+  static bool IsOk(const absl::Status& x) { return x.ok(); }
+  static bool IsOk(StatusFlag x) { return x.ok(); }
+  template <typename T>
+  static bool IsOk(const ValueOrFailure<T>& x) {
+    return x.ok();
+  }
+  template <typename T>
+  static T Unwrapped(absl::StatusOr<T> x) {
+    return std::move(*x);
+  }
+  template <typename T>
+  static T Unwrapped(ValueOrFailure<T> x) {
+    return std::move(*x);
+  }
+  static Empty Unwrapped(absl::Status) { return Empty{}; }
+  static Empty Unwrapped(StatusFlag) { return Empty{}; }
+  template <typename R, typename T>
+  static R EarlyReturn(absl::StatusOr<T> x) {
+    return x.status();
+  }
+  template <typename R>
+  static R EarlyReturn(absl::Status x) {
+    return FailureStatusCast<R>(std::move(x));
+  }
+  template <typename R>
+  static R EarlyReturn(StatusFlag x) {
+    return FailureStatusCast<R>(x);
+  }
+  template <typename R, typename T>
+  static R EarlyReturn(const ValueOrFailure<T>& x) {
+    GPR_ASSERT(!x.ok());
+    return FailureStatusCast<R>(Failure{});
+  }
+  template <typename... A>
+  static auto FinalReturn(A&&... a) {
+    return Result<std::tuple<A...>>(std::make_tuple(std::forward<A>(a)...));
+  }
+};
+
+// Implementation of TryJoin combinator.
+template <template <typename> class R, typename... Promises>
+class TryJoin {
+ public:
+  explicit TryJoin(Promises... promises) : state_(std::move(promises)...) {}
+  auto operator()() { return state_.PollOnce(); }
+
+ private:
+  JoinState<TryJoinTraits<R>, Promises...> state_;
+};
+
+template <template <typename> class R>
+struct WrapInStatusOrTuple {
+  template <typename T>
+  R<std::tuple<T>> operator()(R<T> x) {
+    if (!x.ok()) return x.status();
+    return std::make_tuple(std::move(*x));
+  }
+};
+
+}  // namespace promise_detail
+
+// Run all promises.
+// If any fail, cancel the rest and return the failure.
+// If all succeed, return Ok(tuple-of-results).
+template <template <typename> class R, typename... Promises>
+promise_detail::TryJoin<R, Promises...> TryJoin(Promises... promises) {
+  return promise_detail::TryJoin<R, Promises...>(std::move(promises)...);
+}
+
+template <template <typename> class R, typename F>
+auto TryJoin(F promise) {
+  return Map(promise, promise_detail::WrapInStatusOrTuple<R>{});
+}
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_LIB_PROMISE_TRY_JOIN_H

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

@@ -31,6 +31,7 @@
 #include "src/core/lib/promise/detail/seq_state.h"
 #include "src/core/lib/promise/detail/status.h"
 #include "src/core/lib/promise/poll.h"
+#include "src/core/lib/promise/status_flag.h"
 
 namespace grpc_core {
 
@@ -45,6 +46,7 @@ struct TrySeqTraitsWithSfinae {
     return next->Make(std::forward<T>(value));
   }
   static bool IsOk(const T&) { return true; }
+  static const char* ErrorString(const T&) { abort(); }
   template <typename R>
   static R ReturnValue(T&&) {
     abort();
@@ -69,9 +71,12 @@ struct TrySeqTraitsWithSfinae<absl::StatusOr<T>> {
     return next->Make(std::move(*status));
   }
   static bool IsOk(const absl::StatusOr<T>& status) { return status.ok(); }
+  static std::string ErrorString(const absl::StatusOr<T>& status) {
+    return status.status().ToString();
+  }
   template <typename R>
   static R ReturnValue(absl::StatusOr<T>&& status) {
-    return StatusCast<R>(status.status());
+    return FailureStatusCast<R>(status.status());
   }
   template <typename F, typename Elem>
   static auto CallSeqFactory(F& f, Elem&& elem, absl::StatusOr<T> value)
@@ -81,17 +86,43 @@ struct TrySeqTraitsWithSfinae<absl::StatusOr<T>> {
   template <typename Result, typename RunNext>
   static Poll<Result> CheckResultAndRunNext(absl::StatusOr<T> prior,
                                             RunNext run_next) {
-    if (!prior.ok()) return StatusCast<Result>(prior.status());
+    if (!prior.ok()) return FailureStatusCast<Result>(prior.status());
     return run_next(std::move(prior));
   }
 };
+
+template <typename T>
+struct AllowGenericTrySeqTraits {
+  static constexpr bool value = true;
+};
+
+template <>
+struct AllowGenericTrySeqTraits<absl::Status> {
+  static constexpr bool value = false;
+};
+
+template <typename T>
+struct AllowGenericTrySeqTraits<absl::StatusOr<T>> {
+  static constexpr bool value = false;
+};
+
+template <typename T, typename AnyType = void>
+struct TakeValueExists {
+  static constexpr bool value = false;
+};
+template <typename T>
+struct TakeValueExists<T,
+                       absl::void_t<decltype(TakeValue(std::declval<T>()))>> {
+  static constexpr bool value = true;
+};
 // If there exists a function 'IsStatusOk(const T&) -> bool' then we assume that
 // T is a status type for the purposes of promise sequences, and a non-OK T
 // should terminate the sequence and return.
 template <typename T>
 struct TrySeqTraitsWithSfinae<
     T, absl::enable_if_t<
-           std::is_same<decltype(IsStatusOk(std::declval<T>())), bool>::value,
+           std::is_same<decltype(IsStatusOk(std::declval<T>())), bool>::value &&
+               !TakeValueExists<T>::value && AllowGenericTrySeqTraits<T>::value,
            void>> {
   using UnwrappedType = void;
   using WrappedType = T;
@@ -100,9 +131,39 @@ struct TrySeqTraitsWithSfinae<
     return next->Make();
   }
   static bool IsOk(const T& status) { return IsStatusOk(status); }
+  static std::string ErrorString(const T& status) {
+    return IsStatusOk(status) ? "OK" : "FAILED";
+  }
+  template <typename R>
+  static R ReturnValue(T&& status) {
+    return FailureStatusCast<R>(std::move(status));
+  }
+  template <typename Result, typename RunNext>
+  static Poll<Result> CheckResultAndRunNext(T prior, RunNext run_next) {
+    if (!IsStatusOk(prior)) return Result(std::move(prior));
+    return run_next(std::move(prior));
+  }
+};
+template <typename T>
+struct TrySeqTraitsWithSfinae<
+    T, absl::enable_if_t<
+           std::is_same<decltype(IsStatusOk(std::declval<T>())), bool>::value &&
+               TakeValueExists<T>::value && AllowGenericTrySeqTraits<T>::value,
+           void>> {
+  using UnwrappedType = decltype(TakeValue(std::declval<T>()));
+  using WrappedType = T;
+  template <typename Next>
+  static auto CallFactory(Next* next, T&& status) {
+    return next->Make(TakeValue(std::forward<T>(status)));
+  }
+  static bool IsOk(const T& status) { return IsStatusOk(status); }
+  static std::string ErrorString(const T& status) {
+    return IsStatusOk(status) ? "OK" : "FAILED";
+  }
   template <typename R>
   static R ReturnValue(T&& status) {
-    return R(std::move(status));
+    GPR_DEBUG_ASSERT(!IsStatusOk(status));
+    return FailureStatusCast<R>(status.status());
   }
   template <typename Result, typename RunNext>
   static Poll<Result> CheckResultAndRunNext(T prior, RunNext run_next) {
@@ -119,9 +180,12 @@ struct TrySeqTraitsWithSfinae<absl::Status> {
     return next->Make();
   }
   static bool IsOk(const absl::Status& status) { return status.ok(); }
+  static std::string ErrorString(const absl::Status& status) {
+    return status.ToString();
+  }
   template <typename R>
   static R ReturnValue(absl::Status&& status) {
-    return StatusCast<R>(std::move(status));
+    return FailureStatusCast<R>(std::move(status));
   }
   template <typename Result, typename RunNext>
   static Poll<Result> CheckResultAndRunNext(absl::Status prior,
@@ -137,8 +201,9 @@ using TrySeqTraits = TrySeqTraitsWithSfinae<T>;
 template <typename P, typename... Fs>
 class TrySeq {
  public:
-  explicit TrySeq(P&& promise, Fs&&... factories)
-      : state_(std::forward<P>(promise), std::forward<Fs>(factories)...) {}
+  explicit TrySeq(P&& promise, Fs&&... factories, DebugLocation whence)
+      : state_(std::forward<P>(promise), std::forward<Fs>(factories)...,
+               whence) {}
 
   auto operator()() { return state_.PollOnce(); }
 
@@ -180,9 +245,66 @@ struct TrySeqIterResultTraits {
 // Functors can return StatusOr<> to signal that a value is fed forward, or
 // Status to indicate only success/failure. In the case of returning Status,
 // the construction functors take no arguments.
-template <typename... Functors>
-promise_detail::TrySeq<Functors...> TrySeq(Functors... functors) {
-  return promise_detail::TrySeq<Functors...>(std::move(functors)...);
+template <typename F>
+F TrySeq(F functor) {
+  return functor;
+}
+
+template <typename F0, typename F1>
+promise_detail::TrySeq<F0, F1> TrySeq(F0 f0, F1 f1, DebugLocation whence = {}) {
+  return promise_detail::TrySeq<F0, F1>(std::move(f0), std::move(f1), whence);
+}
+
+template <typename F0, typename F1, typename F2>
+promise_detail::TrySeq<F0, F1, F2> TrySeq(F0 f0, F1 f1, F2 f2,
+                                          DebugLocation whence = {}) {
+  return promise_detail::TrySeq<F0, F1, F2>(std::move(f0), std::move(f1),
+                                            std::move(f2), whence);
+}
+
+template <typename F0, typename F1, typename F2, typename F3>
+promise_detail::TrySeq<F0, F1, F2, F3> TrySeq(F0 f0, F1 f1, F2 f2, F3 f3,
+                                              DebugLocation whence = {}) {
+  return promise_detail::TrySeq<F0, F1, F2, F3>(
+      std::move(f0), std::move(f1), std::move(f2), std::move(f3), whence);
+}
+
+template <typename F0, typename F1, typename F2, typename F3, typename F4>
+promise_detail::TrySeq<F0, F1, F2, F3, F4> TrySeq(F0 f0, F1 f1, F2 f2, F3 f3,
+                                                  F4 f4,
+                                                  DebugLocation whence = {}) {
+  return promise_detail::TrySeq<F0, F1, F2, F3, F4>(
+      std::move(f0), std::move(f1), std::move(f2), std::move(f3), std::move(f4),
+      whence);
+}
+
+template <typename F0, typename F1, typename F2, typename F3, typename F4,
+          typename F5>
+promise_detail::TrySeq<F0, F1, F2, F3, F4, F5> TrySeq(
+    F0 f0, F1 f1, F2 f2, F3 f3, F4 f4, F5 f5, DebugLocation whence = {}) {
+  return promise_detail::TrySeq<F0, F1, F2, F3, F4, F5>(
+      std::move(f0), std::move(f1), std::move(f2), std::move(f3), std::move(f4),
+      std::move(f5), whence);
+}
+
+template <typename F0, typename F1, typename F2, typename F3, typename F4,
+          typename F5, typename F6>
+promise_detail::TrySeq<F0, F1, F2, F3, F4, F5, F6> TrySeq(
+    F0 f0, F1 f1, F2 f2, F3 f3, F4 f4, F5 f5, F6 f6,
+    DebugLocation whence = {}) {
+  return promise_detail::TrySeq<F0, F1, F2, F3, F4, F5, F6>(
+      std::move(f0), std::move(f1), std::move(f2), std::move(f3), std::move(f4),
+      std::move(f5), std::move(f6), whence);
+}
+
+template <typename F0, typename F1, typename F2, typename F3, typename F4,
+          typename F5, typename F6, typename F7>
+promise_detail::TrySeq<F0, F1, F2, F3, F4, F5, F6, F7> TrySeq(
+    F0 f0, F1 f1, F2 f2, F3 f3, F4 f4, F5 f5, F6 f6, F7 f7,
+    DebugLocation whence = {}) {
+  return promise_detail::TrySeq<F0, F1, F2, F3, F4, F5, F6, F7>(
+      std::move(f0), std::move(f1), std::move(f2), std::move(f3), std::move(f4),
+      std::move(f5), std::move(f6), std::move(f7), whence);
 }
 
 // Try a sequence of operations of unknown length.

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

@@ -180,7 +180,7 @@ class Arena {
   template <typename T, typename... Args>
   T* New(Args&&... args) {
     T* t = static_cast<T*>(Alloc(sizeof(T)));
-    Construct(t, std::forward<Args>(args)...);
+    new (t) T(std::forward<Args>(args)...);
     return t;
   }
 
@@ -333,7 +333,7 @@ class Arena {
   //          value in Arena::PoolSizes, and so this may pessimize total
   //          arena size.
   template <typename T, typename... Args>
-  PoolPtr<T> MakePooled(Args&&... args) {
+  static PoolPtr<T> MakePooled(Args&&... args) {
     return PoolPtr<T>(new T(std::forward<Args>(args)...), PooledDeleter());
   }