common/async: blocked_completion uses our redirect_error

Generalizing it to exceptions, etc.

Signed-off-by: Adam C. Emerson <[email protected]>

Author: adamemerson

src/common/async/blocked_completion.h

@@ -16,30 +16,44 @@
 #ifndef CEPH_COMMON_ASYNC_BLOCKED_COMPLETION_H
 #define CEPH_COMMON_ASYNC_BLOCKED_COMPLETION_H
 
+/// \file common/async/blocked_completion.h
+///
+/// \brief A blocking `completion token`
+///
+/// This completion token will actually hard-block your thread. Do not
+/// do so within an `io_context` thread.
+
 #include <condition_variable>
 #include <mutex>
 #include <optional>
 
 #include <boost/asio/async_result.hpp>
-#include <boost/asio/redirect_error.hpp>
+#include <boost/asio/disposition.hpp>
 
 #include <boost/system/error_code.hpp>
 
-#include <common/async/concepts.h>
+#include "common/async/redirect_error.h"
 
 namespace ceph::async {
-
-namespace bs = boost::system;
-
+/// A \ref `completion token` type that blocks the current thread
+/// until the operation completes.
+///
+/// \warning Keep deadlocks in mind. Do not use in threads that expect
+/// to be asynchronous.
 class use_blocked_t {
 public:
   use_blocked_t() = default;
 
-  auto operator [](bs::error_code& ec) const {
-    return boost::asio::redirect_error(use_blocked_t{}, ec);
+  /// Redirect the \ref `disposition` of the operation to a
+  /// variable. (A `disposition` is a concept generalizing error codes
+  /// and exceptions.)
+  template<boost::asio::disposition Disposition>
+  auto operator [](Disposition& d) const {
+    return redirect_error(use_blocked_t{}, d);
   }
 };
 
+/// The archetypical instance of `use_blocked_t`
 inline constexpr use_blocked_t use_blocked;
 
 namespace detail {

src/test/common/test_blocked_completion.cc

@@ -12,9 +12,14 @@
  *
  */
 
+#include "common/async/blocked_completion.h"
+
+#include <exception>
 
 #include <boost/asio/append.hpp>
+#include <boost/asio/awaitable.hpp>
 #include <boost/asio/async_result.hpp>
+#include <boost/asio/co_spawn.hpp>
 #include <boost/asio/io_context.hpp>
 #include <boost/asio/post.hpp>
 #include <boost/asio/steady_timer.hpp>
@@ -23,7 +28,7 @@
 
 #include <gtest/gtest.h>
 
-#include "common/async/blocked_completion.h"
+
 using namespace std::literals;
 
 namespace asio = boost::asio;
@@ -152,6 +157,44 @@ TEST(BlockedCompletion, AnError)
   EXPECT_EQ(sys::error_code(EDOM, sys::system_category()), ec);
 }
 
+TEST(BlockedCompletion, AnException)
+{
+  context_thread t;
+  std::exception_ptr e = nullptr;
+
+  ASSERT_FALSE(e);
+  ASSERT_THROW(asio::co_spawn(t.get_executor(),
+			      []() -> asio::awaitable<void> {
+				throw std::exception{};
+				co_return;
+			      }, async::use_blocked),
+	       std::exception);
+  // Have yet to divert an exception
+  ASSERT_FALSE(e);
+
+  ASSERT_NO_THROW(asio::co_spawn(t.get_executor(),
+				 []() -> asio::awaitable<void> {
+				   throw std::exception{};
+				   co_return;
+				 }, async::use_blocked[e]));
+  // Exception diverted
+  ASSERT_TRUE(e);
+
+  ASSERT_NO_THROW(asio::co_spawn(t.get_executor(),
+				 []() -> asio::awaitable<void> {
+				   co_return;
+				 }, async::use_blocked));
+  // Previously diverted exception not overwritten
+  ASSERT_TRUE(e);
+
+  ASSERT_NO_THROW(asio::co_spawn(t.get_executor(),
+				 []() -> asio::awaitable<void> {
+				   co_return;
+				 }, async::use_blocked[e]));
+  // Success diverted to overwrite previous exception
+  ASSERT_FALSE(e);
+}
+
 TEST(BlockedCompletion, MoveOnly)
 {
   context_thread t;