Boost.beast websocket - How to make a pending async_read() queue/work for io_context.run()?

Okay, the simplest thing is to add a work_guard. The more logical thing to do is to have a thread_pool as the execution context.

Slap a work guard on it:

boost::asio::io_context ioc;
boost::asio::executor_work_guard<boost::asio::io_context::executor_type>
    work = make_work_guard(ioc.get_executor());

(or simply auto work = make_work_guard(...);).

If at some point you want the run to return, release the work guard:

work.reset();

A Thread Pool

The previous sort of skimped over the "obvious" fact that you'd need another thread to either run() the service or to reset() the work guard.

Instead, I'd suggest to leave the running of the thread to Asio in the first place:

boost::asio::thread_pool ioc(1);

This, like io_context is an execution context:

int main()
{
    // +-----------------------------+
    // | Get azure access token      |
    // +-----------------------------+
    static std::string const accessToken =
        "wss://sehe797979.webpubsub.azure.com/client/hubs/"
        "Hub?access_token=*************************************"
        "**********************************************************************"
        "**********************************************************************"
        "**********************************************************************"
        "************************************************************";
    // get_access_token();

    // +--------------------------+
    // | Websocket payload struct |
    // +--------------------------+
    struct Payload payload = {0, "", "text", "test", "joinGroup"};

    // +---------------------------------+
    // | Websocket connection parameters |
    // +---------------------------------+
    std::string protocol = "wss://";
    std::string host     = "sehe797979.webpubsub.azure.com";
    std::string port     = "443";
    std::string text     = json_payload(payload);

    auto endpointSubstringIndex = protocol.length() + host.length();

    // Endpoint
    std::string endpoint = accessToken.substr(endpointSubstringIndex);
    //std::cout << "Endpoint : " << endpoint << std::endl;
    
    // The io_context is required for all I/O
    boost::asio::thread_pool ioc(1);

    // The SSL context is required, and holds certificates
    ssl::context ctx{ssl::context::sslv23_client};

    // This holds the root certificate used for verification
    load_root_certificates(ctx);

    // Launch the asynchronous operation
    std::shared_ptr<session> ws_session =
        std::make_shared<session>(ioc.get_executor(), ctx);
    ws_session->open(host, port, endpoint);

    // Run the I/O service. The call will return when the socket is closed.
    // Change the payload type
    payload.type = "sendToGroup";

    // +--------------+
    // | Send Message |
    // +--------------+
    // Get the input and update the payload data
    while (getline(std::cin, payload.data)) {
        // Send the data over WSS
        ws_session->write(json_payload(payload));
    }

    ioc.join();
}

This requires minimal changes to the session constructor to take an executor instead of the io_context&:

template <typename Executor>
explicit session(Executor executor, ssl::context& ctx)
    : resolver_(executor)
    , ws_(executor, ctx)
{
}

Here's a fully self-contained compiling demo Live On Coliru