grpc 1.44.0.pre2 → 1.45.0

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

@@ -162,9 +162,9 @@ absl::enable_if_t<I <= J, SeqState<Traits, I, Fs...>*> GetSeqState(
 }
 
 template <template <typename> class Traits, char I, typename... Fs, typename T>
-auto CallNext(SeqState<Traits, I, Fs...>* state, T&& arg) -> decltype(
-    SeqState<Traits, I, Fs...>::Types::PromiseResultTraits::CallFactory(
-        &state->next_factory, std::forward<T>(arg))) {
+auto CallNext(SeqState<Traits, I, Fs...>* state, T&& arg)
+    -> decltype(SeqState<Traits, I, Fs...>::Types::PromiseResultTraits::
+                    CallFactory(&state->next_factory, std::forward<T>(arg))) {
   return SeqState<Traits, I, Fs...>::Types::PromiseResultTraits::CallFactory(
       &state->next_factory, std::forward<T>(arg));
 }
@@ -401,6 +401,95 @@ class BasicSeq {
   }
 };
 
+// As above, but models a sequence of unknown size
+// At each element, the accumulator A and the current value V is passed to some
+// function of type F as f(V, A); f is expected to return a promise that
+// resolves to Traits::WrappedType.
+template <template <typename Wrapped> class Traits, typename F, typename Arg,
+          typename Iter>
+class BasicSeqIter {
+ private:
+  using IterValue = decltype(*std::declval<Iter>());
+  using StateCreated = decltype(std::declval<F>()(std::declval<IterValue>(),
+                                                  std::declval<Arg>()));
+  using State = PromiseLike<StateCreated>;
+  using Wrapped = typename State::Result;
+
+ public:
+  BasicSeqIter(Iter begin, Iter end, F f, Arg arg)
+      : cur_(begin), end_(end), f_(std::move(f)) {
+    if (cur_ == end_) {
+      Construct(&result_, std::move(arg));
+    } else {
+      Construct(&state_, f_(*cur_, std::move(arg)));
+    }
+  }
+
+  ~BasicSeqIter() {
+    if (cur_ == end_) {
+      Destruct(&result_);
+    } else {
+      Destruct(&state_);
+    }
+  }
+
+  BasicSeqIter(const BasicSeqIter& other) = delete;
+  BasicSeqIter& operator=(const BasicSeqIter&) = delete;
+
+  BasicSeqIter(BasicSeqIter&& other) noexcept
+      : cur_(other.cur_), end_(other.end_), f_(std::move(other.f_)) {
+    if (cur_ == end_) {
+      Construct(&result_, std::move(other.result_));
+    } else {
+      Construct(&state_, std::move(other.state_));
+    }
+  }
+  BasicSeqIter& operator=(BasicSeqIter&& other) noexcept {
+    cur_ = other.cur_;
+    end_ = other.end_;
+    if (cur_ == end_) {
+      Construct(&result_, std::move(other.result_));
+    } else {
+      Construct(&state_, std::move(other.state_));
+    }
+    return *this;
+  }
+
+  Poll<Wrapped> operator()() {
+    if (cur_ == end_) {
+      return std::move(result_);
+    }
+    return PollNonEmpty();
+  }
+
+ private:
+  Poll<Wrapped> PollNonEmpty() {
+    Poll<Wrapped> r = state_();
+    if (absl::holds_alternative<Pending>(r)) return r;
+    return Traits<Wrapped>::template CheckResultAndRunNext<Wrapped>(
+        std::move(absl::get<Wrapped>(r)), [this](Wrapped arg) -> Poll<Wrapped> {
+          auto next = cur_;
+          ++next;
+          if (next == end_) {
+            return std::move(arg);
+          }
+          cur_ = next;
+          state_.~State();
+          Construct(&state_,
+                    Traits<Wrapped>::CallSeqFactory(f_, *cur_, std::move(arg)));
+          return PollNonEmpty();
+        });
+  }
+
+  Iter cur_;
+  const Iter end_;
+  GPR_NO_UNIQUE_ADDRESS F f_;
+  union {
+    GPR_NO_UNIQUE_ADDRESS State state_;
+    GPR_NO_UNIQUE_ADDRESS Arg result_;
+  };
+};
+
 }  // namespace promise_detail
 }  // namespace grpc_core
 

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

@@ -88,7 +88,7 @@ class Curried {
       : f_(std::forward<F>(f)), arg_(std::forward<Arg>(arg)) {}
   Curried(const F& f, Arg&& arg) : f_(f), arg_(std::forward<Arg>(arg)) {}
   using Result = decltype(std::declval<F>()(std::declval<Arg>()));
-  Result operator()() { return f_(arg_); }
+  Result operator()() { return f_(std::move(arg_)); }
 
  private:
   GPR_NO_UNIQUE_ADDRESS F f_;

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

@@ -20,6 +20,7 @@
 #include <new>
 #include <type_traits>
 
+#include "absl/status/statusor.h"
 #include "absl/types/variant.h"
 
 #include "src/core/lib/promise/detail/promise_factory.h"
@@ -44,20 +45,44 @@ struct LoopTraits;
 template <typename T>
 struct LoopTraits<LoopCtl<T>> {
   using Result = T;
+  static LoopCtl<T> ToLoopCtl(LoopCtl<T> value) { return value; }
+};
+
+template <typename T>
+struct LoopTraits<absl::StatusOr<LoopCtl<T>>> {
+  using Result = absl::StatusOr<T>;
+  static LoopCtl<Result> ToLoopCtl(absl::StatusOr<LoopCtl<T>> value) {
+    if (!value.ok()) return value.status();
+    const auto& inner = *value;
+    if (absl::holds_alternative<Continue>(inner)) return Continue{};
+    return absl::get<T>(inner);
+  }
+};
+
+template <>
+struct LoopTraits<absl::StatusOr<LoopCtl<absl::Status>>> {
+  using Result = absl::Status;
+  static LoopCtl<Result> ToLoopCtl(
+      absl::StatusOr<LoopCtl<absl::Status>> value) {
+    if (!value.ok()) return value.status();
+    const auto& inner = *value;
+    if (absl::holds_alternative<Continue>(inner)) return Continue{};
+    return absl::get<absl::Status>(inner);
+  }
 };
 
 template <typename F>
 class Loop {
  private:
   using Factory = promise_detail::PromiseFactory<void, F>;
-  using Promise = decltype(std::declval<Factory>().Repeated());
-  using PromiseResult = typename Promise::Result;
+  using PromiseType = decltype(std::declval<Factory>().Repeated());
+  using PromiseResult = typename PromiseType::Result;
 
  public:
   using Result = typename LoopTraits<PromiseResult>::Result;
 
   explicit Loop(F f) : factory_(std::move(f)), promise_(factory_.Repeated()) {}
-  ~Loop() { promise_.~Promise(); }
+  ~Loop() { promise_.~PromiseType(); }
 
   Loop(Loop&& loop) noexcept
       : factory_(std::move(loop.factory_)),
@@ -74,13 +99,14 @@ class Loop {
       if (auto* p = absl::get_if<kPollReadyIdx>(&promise_result)) {
         //  - then if it's Continue, destroy the promise and recreate a new one
         //  from our factory.
-        if (absl::holds_alternative<Continue>(*p)) {
-          promise_.~Promise();
-          new (&promise_) Promise(factory_.Repeated());
+        auto lc = LoopTraits<PromiseResult>::ToLoopCtl(*p);
+        if (absl::holds_alternative<Continue>(lc)) {
+          promise_.~PromiseType();
+          new (&promise_) PromiseType(factory_.Repeated());
           continue;
         }
         //  - otherwise there's our result... return it out.
-        return absl::get<Result>(*p);
+        return absl::get<Result>(lc);
       } else {
         // Otherwise the inner promise was pending, so we are pending.
         return Pending();
@@ -90,7 +116,7 @@ class Loop {
 
  private:
   GPR_NO_UNIQUE_ADDRESS Factory factory_;
-  GPR_NO_UNIQUE_ADDRESS union { GPR_NO_UNIQUE_ADDRESS Promise promise_; };
+  GPR_NO_UNIQUE_ADDRESS union { GPR_NO_UNIQUE_ADDRESS PromiseType promise_; };
 };
 
 }  // namespace promise_detail

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

@@ -37,6 +37,12 @@ struct Pending {
 template <typename T>
 using Poll = absl::variant<Pending, T>;
 
+template <typename T, typename U>
+Poll<T> poll_cast(Poll<U> poll) {
+  if (absl::holds_alternative<Pending>(poll)) return Pending{};
+  return std::move(absl::get<U>(poll));
+}
+
 // Variant of Poll that serves as a ready value
 static constexpr size_t kPollReadyIdx = 1;
 

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

@@ -0,0 +1,95 @@
+// 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_CORE_LIB_PROMISE_PROMISE_H
+#define GRPC_CORE_LIB_PROMISE_PROMISE_H
+
+#include <grpc/support/port_platform.h>
+
+#include <functional>
+#include <type_traits>
+
+#include "absl/status/status.h"
+#include "absl/types/optional.h"
+#include "absl/types/variant.h"
+
+#include "src/core/lib/promise/detail/promise_like.h"
+#include "src/core/lib/promise/poll.h"
+
+namespace grpc_core {
+
+// A Promise is any functor that takes no arguments and returns Poll<T>.
+// Most of the time we just pass around the functor, but occasionally
+// it pays to have a type erased variant, which we define here.
+template <typename T>
+using Promise = std::function<Poll<T>()>;
+
+// Helper to execute a promise immediately and return either the result or
+// nothing.
+template <typename Promise>
+auto NowOrNever(Promise promise)
+    -> absl::optional<typename promise_detail::PromiseLike<Promise>::Result> {
+  auto r = promise_detail::PromiseLike<Promise>(std::move(promise))();
+  if (auto* p = absl::get_if<kPollReadyIdx>(&r)) {
+    return std::move(*p);
+  }
+  return {};
+}
+
+// A promise that never completes.
+template <typename T>
+struct Never {
+  Poll<T> operator()() { return Pending(); }
+};
+
+namespace promise_detail {
+// A promise that immediately completes.
+template <typename T>
+class Immediate {
+ public:
+  explicit Immediate(T value) : value_(std::move(value)) {}
+
+  Poll<T> operator()() { return std::move(value_); }
+
+ private:
+  T value_;
+};
+}  // namespace promise_detail
+
+// Return \a value immediately
+template <typename T>
+promise_detail::Immediate<T> Immediate(T value) {
+  return promise_detail::Immediate<T>(std::move(value));
+}
+
+// Return status Ok immediately
+struct ImmediateOkStatus {
+  Poll<absl::Status> operator()() { return absl::OkStatus(); }
+};
+
+// Typecheck that a promise returns the expected return type.
+// usage: auto promise = WithResult<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>
+auto WithResult(F f) ->
+    typename std::enable_if<std::is_same<decltype(f()), Poll<T>>::value,
+                            F>::type {
+  return f;
+}
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_PROMISE_PROMISE_H

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

@@ -37,7 +37,11 @@ struct SeqTraits {
       -> decltype(next->Once(std::forward<T>(value))) {
     return next->Once(std::forward<T>(value));
   }
-
+  template <typename F, typename Elem>
+  static auto CallSeqFactory(F& f, Elem&& elem, T&& value)
+      -> decltype(f(std::forward<Elem>(elem), std::forward<T>(value))) {
+    return f(std::forward<Elem>(elem), std::forward<T>(value));
+  }
   template <typename Result, typename PriorResult, typename RunNext>
   static Poll<Result> CheckResultAndRunNext(PriorResult prior,
                                             RunNext run_next) {
@@ -66,6 +70,20 @@ F Seq(F functor) {
   return functor;
 }
 
+// Execute a sequence of operations of unknown length.
+// Asynchronously:
+//   for (element in (begin, end)) {
+//     argument = wait_for factory(element, argument);
+//   }
+//   return argument;
+template <typename Iter, typename Factory, typename Argument>
+promise_detail::BasicSeqIter<promise_detail::SeqTraits, Factory, Argument, Iter>
+SeqIter(Iter begin, Iter end, Argument argument, Factory factory) {
+  return promise_detail::BasicSeqIter<promise_detail::SeqTraits, Factory,
+                                      Argument, Iter>(
+      begin, end, std::move(factory), std::move(argument));
+}
+
 }  // namespace grpc_core
 
 #endif  // GRPC_CORE_LIB_PROMISE_SEQ_H

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

@@ -0,0 +1,74 @@
+// Copyright 2022 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 <grpc/support/port_platform.h>
+
+#include "src/core/lib/promise/sleep.h"
+
+namespace grpc_core {
+
+Sleep::Sleep(Timestamp deadline) : state_(new State(deadline)) {
+  GRPC_CLOSURE_INIT(&state_->on_timer, &OnTimer, state_, nullptr);
+}
+
+Sleep::~Sleep() {
+  if (state_ == nullptr) return;
+  {
+    MutexLock lock(&state_->mu);
+    switch (state_->stage) {
+      case Stage::kInitial:
+        state_->Unref();
+        break;
+      case Stage::kStarted:
+        grpc_timer_cancel(&state_->timer);
+        break;
+      case Stage::kDone:
+        break;
+    }
+  }
+  state_->Unref();
+}
+
+void Sleep::OnTimer(void* arg, grpc_error_handle) {
+  auto* state = static_cast<State*>(arg);
+  Waker waker;
+  {
+    MutexLock lock(&state->mu);
+    state->stage = Stage::kDone;
+    waker = std::move(state->waker);
+  }
+  waker.Wakeup();
+  state->Unref();
+}
+
+Poll<absl::Status> Sleep::operator()() {
+  MutexLock lock(&state_->mu);
+  switch (state_->stage) {
+    case Stage::kInitial:
+      if (state_->deadline <= ExecCtx::Get()->Now()) {
+        return absl::OkStatus();
+      }
+      state_->stage = Stage::kStarted;
+      grpc_timer_init(&state_->timer, state_->deadline, &state_->on_timer);
+      break;
+    case Stage::kStarted:
+      break;
+    case Stage::kDone:
+      return absl::OkStatus();
+  }
+  state_->waker = Activity::current()->MakeNonOwningWaker();
+  return Pending{};
+}
+
+}  // namespace grpc_core

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

@@ -0,0 +1,66 @@
+// Copyright 2022 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_CORE_LIB_PROMISE_SLEEP_H
+#define GRPC_CORE_LIB_PROMISE_SLEEP_H
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/iomgr/timer.h"
+#include "src/core/lib/promise/activity.h"
+#include "src/core/lib/promise/poll.h"
+
+namespace grpc_core {
+
+// Promise that sleeps until a deadline and then finishes.
+class Sleep {
+ public:
+  explicit Sleep(Timestamp deadline);
+  ~Sleep();
+
+  Sleep(const Sleep&) = delete;
+  Sleep& operator=(const Sleep&) = delete;
+  Sleep(Sleep&& other) noexcept : state_(other.state_) {
+    other.state_ = nullptr;
+  }
+  Sleep& operator=(Sleep&& other) noexcept {
+    std::swap(state_, other.state_);
+    return *this;
+  }
+
+  Poll<absl::Status> operator()();
+
+ private:
+  static void OnTimer(void* arg, grpc_error_handle error);
+
+  enum class Stage { kInitial, kStarted, kDone };
+  struct State {
+    explicit State(Timestamp deadline) : deadline(deadline) {}
+    RefCount refs{2};
+    const Timestamp deadline;
+    grpc_timer timer;
+    grpc_closure on_timer;
+    Mutex mu;
+    Stage stage ABSL_GUARDED_BY(mu) = Stage::kInitial;
+    Waker waker ABSL_GUARDED_BY(mu);
+    void Unref() {
+      if (refs.Unref()) delete this;
+    }
+  };
+  State* state_;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_PROMISE_SLEEP_H

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

@@ -0,0 +1,157 @@
+// 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_CORE_LIB_PROMISE_TRY_SEQ_H
+#define GRPC_CORE_LIB_PROMISE_TRY_SEQ_H
+
+#include <grpc/support/port_platform.h>
+
+#include <tuple>
+#include <utility>
+
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+#include "absl/types/variant.h"
+
+#include "src/core/lib/promise/detail/basic_seq.h"
+#include "src/core/lib/promise/detail/status.h"
+#include "src/core/lib/promise/poll.h"
+
+namespace grpc_core {
+
+namespace promise_detail {
+
+template <typename T, typename Ignored = void>
+struct TrySeqTraitsWithSfinae {
+  using UnwrappedType = T;
+  using WrappedType = absl::StatusOr<T>;
+  template <typename Next>
+  static auto CallFactory(Next* next, T&& value)
+      -> decltype(next->Once(std::forward<T>(value))) {
+    return next->Once(std::forward<T>(value));
+  }
+  template <typename F, typename Elem>
+  static auto CallSeqFactory(F& f, Elem&& elem, T&& value)
+      -> decltype(f(std::forward<Elem>(elem), std::forward<T>(value))) {
+    return f(std::forward<Elem>(elem), std::forward<T>(value));
+  }
+  template <typename Result, typename RunNext>
+  static Poll<Result> CheckResultAndRunNext(T prior, RunNext run_next) {
+    return run_next(std::move(prior));
+  }
+};
+
+template <typename T>
+struct TrySeqTraitsWithSfinae<absl::StatusOr<T>> {
+  using UnwrappedType = T;
+  using WrappedType = absl::StatusOr<T>;
+  template <typename Next>
+  static auto CallFactory(Next* next, absl::StatusOr<T>&& status)
+      -> decltype(next->Once(std::move(*status))) {
+    return next->Once(std::move(*status));
+  }
+  template <typename F, typename Elem>
+  static auto CallSeqFactory(F& f, Elem&& elem, absl::StatusOr<T> value)
+      -> decltype(f(std::forward<Elem>(elem), std::move(*value))) {
+    return f(std::forward<Elem>(elem), std::move(*value));
+  }
+  template <typename Result, typename RunNext>
+  static Poll<Result> CheckResultAndRunNext(absl::StatusOr<T> prior,
+                                            RunNext run_next) {
+    if (!prior.ok()) return Result(prior.status());
+    return run_next(std::move(prior));
+  }
+};
+// 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,
+           void>> {
+  using UnwrappedType = void;
+  using WrappedType = T;
+  template <typename Next>
+  static auto CallFactory(Next* next, T&&) -> decltype(next->Once()) {
+    return next->Once();
+  }
+  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 <>
+struct TrySeqTraitsWithSfinae<absl::Status> {
+  using UnwrappedType = void;
+  using WrappedType = absl::Status;
+  template <typename Next>
+  static auto CallFactory(Next* next, absl::Status&&)
+      -> decltype(next->Once()) {
+    return next->Once();
+  }
+  template <typename Result, typename RunNext>
+  static Poll<Result> CheckResultAndRunNext(absl::Status prior,
+                                            RunNext run_next) {
+    if (!prior.ok()) return Result(std::move(prior));
+    return run_next(std::move(prior));
+  }
+};
+
+template <typename T>
+using TrySeqTraits = TrySeqTraitsWithSfinae<T>;
+
+template <typename... Fs>
+using TrySeq = BasicSeq<TrySeqTraits, Fs...>;
+
+}  // namespace promise_detail
+
+// Try a sequence of operations.
+// * Run the first functor as a promise.
+// * Feed its success result into the second functor to create a promise,
+//   then run that.
+// * ...
+// * Feed the second-final success result into the final functor to create a
+//   promise, then run that, with the overall success result being that
+//   promises success result.
+// If any step fails, fail everything.
+// 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)...);
+}
+
+// Try a sequence of operations of unknown length.
+// Asynchronously:
+//   for (element in (begin, end)) {
+//     auto r = wait_for factory(element, argument);
+//     if (!r.ok()) return r;
+//     argument = *r;
+//   }
+//   return argument;
+template <typename Iter, typename Factory, typename Argument>
+promise_detail::BasicSeqIter<promise_detail::TrySeqTraits, Factory, Argument,
+                             Iter>
+TrySeqIter(Iter begin, Iter end, Argument argument, Factory factory) {
+  return promise_detail::BasicSeqIter<promise_detail::TrySeqTraits, Factory,
+                                      Argument, Iter>(
+      begin, end, std::move(factory), std::move(argument));
+}
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_PROMISE_TRY_SEQ_H