How do I write my own async operations with (non-boost) Asio? - c++

Question

I want to write my own asynchronous function based on Asio 1.19.2 (without boost).
The motivation is to create an interface that works with a JSON-RPC-like protocol (not JSON-RPC exactly).
On the socket it would look something like
--> { "method": "subtract", "params": [42, 23], "id": 1 }
<-- ... some irrelevant notifications, etc.
<-- { "result": 19, "id": 1 } <-- ID matches initial call
I have this figured out using std::futures (without Asio). That method signature is something like:
// near useless, because futures don't allow for continuation
std::future<std::string> json_rpc(std::string method, json::array args);
To implement that, I just needed to:
Keep the socket open in the background (it could also be passed into the method or whatever).
Store a set of pending promises.
When you call json_rpc, make a new promise, add it to the set, return the get_future().
Send the RPC on the socket.
If you get a { "result" ... } message on the socket, find the pending future with that ID and set_value() its promise with the result.
How do I translate this future-based approach into an asio-based one, that has a similar interface to e.g. async_read_until? In other words, I want to implement something like:
template <typename CompletionToken>
void async_json_rpc(std::string method, json::array args, CompletionToken&& completion_token);
I found this tutorial from beast, but it uses Boost.Beast, seems outdated, and the only asynchronous part of it is where it calls async_read_some. My code is not really able to make use of these asio async_ "primitives", since my completion handler needs to be invoked at some time outside of the OS's control.
I also found these examples from the asio docs, but they have the same limitation of just wrapping other async_ calls. They also get increasingly unmanageably complex, for application code.
The core of my question, I suppose, is: I have an async function that basically works like it uses asio::use_future as its CompletionToken. How do I let it use any kind of CompletionToken? What is the promise.set_value() equivallent for an asio completion handler?
I'm very interested in simple to understand solutions, so that I'm not the only one on my team able to maintain these sorts of functions.
To clarify further (from my comments):
I already have "servicing completions from a service thread" implemented, but I only support futures (if I was writing an asio async method, its as if I've only made the asio::use_future overload). I'm asking how to support CompletionHandlers in general—i.e. how to write the other async_* overloads that can take lambdas or yield_contexts.

Answer 1

I think you are asking how to implement the "strand"? I've done things similar to this.
In general, you need a worker thread that services a queue. It will loop and execute each item in the queue, but then sleep when it is empty. Adding something to the queue will signal the thread to wake up, if necessary.
A fancier variation is to use a thread pool and common queue, pruning excess threads if you have too many and creating more if there is too much work for the existing threads. Optimally this requires OS support (I've implemented this for Windows Completion Ports).
When you want to do something async, you put the promise on the queue rather than starting a dedicated thread for that.
Or... were you looking at coroutines, to do co_await calls in C++?

Answer 2

You can not write custom async_ overloads in Asio. Asio is not a general-purpose async library, it's a wrapper around epoll/kqueue/IOCP and as such is limited to non-blocking socket I/O.
The good news is you don't need that, as both std::future<std::string> json_rpc(...) as well as void async_json_rpc (..., CompletionCallback) can be implemented using the normal Asio async_read API - you either resolve the promise or invoke your callback in the completion handler of async_read that reads the RPC response from the socket.