Integrating websocket server into existing game loop

[JPGygax68]

I wanted to avoid needing a background thread, and was able after some experimenting to make this work by calling uv_run(uv_default_loop(), UV_RUN_NOWAIT); from inside the game loop.

First, I'd like to know - is this approach correct, or am I inviting big trouble ?

Second, I spent a few hours tracking down an annoying little problem with the loop. I found that my code would refuse to work after I had done what I thought to be some simple and straightforward restructuring.
It turned out the the problem was uWS::Loop::get(). This method gets called as part of the construction of a TemplatedApp, and it gets called without a parameter, which means it will return a uWS loop that isn't associated with any UV loop. However in order to be able to use uv_run() as described above, I need the uWS loop of my main thread to be associated with the UV loop returned by uv_default_loop().

I worked around the problem by having the ctor of a static helper class instance call uWS::Loop::get(uv_default_loop()) as soon as possible, which will establish the required association. But, there is no guarantee that no other code can call uWS::Loop::get() even sooner, so my "solution" is nothing but an unreliable hack.

Ideas?

[ghost]

That's an okay solution. You don't need to worry about loop::get. Initializing it like you do is intended. Loop::get is lazily initialized so you can even put your initialization in main because nothing with call it before you do.

[ghost]

This is how we do it ourselves in the Node.js addon: https://github.com/uNetworking/uWebSockets.js/blob/8ba1edc0bbd05f97f6b1c8a03fd93be89bec458d/src/addon.cpp#L401

[JPGygax68]

In case it could be useful for someone else, here's my current class:

(It's called RC_Channel because the idea is to remote control an Actor in Unreal.)

DISCLAIMER: this is an early version and far from production-ready.

Header file:

#pragma once

#include <string_view>
#include <functional>
#include <vector>
#include <uWebSockets/App.h>
#include <libusockets.h>


class RC_Channel {

public:

    using Incoming_Message_Handler = std::function<void(std::string_view)>;

    RC_Channel();

    auto listen(int port) -> RC_Channel&;

    void close();

    auto on_incoming_message(Incoming_Message_Handler) -> RC_Channel&;

    auto send_message(std::string_view) -> RC_Channel&;

    void run_once();

private:
    
    struct Per_Connection_Data { };
    using websocket_t = uWS::WebSocket<false, true, Per_Connection_Data>;

    uv_loop_t                   *_uv_loop = nullptr;
    Incoming_Message_Handler    _incoming_message_handler;
    us_listen_socket_t          *listen_socket = nullptr;
    uWS::TemplatedApp<false>    ws_app;
    uWS::Loop                   *ws_loop = nullptr;
    websocket_t                 *connection = nullptr;
};

Source file:

#include <cassert>
#include <uWebSockets/App.h>
#include <uv.h>

#include "./rc_channel.h"


static class Initializer {
public:
    Initializer() {
        (void) uWS::Loop::get(uv_default_loop());
    }
} initializer;


RC_Channel::RC_Channel():
    ws_loop{ uWS::Loop::get(uv_default_loop()) },
    ws_app{
        uWS::App().ws<Per_Connection_Data>("/*", {
            .open = [&](auto* ws) {
                std::cout << "Opening connection" << std::endl;
                assert(!connection);
                connection = ws;
            },
            .message = [this](auto* ws, std::string_view message, uWS::OpCode opCode) {
                // std::cout << "Incoming message: " << message << std::endl;
                if (_incoming_message_handler)
                    _incoming_message_handler(message);
            },
           .drain = [](auto* /*ws*/) {
                /* Check ws->getBufferedAmount() here */
            },
            .ping = [](auto* /*ws*/, std::string_view) {
                /* Not implemented yet */
                std::cout << "Ping" << std::endl;
            },
            .pong = [](auto* /*ws*/, std::string_view) {
                /* Not implemented yet */
                std::cout << "Pong" << std::endl;
            },
            .close = [&](auto* ws, int /*code*/, std::string_view /*message*/) {
                /* You may access ws->getUserData() here */
                std::cout << "Connection closed" << std::endl;
                assert(connection);
                connection = nullptr;
            }
        })
    }
{
}

auto RC_Channel::listen(int port) -> RC_Channel&
{
    ws_app
        .listen(port, 
            [&](auto* listen_socket_) {
                if (listen_socket_) {
                    std::cout << "Listening on port " << port << std::endl;
                    listen_socket = listen_socket_;
                }
                else {
                    std::cout << "No listen socket!" << std::endl;
                }
            });

    return *this;
}

void RC_Channel::close()
{
    if (connection) {
        ws_loop->defer([&]() { connection->close(); });
    }
    us_listen_socket_close(0, listen_socket);
}

auto RC_Channel::on_incoming_message(Incoming_Message_Handler handler) -> RC_Channel&
{
    assert(!_incoming_message_handler);
    _incoming_message_handler = handler;

    return *this;
}

auto RC_Channel::send_message(std::string_view msg) -> RC_Channel&
{
    if (connection) {
        connection->send(msg, uWS::TEXT, false);
    }

    return *this;
}

void RC_Channel::run_once()
{
    uv_run(uv_default_loop(), UV_RUN_NOWAIT);
}

[ghost]

You can't capture an std::string_view by copy if using defer. The string_view will most likely point to invalid memory.

[ghost]

You shouldn't even need any defer calls since the whole point of polling the loop is to not have separate threads.

[JPGygax68]

Thanks for reviewing @alexhultman-2fa, I corrected the code.