websocket_client.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 <chrono>
#include <cstdint>
#include <functional>
#include <future>
#include <map>
#include <memory>
#include <mutex>
#include <string>
#include <string_view>
#include <system_error>
#include <vector>
 
#include <asio.hpp>
 
#include "internal/interfaces/i_websocket_client.h"
#include "internal/core/callback_indices.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"
 
namespace kcenon::network::internal
{
    class tcp_socket;
    class websocket_socket;
}
 
namespace kcenon::network::core
{
    struct ws_client_config
    {
        std::string host;                                
        uint16_t port = 80;                              
        std::string path = "/";                          
        std::map<std::string, std::string> headers;      
        std::chrono::milliseconds connect_timeout{10000}; 
        std::chrono::milliseconds ping_interval{30000};   
        bool auto_pong = true;                            
        bool auto_reconnect = false;                      
        size_t max_message_size = 10 * 1024 * 1024;      
    };
 
    class messaging_ws_client
        : public std::enable_shared_from_this<messaging_ws_client>
        , public interfaces::i_websocket_client
    {
    public:
        using message_callback_t = std::function<void(const internal::ws_message&)>;
        using text_message_callback_t = std::function<void(const std::string&)>;
        using binary_message_callback_t = std::function<void(const std::vector<uint8_t>&)>;
        using connected_callback_t = std::function<void()>;
        using disconnected_callback_t = std::function<void(internal::ws_close_code, const std::string&)>;
        using error_callback_t = std::function<void(std::error_code)>;
 
        explicit messaging_ws_client(std::string_view client_id);
 
        ~messaging_ws_client() noexcept override;
 
        // Non-copyable, non-movable
        messaging_ws_client(const messaging_ws_client&) = delete;
        messaging_ws_client& operator=(const messaging_ws_client&) = delete;
        messaging_ws_client(messaging_ws_client&&) = delete;
        messaging_ws_client& operator=(messaging_ws_client&&) = delete;
 
        // ========================================================================
        // Lifecycle Management
        // ========================================================================
 
        [[nodiscard]] auto start_client(const ws_client_config& config) -> VoidResult;
 
        [[nodiscard]] auto start_client(std::string_view host, uint16_t port,
                                        std::string_view path = "/") -> VoidResult;
 
        [[nodiscard]] auto stop_client() -> VoidResult;
 
        [[nodiscard]] auto client_id() const -> const std::string&;
 
        [[nodiscard]] auto send_ping(std::vector<uint8_t>&& payload = {}) -> VoidResult;
 
        // ========================================================================
        // i_network_component interface implementation
        // ========================================================================
 
        [[nodiscard]] auto is_running() const -> bool override;
 
        auto wait_for_stop() -> void override;
 
        // ========================================================================
        // i_websocket_client interface implementation
        // ========================================================================
 
        [[nodiscard]] auto start(
            std::string_view host,
            uint16_t port,
            std::string_view path = "/") -> VoidResult override;
 
        [[nodiscard]] auto stop() -> VoidResult override;
 
        [[nodiscard]] auto is_connected() const -> bool override;
 
        [[nodiscard]] auto send_text(
            std::string&& message,
            interfaces::i_websocket_client::send_callback_t handler = nullptr) -> VoidResult override;
 
        [[nodiscard]] auto send_binary(
            std::vector<uint8_t>&& data,
            interfaces::i_websocket_client::send_callback_t handler = nullptr) -> VoidResult override;
 
        [[nodiscard]] auto ping(std::vector<uint8_t>&& payload = {}) -> VoidResult override;
 
        [[nodiscard]] auto close(
            uint16_t code = 1000,
            std::string_view reason = "") -> VoidResult override;
 
        auto set_text_callback(interfaces::i_websocket_client::text_callback_t callback) -> void override;
 
        auto set_binary_callback(interfaces::i_websocket_client::binary_callback_t callback) -> void override;
 
        auto set_connected_callback(interfaces::i_websocket_client::connected_callback_t callback) -> void override;
 
        auto set_disconnected_callback(interfaces::i_websocket_client::disconnected_callback_t callback) -> void override;
 
        auto set_error_callback(interfaces::i_websocket_client::error_callback_t callback) -> void override;
 
    private:
        // =====================================================================
        // Internal Implementation Methods
        // =====================================================================
 
        auto do_start_impl(std::string_view host, uint16_t port, std::string_view path) -> VoidResult;
 
        auto do_stop_impl() -> VoidResult;
 
        auto do_connect() -> void;
 
        auto on_message(const internal::ws_message& msg) -> void;
 
        auto on_ping(const std::vector<uint8_t>& payload) -> void;
 
        auto on_close(internal::ws_close_code code, const std::string& reason) -> void;
 
        auto on_error(std::error_code ec) -> void;
 
        // =====================================================================
        // Internal Callback Helpers
        // =====================================================================
 
        auto invoke_message_callback(const internal::ws_message& msg) -> void;
 
        auto invoke_connected_callback() -> void;
 
        auto invoke_disconnected_callback(internal::ws_close_code code,
                                          const std::string& reason) -> void;
 
        auto invoke_error_callback(std::error_code ec) -> void;
 
        using callback_index = ws_client_callback;
 
        using callbacks_t = utils::callback_manager<
            message_callback_t,
            text_message_callback_t,
            binary_message_callback_t,
            connected_callback_t,
            disconnected_callback_t,
            error_callback_t
        >;
 
        // =====================================================================
        // Member Variables
        // =====================================================================
 
        std::string client_id_;                          
        utils::lifecycle_manager lifecycle_;             
        callbacks_t callbacks_;                          
        std::atomic<bool> is_connected_{false};          
        ws_client_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::shared_ptr<integration::thread_pool_interface> thread_pool_;   
        std::future<void> io_context_future_;            
        std::shared_ptr<internal::websocket_socket> ws_socket_; 
        std::mutex ws_socket_mutex_;                     
    };
 
// =====================================================================
// Unified Pattern Type Aliases
// =====================================================================
// These aliases provide a consistent API pattern across all protocols,
// making WebSocket clients accessible via the unified template naming.
// See: unified_messaging_client.h for TCP, unified_udp_messaging_client.h for UDP.
 
using ws_client = messaging_ws_client;
 
using secure_ws_client = messaging_ws_client;
 
} // namespace kcenon::network::core