grpc 1.50.0-x86_64-linux → 1.51.0-x86_64-linux

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

@@ -17,6 +17,8 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "absl/status/status.h"
+
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/error.h"
@@ -36,7 +38,7 @@ class ExecCtxWakeupScheduler {
           static_cast<ActivityType*>(arg)->RunScheduledWakeup();
         },
         activity, grpc_schedule_on_exec_ctx);
-    ExecCtx::Run(DEBUG_LOCATION, &closure_, GRPC_ERROR_NONE);
+    ExecCtx::Run(DEBUG_LOCATION, &closure_, absl::OkStatus());
   }
 
  private:

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

@@ -0,0 +1,129 @@
+// 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_FOR_EACH_H
+#define GRPC_CORE_LIB_PROMISE_FOR_EACH_H
+
+#include <grpc/support/port_platform.h>
+
+#include <utility>
+
+#include "absl/status/status.h"
+#include "absl/types/variant.h"
+
+#include "src/core/lib/promise/detail/promise_factory.h"
+#include "src/core/lib/promise/poll.h"
+
+namespace grpc_core {
+
+namespace for_each_detail {
+
+// Done creates statuses for the end of the iteration. It's templated on the
+// type of the result of the ForEach loop, so that we can introduce new types
+// easily.
+template <typename T>
+struct Done;
+
+template <>
+struct Done<absl::Status> {
+  static absl::Status Make() { return absl::OkStatus(); }
+};
+
+template <typename Reader, typename Action>
+class ForEach {
+ private:
+  using ReaderNext = decltype(std::declval<Reader>().Next());
+  using ReaderResult =
+      typename PollTraits<decltype(std::declval<ReaderNext>()())>::Type;
+  using ReaderResultValue = typename ReaderResult::value_type;
+  using ActionFactory =
+      promise_detail::RepeatedPromiseFactory<ReaderResultValue, Action>;
+  using ActionPromise = typename ActionFactory::Promise;
+
+ public:
+  using Result =
+      typename PollTraits<decltype(std::declval<ActionPromise>()())>::Type;
+  ForEach(Reader reader, Action action)
+      : reader_(std::move(reader)),
+        action_factory_(std::move(action)),
+        state_(reader_.Next()) {}
+
+  ForEach(const ForEach&) = delete;
+  ForEach& operator=(const ForEach&) = delete;
+  // noexcept causes compiler errors on older gcc's
+  // NOLINTNEXTLINE(performance-noexcept-move-constructor)
+  ForEach(ForEach&&) = default;
+  // noexcept causes compiler errors on older gcc's
+  // NOLINTNEXTLINE(performance-noexcept-move-constructor)
+  ForEach& operator=(ForEach&&) = default;
+
+  Poll<Result> operator()() { return absl::visit(CallPoll{this}, state_); }
+
+ private:
+  struct InAction {
+    InAction(ActionPromise promise, ReaderResult result)
+        : promise(std::move(promise)), result(std::move(result)) {}
+    ActionPromise promise;
+    ReaderResult result;
+  };
+  Reader reader_;
+  ActionFactory action_factory_;
+  absl::variant<ReaderNext, InAction> state_;
+
+  // Call the inner poll function, and if it's finished, start the next
+  // iteration.
+  struct CallPoll {
+    ForEach* const self;
+
+    Poll<Result> operator()(ReaderNext& reader_next) {
+      auto r = reader_next();
+      if (auto* p = absl::get_if<kPollReadyIdx>(&r)) {
+        if (p->has_value()) {
+          auto action = self->action_factory_.Make(std::move(**p));
+          return (*this)(self->state_.template emplace<InAction>(
+              std::move(action), std::move(*p)));
+        } else {
+          return Done<Result>::Make();
+        }
+      }
+      return Pending();
+    }
+
+    Poll<Result> operator()(InAction& in_action) {
+      auto r = in_action.promise();
+      if (auto* p = absl::get_if<kPollReadyIdx>(&r)) {
+        if (p->ok()) {
+          return (*this)(
+              self->state_.template emplace<ReaderNext>(self->reader_.Next()));
+        } else {
+          return std::move(*p);
+        }
+      }
+      return Pending();
+    }
+  };
+};
+
+}  // namespace for_each_detail
+
+/// For each item acquired by calling Reader::Next, run the promise Action.
+template <typename Reader, typename Action>
+for_each_detail::ForEach<Reader, Action> ForEach(Reader reader, Action action) {
+  return for_each_detail::ForEach<Reader, Action>(std::move(reader),
+                                                  std::move(action));
+}
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_PROMISE_FOR_EACH_H

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

@@ -76,14 +76,14 @@ struct LoopTraits<absl::StatusOr<LoopCtl<absl::Status>>> {
 template <typename F>
 class Loop {
  private:
-  using Factory = promise_detail::PromiseFactory<void, F>;
-  using PromiseType = decltype(std::declval<Factory>().Repeated());
+  using Factory = promise_detail::RepeatedPromiseFactory<void, F>;
+  using PromiseType = decltype(std::declval<Factory>().Make());
   using PromiseResult = typename PromiseType::Result;
 
  public:
   using Result = typename LoopTraits<PromiseResult>::Result;
 
-  explicit Loop(F f) : factory_(std::move(f)), promise_(factory_.Repeated()) {}
+  explicit Loop(F f) : factory_(std::move(f)), promise_(factory_.Make()) {}
   ~Loop() { promise_.~PromiseType(); }
 
   Loop(Loop&& loop) noexcept
@@ -104,7 +104,7 @@ class Loop {
         auto lc = LoopTraits<PromiseResult>::ToLoopCtl(*p);
         if (absl::holds_alternative<Continue>(lc)) {
           promise_.~PromiseType();
-          new (&promise_) PromiseType(factory_.Repeated());
+          new (&promise_) PromiseType(factory_.Make());
           continue;
         }
         //  - otherwise there's our result... return it out.
@@ -118,7 +118,9 @@ class Loop {
 
  private:
   GPR_NO_UNIQUE_ADDRESS Factory factory_;
-  GPR_NO_UNIQUE_ADDRESS union { GPR_NO_UNIQUE_ADDRESS PromiseType promise_; };
+  GPR_NO_UNIQUE_ADDRESS union {
+    GPR_NO_UNIQUE_ADDRESS PromiseType promise_;
+  };
 };
 
 }  // namespace promise_detail

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

@@ -0,0 +1,87 @@
+// 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_MAP_PIPE_H
+#define GRPC_CORE_LIB_PROMISE_MAP_PIPE_H
+
+#include <grpc/support/port_platform.h>
+
+#include "absl/status/status.h"
+
+#include "src/core/lib/promise/detail/promise_factory.h"
+#include "src/core/lib/promise/for_each.h"
+#include "src/core/lib/promise/map.h"
+#include "src/core/lib/promise/pipe.h"
+
+namespace grpc_core {
+
+// Apply a (possibly async) mapping function to src, and output into dst.
+//
+// In psuedo-code:
+// for each element in wait_for src.Next:
+//   x = wait_for filter_factory(element)
+//   wait_for dst.Push(x)
+template <typename T, typename Filter>
+auto MapPipe(PipeReceiver<T> src, PipeSender<T> dst, Filter filter_factory) {
+  return ForEach(
+      std::move(src),
+      [filter_factory = promise_detail::RepeatedPromiseFactory<T, Filter>(
+           std::move(filter_factory)),
+       dst = std::move(dst)](T t) mutable {
+        return TrySeq(filter_factory.Make(std::move(t)), [&dst](T t) {
+          return Map(dst.Push(std::move(t)), [](bool successful_push) {
+            if (successful_push) {
+              return absl::OkStatus();
+            }
+            return absl::CancelledError();
+          });
+        });
+      });
+}
+
+// Helper to intecept a pipe and apply a mapping function.
+// Each of the `Intercept` constructors will take a PipeSender or PipeReceiver,
+// construct a new pipe, and then replace the passed in pipe with its new end.
+// In this way it can interject logic per-element.
+// Next, the TakeAndRun function will return a promise that can be run to apply
+// a mapping promise to each element of the pipe.
+template <typename T>
+class PipeMapper {
+ public:
+  static PipeMapper Intercept(PipeSender<T>& intercept_sender) {
+    PipeMapper<T> r;
+    r.interceptor_.sender.Swap(&intercept_sender);
+    return r;
+  }
+
+  static PipeMapper Intercept(PipeReceiver<T>& intercept_receiver) {
+    PipeMapper<T> r;
+    r.interceptor_.receiver.Swap(&intercept_receiver);
+    return r;
+  }
+
+  template <typename Filter>
+  auto TakeAndRun(Filter filter) {
+    return MapPipe(std::move(interceptor_.receiver),
+                   std::move(interceptor_.sender), std::move(filter));
+  }
+
+ private:
+  PipeMapper() = default;
+  Pipe<T> interceptor_;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_PROMISE_MAP_PIPE_H

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

@@ -0,0 +1,19 @@
+// 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/pipe.h"
+
+grpc_core::DebugOnlyTraceFlag grpc_trace_promise_pipe(false, "promise_pipe");