grpc 1.60.0.pre1 → 1.61.0.pre2

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

@@ -25,7 +25,6 @@
 #include "absl/strings/str_join.h"
 
 #include "src/core/lib/gprpp/atomic_utils.h"
-#include "src/core/lib/gprpp/crash.h"
 
 namespace grpc_core {
 
@@ -84,7 +83,23 @@ class FreestandingActivity::Handle final : public Wakeable {
   }
 
   void WakeupAsync(WakeupMask) override ABSL_LOCKS_EXCLUDED(mu_) {
-    Crash("not implemented");
+    mu_.Lock();
+    // Note that activity refcount can drop to zero, but we could win the lock
+    // against DropActivity, so we need to only increase activities refcount if
+    // it is non-zero.
+    if (activity_ && activity_->RefIfNonzero()) {
+      FreestandingActivity* activity = activity_;
+      mu_.Unlock();
+      // Activity still exists and we have a reference: wake it up, which will
+      // drop the ref.
+      activity->WakeupAsync(0);
+    } else {
+      // Could not get the activity - it's either gone or going. No need to wake
+      // it up!
+      mu_.Unlock();
+    }
+    // Drop the ref to the handle (we have one ref = one wakeup semantics).
+    Unref();
   }
 
   void Drop(WakeupMask) override { Unref(); }

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

@@ -32,7 +32,6 @@
 #include <grpc/support/log.h>
 
 #include "src/core/lib/gprpp/construct_destruct.h"
-#include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/gprpp/no_destruct.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/sync.h"
@@ -502,7 +501,7 @@ class PromiseActivity final
   // the activity to an external threadpool to run. If the activity is already
   // running on this thread, a note is taken of such and the activity is
   // repolled if it doesn't complete.
-  void Wakeup(WakeupMask) final {
+  void Wakeup(WakeupMask m) final {
     // If there is an active activity, but hey it's us, flag that and we'll loop
     // in RunLoop (that's calling from above here!).
     if (Activity::is_current()) {
@@ -511,6 +510,10 @@ class PromiseActivity final
       WakeupComplete();
       return;
     }
+    WakeupAsync(m);
+  }
+
+  void WakeupAsync(WakeupMask) final {
     if (!wakeup_scheduled_.exchange(true, std::memory_order_acq_rel)) {
       // Can't safely run, so ask to run later.
       this->ScheduleWakeup();
@@ -520,8 +523,6 @@ class PromiseActivity final
     }
   }
 
-  void WakeupAsync(WakeupMask) final { Crash("not implemented"); }
-
   // Drop a wakeup
   void Drop(WakeupMask) final { this->WakeupComplete(); }
 

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

@@ -0,0 +1,80 @@
+// 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_ALL_OK_H
+#define GRPC_SRC_CORE_LIB_PROMISE_ALL_OK_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 {
+
+// Traits object to pass to JoinState
+template <typename Result>
+struct AllOkTraits {
+  template <typename T>
+  using ResultType = Result;
+  template <typename T>
+  static bool IsOk(const T& x) {
+    return IsStatusOk(x);
+  }
+  static Empty Unwrapped(StatusFlag) { return Empty{}; }
+  static Empty Unwrapped(absl::Status) { return Empty{}; }
+  template <typename R, typename T>
+  static R EarlyReturn(T&& x) {
+    return StatusCast<R>(std::forward<T>(x));
+  }
+  template <typename... A>
+  static Result FinalReturn(A&&...) {
+    return Result{};
+  }
+};
+
+// Implementation of AllOk combinator.
+template <typename Result, typename... Promises>
+class AllOk {
+ public:
+  explicit AllOk(Promises... promises) : state_(std::move(promises)...) {}
+  auto operator()() { return state_.PollOnce(); }
+
+ private:
+  JoinState<AllOkTraits<Result>, Promises...> state_;
+};
+
+}  // namespace promise_detail
+
+// Run all promises.
+// If any fail, cancel the rest and return the failure.
+// If all succeed, return Ok.
+template <typename Result, typename... Promises>
+auto AllOk(Promises... promises) {
+  return promise_detail::AllOk<Result, Promises...>(std::move(promises)...);
+}
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_LIB_PROMISE_ALL_OK_H