WebSocketServer.h

#pragma once
 
#include "../../utils/scheduler.h"
#include "WebSocketProtocol.h"
 
#include <functional>
#include <map>
#include <memory>
#include <optional>
#include <thread>
 
#include <nlohmann/json.hpp>
#include <websocketpp/config/asio_no_tls.hpp>
#include <websocketpp/server.hpp>
 
namespace net {
namespace websocket {
 
using nlohmann::json;
using websocketpp::connection_hdl;
 
typedef std::shared_ptr<websocketpp::config::core::message_type> message_t;

class SingleClientWSServer {
public:
    SingleClientWSServer(const std::string& serverName, uint16_t port);

    ~SingleClientWSServer();
 
    // delete the assignment operator
    SingleClientWSServer& operator=(const SingleClientWSServer&) = delete;

    bool start();

    void stop();

    bool addProtocol(std::unique_ptr<WebSocketProtocol> protocol);

    void sendRawString(const std::string& protocolPath, const std::string& str);

    void sendJSON(const std::string& protocolPath, const json& obj);
 
private:
    class ProtocolData {
    public:
        ProtocolData(std::unique_ptr<WebSocketProtocol> protocol);
        const std::unique_ptr<WebSocketProtocol> protocol;
        std::optional<connection_hdl> client;
        // holds the periodically scheduled ping event and the watchdog
        std::optional<std::pair<util::PeriodicScheduler<>::eventid_t, util::Watchdog<>>>
            heartbeatInfo;
        std::mutex mutex;
    };
 
    std::string serverName;
    uint16_t port;
    websocketpp::server<websocketpp::config::asio> server;
    bool isRunning;
    // protects against race conditions modifying protocolMap
    std::mutex protocolMapMutex;
    // maps path prefix to ProtocolData for each protocol
    std::map<std::string, ProtocolData> protocolMap;
    std::thread serverThread;
    util::PeriodicScheduler<> pingScheduler;
 
    // called when connection is received and being validated.
    // return true to accept, false to reject
    bool validate(connection_hdl hdl);
    // called when connection is opened
    void onOpen(connection_hdl hdl);
    // called when connection is closed
    void onClose(connection_hdl hdl);
    void onMessage(connection_hdl hdl, message_t message);
    // called when pong message received from WS client
    void onPong(connection_hdl hdl, const std::string& payload);
    void serverTask();
    // Thread-safe access of the protocolMap
    std::optional<std::reference_wrapper<SingleClientWSServer::ProtocolData>>
    getProtocol(const std::string& protocolPath);
};
} // namespace websocket
} // namespace net