websocket_server.h

Go to the documentation of this file.

#ifndef CPPSERVER_ASIO_WEBSOCKET_SERVER_H
#define CPPSERVER_ASIO_WEBSOCKET_SERVER_H

#include "websocket_session.h"

#include <map>
#include <mutex>
#include <tuple>
#include <vector>

namespace CppServer {
namespace Asio {

template <class TServer, class TSession>
class WebSocketSession;


template <class TServer, class TSession>
class WebSocketServer : public std::enable_shared_from_this<WebSocketServer<TServer, TSession>>
{
    template <class TSomeServer, class TSomeSession>
    friend class WebSocketSession;

public:

    explicit WebSocketServer(std::shared_ptr<Service> service, InternetProtocol protocol, int port);

    explicit WebSocketServer(std::shared_ptr<Service> service, const std::string& address, int port);

    explicit WebSocketServer(std::shared_ptr<Service> service, const asio::ip::tcp::endpoint& endpoint);
    WebSocketServer(const WebSocketServer&) = delete;
    WebSocketServer(WebSocketServer&&) = default;
    virtual ~WebSocketServer() = default;

    WebSocketServer& operator=(const WebSocketServer&) = delete;
    WebSocketServer& operator=(WebSocketServer&&) = default;

    std::shared_ptr<Service>& service() noexcept { return _service; }
    asio::ip::tcp::endpoint& endpoint() noexcept { return _endpoint; }
    WebSocketServerCore& core() noexcept { return _core; }

    uint64_t current_sessions() const noexcept { return _sessions.size(); }
    uint64_t messages_sent() const noexcept { return _messages_sent; }
    uint64_t messages_received() const noexcept { return _messages_received; }
    uint64_t bytes_sent() const noexcept { return _bytes_sent; }
    uint64_t bytes_received() const noexcept { return _bytes_received; }

    bool IsStarted() const noexcept { return _started; }


    bool Start();

    bool Stop();

    bool Restart();


    bool Multicast(const void* buffer, size_t size, websocketpp::frame::opcode::value opcode = websocketpp::frame::opcode::binary);

    bool Multicast(const std::string& text, websocketpp::frame::opcode::value opcode = websocketpp::frame::opcode::text);

    bool Multicast(const WebSocketMessage& message);


    bool DisconnectAll();

protected:
    virtual void onStarted() {}
    virtual void onStopped() {}


    virtual void onConnected(std::shared_ptr<TSession>& session) {}

    virtual void onDisconnected(std::shared_ptr<TSession>& session) {}


    virtual void onError(int error, const std::string& category, const std::string& message) {}

private:
    // Asio service
    std::shared_ptr<Service> _service;
    // Server endpoint & core
    asio::ip::tcp::endpoint _endpoint;
    WebSocketServerCore _core;
    std::atomic<bool> _initialized;
    std::atomic<bool> _started;
    // Server statistic
    uint64_t _messages_sent;
    uint64_t _messages_received;
    uint64_t _bytes_sent;
    uint64_t _bytes_received;
    // Server sessions
    std::map<websocketpp::connection_hdl, std::shared_ptr<TSession>, std::owner_less<websocketpp::connection_hdl>> _connections;
    std::map<CppCommon::UUID, std::shared_ptr<TSession>> _sessions;
    // Multicast buffer
    std::mutex _multicast_lock;
    std::vector<std::tuple<std::vector<uint8_t>, websocketpp::frame::opcode::value>> _multicast_buffer;
    std::vector<std::tuple<std::string, websocketpp::frame::opcode::value>> _multicast_text;
    std::vector<WebSocketMessage> _multicast_messages;

    void InitAsio();

    /*
        \param connection - WebSocket connection
    */
    std::shared_ptr<TSession> RegisterSession(websocketpp::connection_hdl connection);

    void UnregisterSession(websocketpp::connection_hdl connection);

    void UnregisterSession(const CppCommon::UUID& id);

    void MulticastAll();

    void ClearBuffers();

    void SendError(std::error_code ec);
};

} // namespace Asio
} // namespace CppServer

#include "websocket_session.inl"
#include "websocket_server.inl"

#endif // CPPSERVER_ASIO_WEBSOCKET_SERVER_H