asio: awaitable operator|| don't return when timer expires

The attached code, extracted from a larger codebase, has behavior that I cannot
explain.

The problem is in the run function where I would like to wait up to a maximum
time that the awaitable returned by async_initiate completes.

The async operation initiated by async_initiate never completes (in this
example because I never call the handler, in the real program because it is
waiting for a network packet), but the coroutine is stuck on the co_await even
if the timer expires.

The asio version is the one shipped with boost 1.81.0

#include <boost/asio/any_completion_handler.hpp>
#include <boost/asio/any_io_executor.hpp>
#include <boost/asio/async_result.hpp>
#include <boost/asio/co_spawn.hpp>
#include <boost/asio/detached.hpp>
#include <boost/asio/experimental/awaitable_operators.hpp>
#include <boost/asio/io_context.hpp>
#include <boost/asio/ip/udp.hpp>
#include <boost/asio/steady_timer.hpp>
#include <boost/asio/use_awaitable.hpp>
#include <iostream>

namespace asio = boost::asio;
using namespace asio::experimental::awaitable_operators;

// this function exists only to keep the io_context busy
asio::awaitable<void> busy() {
    auto exec = co_await asio::this_coro::executor;

    using asio::ip::udp;
    auto socket = udp::socket(exec, udp::endpoint(udp::v4(), 40000));

    uint8_t msg[1024];
    std::cout << "reading from socket...\n";
    co_await socket.async_receive(asio::buffer(msg), asio::use_awaitable);
}

std::optional<asio::any_completion_handler<void(int)>> stored;

asio::awaitable<void> run() {
    std::cout << "run() called\n";

    auto exec = co_await asio::this_coro::executor;
    asio::steady_timer timer{exec, std::chrono::seconds(2)};

    auto initiate = [&]([[maybe_unused]] asio::any_completion_handler<void(int)> handler) {
        // don't call the handler on purpose
        //
        // move it on `stored` only for the sake of this example, to rule out
        // any side-effect of the handler destructor
        stored = std::move(handler);
    };

    co_await (asio::async_initiate<const asio::use_awaitable_t<>, void(int)>(initiate, asio::use_awaitable)
              || timer.async_wait(asio::use_awaitable));
    std::cout << "done\n";
}

int main() {
    asio::io_context io;

    asio::co_spawn(io, busy, asio::detached);
    asio::co_spawn(io, run, asio::detached);
    io.run();
}

I know that operator|| is waiting for "a success" but this should not be the cause of the problem because the time completes (or should complete) without an error

> The async operation initiated by async_initiate never completes (in this example because I never call the handler,

If you don't complete, you can't witness that it completes with operation_aborted either.

> in the real program because it is waiting for a network packet), but the coroutine is stuck on the co_await even if the timer expires.

Let's put that to the test:

Live On Coliru

#include <boost/asio.hpp>
#include <boost/asio/experimental/awaitable_operators.hpp>
#include <iostream>
namespace asio = boost::asio;
using namespace asio::experimental::awaitable_operators;
using namespace std::chrono_literals;
asio::awaitable<void> busy() {
auto exec = co_await asio::this_coro::executor;
using asio::ip::udp;
try {
while (true) {
auto socket = udp::socket(exec, udp::endpoint(udp::v4(), 40000));
uint8_t msg[1024];
std::cout << "reading from socket..." << std::endl;
auto n = co_await socket.async_receive(asio::buffer(msg), asio::use_awaitable);
std::cout << "received " << n << " bytes" << std::endl;
}
} catch (boost::system::system_error const& se) {
auto const& ec = se.code();
std::cout << "receive failed: " << ec.message() << " at " << ec.location() << std::endl;
}
}
asio::awaitable<void> run() {
std::cout << "run() called\n";
auto exec = co_await asio::this_coro::executor;
asio::steady_timer timer{exec, 2s};
co_await (busy() || timer.async_wait(asio::use_awaitable));
std::cout << "done\n";
}
int main() {
asio::io_context io;
asio::co_spawn(io, run, asio::detached);
io.run();
}

Works as advertised. If you prefer to avoid exception handling, you can use as_tuple or redirect_error:

asio::awaitable<void> busy() {
auto exec = co_await asio::this_coro::executor;
for (error_code ec; !ec.failed();) {
auto socket = asio::ip::udp::socket{exec, {{}, 40'000}};
uint8_t msg[1024];
std::cout << "reading from socket..." << std::endl;
auto n = co_await socket.async_receive(asio::buffer(msg), redirect_error(asio::use_awaitable, ec));
std::cout << "received " << n << " bytes (" << ec.message() << ")" << std::endl;
}
}

Your Own Async Initiatiation?

Your own IO objects/operations may not support cancellation. If you want, implement is on cancellation_slot. Let's also show how to use a work guard to keep the execution context alive:

template <typename Token>
auto async_stuff(Token token) {
auto initiate = [](auto handler) {
auto cs   = asio::get_associated_cancellation_slot(handler);
auto work = make_work_guard(asio::get_associated_executor(handler));
cs.assign([work, h = std::move(handler)](asio::cancellation_type type) mutable {
using ct = asio::cancellation_type;
if (ct::none != (type & ct::terminal))
std::cout << "cancellation_type terminal" << std::endl;
if (ct::none != (type & ct::partial))
std::cout << "cancellation_type partial" << std::endl;
if (ct::none != (type & ct::total))
std::cout << "cancellation_type total" << std::endl;
work.reset();
std::move(h)(asio::error::operation_aborted, -1);
});
};
return asio::async_initiate<Token, void(error_code, int)>(initiate, token);
}

You can bind your cancellation slot like this:

Live

int main() {
asio::thread_pool io(1);
asio::cancellation_signal cancel;
auto token = asio::bind_cancellation_slot(cancel.slot(), asio::use_awaitable);
asio::co_spawn(io, async_stuff(token), asio::detached);
using namespace std::chrono_literals;
std::this_thread::sleep_for(2s);
cancel.emit(asio::cancellation_type::terminal);
io.join();
}

The experimental operators use parallel_group which use cancellation slots under the hood.