From fc3d1b2f014794532631f5d4b380ca387721948c Mon Sep 17 00:00:00 2001
From: =?utf8?q?Rados=C5=82aw=20Zarzy=C5=84ski?= <rzarzyns@redhat.com>
Date: Wed, 30 Mar 2022 15:02:20 +0200
Subject: [PATCH] crimson/common: let errorator's handlers to conditionally
 forward errors
MIME-Version: 1.0
Content-Type: text/plain; charset=utf8
Content-Transfer-Encoding: 8bit

The use case is like the following one:

```diff
diff --git a/src/crimson/osd/replicated_recovery_backend.cc b/src/crimson/osd/replicated_recovery_backend.cc
index a96f1b8dd2b..055add2e407 100644
--- a/src/crimson/osd/replicated_recovery_backend.cc
+++ b/src/crimson/osd/replicated_recovery_backend.cc
@@ -516,10 +516,14 @@ ReplicatedRecoveryBackend::read_object_for_push_op(
       recovered_to = push_op->data_included.range_end();
     }
     return seastar::make_ready_future<uint64_t>(recovered_to);
-  }, PGBackend::read_errorator::all_same_way([](auto e) {
+  }, PGBackend::read_errorator::all_same_way([](auto e, auto&& e_raw) -> PGBackend::read_errorator::future<uint64_t> {
     logger().debug("build_push_op: read exception");
-    return seastar::make_exception_future<uint64_t>(e);
-  }));
+    if (42) {
+      return std::move(e_raw);
+    } else {
+      return seastar::make_exception_future<uint64_t>(e);
+    }
+  })).handle_error_interruptible(PGBackend::read_errorator::discard_all{});
 }

 RecoveryBackend::interruptible_future<>
```

Signed-off-by: Radosław Zarzyński <rzarzyns@redhat.com>
---
 src/crimson/common/errorator.h | 18 ++++++++++++++----
 1 file changed, 14 insertions(+), 4 deletions(-)

diff --git a/src/crimson/common/errorator.h b/src/crimson/common/errorator.h
index 5f817eec918..71dddf2b5a1 100644
--- a/src/crimson/common/errorator.h
+++ b/src/crimson/common/errorator.h
@@ -131,8 +131,14 @@ struct unthrowable_wrapper : error_t<unthrowable_wrapper<ErrorT, ErrorV>> {
   static auto handle(Func&& func) {
     return [
       func = std::forward<Func>(func)
-    ] (const unthrowable_wrapper&) mutable -> decltype(auto) {
-      if constexpr (std::is_invocable_v<Func, ErrorT>) {
+    ] (const unthrowable_wrapper& raw_error) mutable -> decltype(auto) {
+      if constexpr (std::is_invocable_v<Func, ErrorT, decltype(raw_error)>) {
+	// check whether the handler wants to take the raw error object which
+	// would be the case if it wants conditionally handle-or-pass-further.
+        return std::invoke(std::forward<Func>(func),
+                           ErrorV,
+                           std::move(raw_error));
+      } else if constexpr (std::is_invocable_v<Func, ErrorT>) {
         return std::invoke(std::forward<Func>(func), ErrorV);
       } else {
         return std::invoke(std::forward<Func>(func));
@@ -197,13 +203,17 @@ struct stateful_error_t : error_t<stateful_error_t<ErrorT>> {
     return [
       func = std::forward<Func>(func)
     ] (stateful_error_t<ErrorT>&& e) mutable -> decltype(auto) {
-      if constexpr (std::is_invocable_v<Func, void>) {
+      if constexpr (std::is_invocable_v<Func>) {
         return std::invoke(std::forward<Func>(func));
       }
       try {
         std::rethrow_exception(e.ep);
       } catch (const ErrorT& obj) {
-        return std::invoke(std::forward<Func>(func), obj);
+        if constexpr (std::is_invocable_v<Func, decltype(obj), decltype(e)>) {
+          return std::invoke(std::forward<Func>(func), obj, e);
+	} else if constexpr (std::is_invocable_v<Func, decltype(obj)>) {
+          return std::invoke(std::forward<Func>(func), obj);
+	}
       }
       ceph_abort_msg("exception type mismatch -- impossible!");
     };
-- 
2.39.5