unified_messaging_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
#ifndef KCENON_NETWORK_INTERNAL_CORE_UNIFIED_MESSAGING_CLIENT_H_
#define KCENON_NETWORK_INTERNAL_CORE_UNIFIED_MESSAGING_CLIENT_H_
 
#include <atomic>
#include <concepts>
#include <functional>
#include <future>
#include <memory>
#include <mutex>
#include <span>
#include <string>
#include <string_view>
#include <type_traits>
#include <vector>
 
#include <asio.hpp>
 
#include "kcenon/network/policy/tls_policy.h"
#include "kcenon/network/detail/protocol/protocol_tags.h"
#include "internal/core/callback_indices.h"
#include "kcenon/network/detail/utils/callback_manager.h"
#include "kcenon/network/detail/utils/result_types.h"
#include "kcenon/network/detail/utils/lifecycle_manager.h"
 
#ifdef BUILD_TLS_SUPPORT
#include <asio/ssl.hpp>
#endif
 
namespace kcenon::network::internal
{
    class tcp_socket;
#ifdef BUILD_TLS_SUPPORT
    class secure_tcp_socket;
#endif
}
 
namespace kcenon::network::core
{
 
template <protocol::Protocol Protocol, policy::TlsPolicy TlsPolicy = policy::no_tls>
    requires std::same_as<Protocol, protocol::tcp_protocol>
class unified_messaging_client
    : public std::enable_shared_from_this<unified_messaging_client<Protocol, TlsPolicy>>
{
public:
    static constexpr bool is_secure = policy::is_tls_enabled_v<TlsPolicy>;
 
    using receive_callback_t = std::function<void(const std::vector<uint8_t>&)>;
    using connected_callback_t = std::function<void()>;
    using disconnected_callback_t = std::function<void()>;
    using error_callback_t = std::function<void(std::error_code)>;
 
    explicit unified_messaging_client(std::string_view client_id);
 
    unified_messaging_client(std::string_view client_id, const TlsPolicy& tls_config)
        requires policy::is_tls_enabled_v<TlsPolicy>;
 
    ~unified_messaging_client() noexcept;
 
    // Non-copyable, non-movable
    unified_messaging_client(const unified_messaging_client&) = delete;
    unified_messaging_client& operator=(const unified_messaging_client&) = delete;
    unified_messaging_client(unified_messaging_client&&) = delete;
    unified_messaging_client& operator=(unified_messaging_client&&) = delete;
 
    // =====================================================================
    // Lifecycle Management
    // =====================================================================
 
    [[nodiscard]] auto start_client(std::string_view host, uint16_t port) -> VoidResult;
 
    [[nodiscard]] auto stop_client() -> VoidResult;
 
    auto wait_for_stop() -> void;
 
    [[nodiscard]] auto is_running() const noexcept -> bool;
 
    [[nodiscard]] auto is_connected() const noexcept -> bool;
 
    [[nodiscard]] auto client_id() const -> const std::string&;
 
    // =====================================================================
    // Data Transfer
    // =====================================================================
 
    [[nodiscard]] auto send_packet(std::vector<uint8_t>&& data) -> VoidResult;
 
    // =====================================================================
    // Callback Setters
    // =====================================================================
 
    auto set_receive_callback(receive_callback_t callback) -> void;
 
    auto set_connected_callback(connected_callback_t callback) -> void;
 
    auto set_disconnected_callback(disconnected_callback_t callback) -> void;
 
    auto set_error_callback(error_callback_t callback) -> void;
 
private:
    // =====================================================================
    // Internal Socket Type Selection
    // =====================================================================
 
#ifdef BUILD_TLS_SUPPORT
    using socket_type = std::conditional_t<
        is_secure,
        internal::secure_tcp_socket,
        internal::tcp_socket
    >;
#else
    using socket_type = internal::tcp_socket;
#endif
 
    // =====================================================================
    // Internal Implementation Methods
    // =====================================================================
 
    auto do_start_impl(std::string_view host, uint16_t port) -> VoidResult;
    auto do_stop_impl() -> VoidResult;
    auto do_send_impl(std::vector<uint8_t>&& data) -> VoidResult;
 
    // =====================================================================
    // Internal Callback Helpers
    // =====================================================================
 
    auto set_connected(bool connected) -> void;
    auto invoke_receive_callback(const std::vector<uint8_t>& data) -> void;
    auto invoke_connected_callback() -> void;
    auto invoke_disconnected_callback() -> void;
    auto invoke_error_callback(std::error_code ec) -> void;
 
    // =====================================================================
    // Internal Connection Handlers
    // =====================================================================
 
    auto do_connect(std::string_view host, uint16_t port) -> void;
    auto on_connect(std::error_code ec) -> void;
    auto on_receive(std::span<const uint8_t> data) -> void;
    auto on_error(std::error_code ec) -> void;
    auto on_connection_failed(std::error_code ec) -> void;
 
#ifdef BUILD_TLS_SUPPORT
    auto on_handshake_complete(std::error_code ec) -> void
        requires is_secure;
#endif
 
private:
    using callback_index = tcp_client_callback;
 
    using callbacks_t = utils::callback_manager<
        receive_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};      
    std::atomic<bool> stop_initiated_{false};    
    std::shared_ptr<asio::io_context> io_context_; 
    std::unique_ptr<asio::executor_work_guard<asio::io_context::executor_type>>
        work_guard_;                             
    std::future<void> io_context_future_;        
#ifdef BUILD_TLS_SUPPORT
    std::unique_ptr<asio::ssl::context> ssl_context_; 
    [[no_unique_address]] TlsPolicy tls_config_; 
#endif
 
    auto get_socket() const -> std::shared_ptr<socket_type>;
 
    mutable std::mutex socket_mutex_;            
    std::shared_ptr<socket_type> socket_;        
    mutable std::mutex pending_mutex_;           
    std::shared_ptr<asio::ip::tcp::resolver> pending_resolver_;
    std::shared_ptr<asio::ip::tcp::socket> pending_socket_;
};
 
// =====================================================================
// Type Aliases for Convenience
// =====================================================================
 
using tcp_client = unified_messaging_client<protocol::tcp_protocol, policy::no_tls>;
 
#ifdef BUILD_TLS_SUPPORT
using secure_tcp_client = unified_messaging_client<protocol::tcp_protocol, policy::tls_enabled>;
#endif
 
} // namespace kcenon::network::core
 
// Include template implementation
#include "unified_messaging_client.inl"
 
#endif // KCENON_NETWORK_INTERNAL_CORE_UNIFIED_MESSAGING_CLIENT_H_