boost::asio::co_spawn does not propagate exception

Question

I'm dabbling in coroutines in respect to boost::asio, and I'm confused by exception handling. Judging by the examples in the docs, it looks like any 'fail' error_code is turned into an exception - so I hopefully assumed that any exception thrown would also be propagated back to the co_spawn call. But that doesn't appear to be case:

#define BOOST_ASIO_HAS_CO_AWAIT
#define BOOST_ASIO_HAS_STD_COROUTINE

#include <iostream>

#include <boost/asio/awaitable.hpp>
#include <boost/asio/co_spawn.hpp>
#include <boost/asio/detached.hpp>
#include <boost/asio/io_context.hpp>
#include <boost/asio/executor_work_guard.hpp>

namespace this_coro = boost::asio::this_coro;

boost::asio::awaitable<void> async_op()
{
    std::cout << "About to throw" << std::endl;
    throw std::runtime_error{"Bang!"};
}

int main()
{
    auto ctx = boost::asio::io_context{};
    auto guard = boost::asio::make_work_guard(ctx.get_executor());

    boost::asio::co_spawn(ctx, async_op, boost::asio::detached);

    ctx.run();
}

If this is ran in a debugger, you can see the exception being thrown, but then it just seems to hang. Pausing the debugger shows that the ctx.run() is waiting for new work (due to the executor_work_guard). So it looks like something inside boost::asio has silently swallowed the exception.

As an experiment, I switched the async operation to use boost::asio library calls:

boost::asio::awaitable<void> async_op()
{
    auto executor = co_await this_coro::executor;
    auto socket = boost::asio::ip::tcp::socket{executor};

    std::cout << "Starting resolve" << std::endl;
    auto resolver = boost::asio::ip::tcp::resolver{executor};
    const auto endpoints = co_await resolver.async_resolve("localhost",
                                                           "4444",
                                                           boost::asio::use_awaitable);



    std::cout << "Starting connect (num endpoints: " << endpoints.size() << ")" << std::endl;
    co_await boost::asio::async_connect(socket, endpoints, boost::asio::use_awaitable);
    std::cout << "Exited" << std::endl;
}

I don't have a server running on port 4444, so this should fail immediately - and it does but silently. Pausing the debugger shows that it's stuck in epoll waiting for something (I'm on Linux).

Swapping the async_connect CompletionToken to a boost::asio::redirect_error shows that the operation is failing:

co_await boost::asio::async_connect(socket,
                                    endpoints, 
                                    boost::asio::redirect_error(boost::asio::use_awaitable, ec));
std::cout << "Exited: " << ec.message() << std::endl;

Yields:

Starting resolve
Starting connect (num endpoints: 1)
Exited: Connection refused

So how do I propagate exceptions, and create them from error_codes, out of coroutines in boost::asio?

Answer 1

boost::asio::co_spawn creates a separate thread. This means that exceptions are not propagated. You can read more about this here:

• Will main() catch exceptions thrown from threads?
• How can I propagate exceptions between threads?

But co_spawn supports a completion handler with the signature void(std::exception_ptr, R). In your example you used boost::asio::detached which means the completion result is ignored. To propagate it simply write a custom handler.