websocket_server.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2024, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include "internal/core/callback_indices.h"
#include "internal/interfaces/i_websocket_server.h"
#include "internal/websocket/websocket_protocol.h"
#include "kcenon/network/detail/utils/result_types.h"
#include "kcenon/network/detail/utils/lifecycle_manager.h"
#include "kcenon/network/detail/utils/callback_manager.h"
#include "kcenon/network/integration/thread_integration.h"
 
#include <chrono>
#include <cstdint>
#include <functional>
#include <future>
#include <memory>
#include <mutex>
#include <string>
#include <string_view>
#include <system_error>
#include <vector>
 
#include <asio.hpp>
 
namespace kcenon::network::internal
{
    class websocket_socket;
}
 
#if defined(NETWORK_ENABLE_TEST_INJECTION)
namespace kcenon::network::tests::support
{
    class ws_server_probe;
} // namespace kcenon::network::tests::support
#endif
 
namespace kcenon::network::core
{
    class ws_session_manager;
 
    struct ws_server_config
    {
        uint16_t port = 8080;                            
        std::string path = "/";                          
        size_t max_connections = 1000;                   
        std::chrono::milliseconds ping_interval{30000};  
        bool auto_pong = true;                           
        size_t max_message_size = 10 * 1024 * 1024;     
    };
 
    class ws_connection : public interfaces::i_websocket_session
    {
    public:
        // Allow server to create connections
        friend class messaging_ws_server;
 
        // Constructor - used by server
        explicit ws_connection(std::shared_ptr<class ws_connection_impl> impl);
 
        ~ws_connection() override = default;
 
        // ========================================================================
        // i_websocket_session interface implementation
        // ========================================================================
 
        [[nodiscard]] auto id() const -> std::string_view override;
 
        [[nodiscard]] auto is_connected() const -> bool override;
 
        [[nodiscard]] auto send(std::vector<uint8_t>&& data) -> VoidResult override;
 
        auto close() -> void override;
 
        [[nodiscard]] auto send_text(std::string&& message) -> VoidResult override;
 
        [[nodiscard]] auto send_binary(std::vector<uint8_t>&& data) -> VoidResult override;
 
        auto close(uint16_t code, std::string_view reason = "") -> void override;
 
        [[nodiscard]] auto path() const -> std::string_view override;
 
        auto remote_endpoint() const -> std::string;
 
    private:
        auto get_impl() const -> std::shared_ptr<ws_connection_impl> { return pimpl_; }
 
        std::shared_ptr<ws_connection_impl> pimpl_;
    };
 
    class ws_connection_impl;
 
    class messaging_ws_server
        : public std::enable_shared_from_this<messaging_ws_server>
        , public interfaces::i_websocket_server
    {
    public:
        using connection_callback_t = std::function<void(std::shared_ptr<ws_connection>)>;
        using disconnection_callback_t = std::function<void(const std::string&, internal::ws_close_code, const std::string&)>;
        using message_callback_t = std::function<void(std::shared_ptr<ws_connection>, const internal::ws_message&)>;
        using text_message_callback_t = std::function<void(std::shared_ptr<ws_connection>, const std::string&)>;
        using binary_message_callback_t = std::function<void(std::shared_ptr<ws_connection>, const std::vector<uint8_t>&)>;
        using error_callback_t = std::function<void(const std::string&, std::error_code)>;
 
        explicit messaging_ws_server(std::string_view server_id);
 
        ~messaging_ws_server() noexcept override;
 
        // Non-copyable, non-movable
        messaging_ws_server(const messaging_ws_server&) = delete;
        messaging_ws_server& operator=(const messaging_ws_server&) = delete;
        messaging_ws_server(messaging_ws_server&&) = delete;
        messaging_ws_server& operator=(messaging_ws_server&&) = delete;
 
        // ========================================================================
        // Lifecycle Management
        // ========================================================================
 
        [[nodiscard]] auto start_server(const ws_server_config& config) -> VoidResult;
 
        [[nodiscard]] auto start_server(uint16_t port, std::string_view path = "/") -> VoidResult;
 
        [[nodiscard]] auto stop_server() -> VoidResult;
 
        [[nodiscard]] auto server_id() const -> const std::string&;
 
        auto broadcast_text(const std::string& message) -> void;
 
        auto broadcast_binary(const std::vector<uint8_t>& data) -> void;
 
        auto get_connection(const std::string& connection_id) -> std::shared_ptr<ws_connection>;
 
        auto get_all_connections() -> std::vector<std::string>;
 
        // ========================================================================
        // i_network_component interface implementation
        // ========================================================================
 
        [[nodiscard]] auto is_running() const -> bool override;
 
        auto wait_for_stop() -> void override;
 
        // ========================================================================
        // i_websocket_server interface implementation
        // ========================================================================
 
        [[nodiscard]] auto start(uint16_t port) -> VoidResult override;
 
        [[nodiscard]] auto stop() -> VoidResult override;
 
        [[nodiscard]] auto connection_count() const -> size_t override;
 
        auto set_connection_callback(interfaces::i_websocket_server::connection_callback_t callback) -> void override;
 
        auto set_disconnection_callback(interfaces::i_websocket_server::disconnection_callback_t callback) -> void override;
 
        auto set_text_callback(interfaces::i_websocket_server::text_callback_t callback) -> void override;
 
        auto set_binary_callback(interfaces::i_websocket_server::binary_callback_t callback) -> void override;
 
        auto set_error_callback(interfaces::i_websocket_server::error_callback_t callback) -> void override;
 
    private:
#if defined(NETWORK_ENABLE_TEST_INJECTION)
        // Test-only: grants tests/support/ws_server_probe access to private
        // surfaces without leaking them through the public API.
        friend class kcenon::network::tests::support::ws_server_probe;
#endif
 
        // =====================================================================
        // Internal Implementation Methods
        // =====================================================================
 
        auto do_start_impl(uint16_t port, std::string_view path) -> VoidResult;
 
        auto do_stop_impl() -> VoidResult;
 
        auto do_accept() -> void;
 
        auto handle_new_connection(std::shared_ptr<asio::ip::tcp::socket> socket) -> void;
 
        auto on_message(std::shared_ptr<ws_connection> conn, const internal::ws_message& msg) -> void;
 
        auto on_close(const std::string& conn_id, internal::ws_close_code code, const std::string& reason) -> void;
 
        auto on_error(const std::string& conn_id, std::error_code ec) -> void;
 
        // =====================================================================
        // Internal Callback Helpers
        // =====================================================================
 
        auto invoke_connection_callback(std::shared_ptr<ws_connection> conn) -> void;
 
        auto invoke_disconnection_callback(const std::string& conn_id,
                                           internal::ws_close_code code,
                                           const std::string& reason) -> void;
 
        auto invoke_message_callback(std::shared_ptr<ws_connection> conn,
                                     const internal::ws_message& msg) -> void;
 
        auto invoke_error_callback(const std::string& conn_id, std::error_code ec) -> void;
 
        using callback_index = ws_server_callback;
 
        using callbacks_t = utils::callback_manager<
            connection_callback_t,
            disconnection_callback_t,
            message_callback_t,
            text_message_callback_t,
            binary_message_callback_t,
            error_callback_t
        >;
 
        // =====================================================================
        // Member Variables
        // =====================================================================
 
        std::string server_id_;                          
        utils::lifecycle_manager lifecycle_;             
        callbacks_t callbacks_;                          
        ws_server_config config_;                        
        std::unique_ptr<asio::io_context> io_context_;   
        std::unique_ptr<asio::executor_work_guard<asio::io_context::executor_type>> work_guard_; 
        std::unique_ptr<asio::ip::tcp::acceptor> acceptor_; 
        mutable std::mutex acceptor_mutex_;              
        std::shared_ptr<integration::thread_pool_interface> thread_pool_;   
        std::future<void> io_context_future_;            
        std::shared_ptr<ws_session_manager> session_mgr_; 
    };
 
// =====================================================================
// Unified Pattern Type Aliases
// =====================================================================
// These aliases provide a consistent API pattern across all protocols,
// making WebSocket servers accessible via the unified template naming.
// See: unified_messaging_server.h for TCP, unified_udp_messaging_server.h for UDP.
 
using ws_server = messaging_ws_server;
 
using secure_ws_server = messaging_ws_server;
 
} // namespace kcenon::network::core