connectionsmanager.h

#ifndef CONNECTIONSMANAGER_H
#define CONNECTIONSMANAGER_H
 
#include <stdint.h>
 
#include <thread>
#include <map>
#include <memory>
#include <set>
#include <vector>
 
#include "gameobject.h"
#include "../utils/json.hpp"
 
class TcpServer;
class SocketDevice;
class GameManager;
 
class ConnectionsManager
//    : public Thread
{
public:
    using WatermarkType = int64_t;
    static ConnectionsManager* connections_manager;
 
    static constexpr WatermarkType watermark_ref = 0x08FEEF0100112233ULL;
 
    // CLIENT -> SERVER requests.
    //
    // A message is always a JSON object serialized with MessagePack format, only one JSON for each command.
    //
    //  *****To avoid messing up the TCP channel, you must **never** mix send and receive for the
    // same command *****
    //.
    // The CLIENT initiate an object_subscribe command.
    // The CLIENT can send addiitonal object_unsubscribe to stop updates.
    // the CLIENT can send additional command specific messages.
    // The server will NOT reply at this time, but reply with one of the SERVER -> CLIENT commands.
    static constexpr char cmd_from_client_subscribe_starsystem[] = "subscribe_starsystem";
    static constexpr char cmd_from_client_unsubscribe_starsystem[] = "unsubscribe_starsystem";
    static constexpr char cmd_from_client_get_player_data[] = "player_data";
    static constexpr char cmd_from_client_get_starsystem_data[] = "starsystem_data";
    static constexpr char cmd_from_client_get_rules[] = "rules";
 
    // SERVER -> CLIENT messages.
    // The SERVER will send back to the CLIENT one of the following messages:
    static constexpr char cmd_to_client_player_data[] = "player_data";
    static constexpr char cmd_to_client_starsystem_data[] = "starsystem_data";
    static constexpr char cmd_to_client_rules_data[] = "rules";
 
    // System messages (client -> server)
    static constexpr char cmd_quit_request[] = "quit";
 
public:
    ConnectionsManager( int listen_port, const std::string& listen_on, std::atomic<bool>& keep_running );
    ~ConnectionsManager();
 
    bool isReady();
 
    static bool sendMessage( const std::string& command_name, const nlohmann::json& command_data, std::unique_ptr<SocketDevice>& connection );
    static bool sendPackedMessage( const std::vector<uint8_t>& command_packed_data, std::unique_ptr<SocketDevice>& connection );
    static bool receiveMessage( nlohmann::json& command_data, std::unique_ptr<SocketDevice>& connection );
 
private:
    static void static_run( ConnectionsManager* myself );
    void run();
 
    // accept incoming new connections
    bool _acceptConnection( std::unique_ptr<SocketDevice>& connection );
 
    // Process connection -> server requests
    bool _checkCommand(std::unique_ptr<SocketDevice>& connection, ObjectId player_id );
    bool _subscribeStarsystem( const nlohmann::json& command_data, ObjectId player_id);
    bool _unsubscribeStarsystem(const nlohmann::json &command_data, ObjectId player_id );
    bool _getPlayerData(const nlohmann::json &command_data, std::unique_ptr<SocketDevice> &client);
    bool _getStarsystemData(const nlohmann::json &command_data, std::unique_ptr<SocketDevice> &client);
    bool _getRules( std::unique_ptr<SocketDevice>& client );
 
    // Process server -> client replies
    bool _sendPlayerData( std::unique_ptr<SocketDevice>& client, ObjectId player_id );
    bool _sendStarsystemData( std::unique_ptr<SocketDevice>& client, ObjectId starsystem_id );
    bool _sendRules( std::unique_ptr<SocketDevice>& client );
 
    std::thread _t;
    TcpServer* _server;
    std::atomic<bool>& _keep_running;
 
    std::map<ObjectId, std::unique_ptr<SocketDevice>> _connected_players;
    std::map<ObjectId, std::set<ObjectId>> _subscribed_starsystems;
};
 
#endif // CONNECTIONSMANAGER_H