unified_messaging_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
#ifndef KCENON_NETWORK_INTERNAL_CORE_UNIFIED_MESSAGING_SERVER_H_
#define KCENON_NETWORK_INTERNAL_CORE_UNIFIED_MESSAGING_SERVER_H_
 
#include <atomic>
#include <concepts>
#include <functional>
#include <future>
#include <memory>
#include <mutex>
#include <string>
#include <string_view>
#include <type_traits>
#include <vector>
 
#include <asio.hpp>
 
#include "kcenon/network/detail/config/feature_flags.h"
#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
 
// Optional monitoring support via common_system
#if KCENON_WITH_COMMON_SYSTEM
#include <kcenon/common/interfaces/monitoring_interface.h>
#endif
 
namespace kcenon::network::session
{
class messaging_session;
#ifdef BUILD_TLS_SUPPORT
class secure_session;
#endif
} // namespace kcenon::network::session
 
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_server
    : public std::enable_shared_from_this<unified_messaging_server<Protocol, TlsPolicy>>
{
public:
    static constexpr bool is_secure = policy::is_tls_enabled_v<TlsPolicy>;
 
#ifdef BUILD_TLS_SUPPORT
    using session_type = std::conditional_t<
        is_secure,
        session::secure_session,
        session::messaging_session>;
#else
    using session_type = session::messaging_session;
#endif
 
    using session_ptr = std::shared_ptr<session_type>;
 
    using connection_callback_t = std::function<void(session_ptr)>;
    using disconnection_callback_t = std::function<void(const std::string&)>;
    using receive_callback_t = std::function<void(session_ptr, const std::vector<uint8_t>&)>;
    using error_callback_t = std::function<void(session_ptr, std::error_code)>;
 
    explicit unified_messaging_server(std::string_view server_id)
        requires (!policy::is_tls_enabled_v<TlsPolicy>);
 
    unified_messaging_server(std::string_view server_id, const TlsPolicy& tls_config)
        requires policy::is_tls_enabled_v<TlsPolicy>;
 
    ~unified_messaging_server() noexcept;
 
    // Non-copyable, non-movable
    unified_messaging_server(const unified_messaging_server&) = delete;
    unified_messaging_server& operator=(const unified_messaging_server&) = delete;
    unified_messaging_server(unified_messaging_server&&) = delete;
    unified_messaging_server& operator=(unified_messaging_server&&) = delete;
 
    // =====================================================================
    // Lifecycle Management
    // =====================================================================
 
    [[nodiscard]] auto start_server(uint16_t port) -> VoidResult;
 
    [[nodiscard]] auto stop_server() -> VoidResult;
 
    auto wait_for_stop() -> void;
 
    [[nodiscard]] auto is_running() const noexcept -> bool;
 
    [[nodiscard]] auto server_id() const -> const std::string&;
 
    // =====================================================================
    // Callback Setters
    // =====================================================================
 
    auto set_connection_callback(connection_callback_t callback) -> void;
 
    auto set_disconnection_callback(disconnection_callback_t callback) -> void;
 
    auto set_receive_callback(receive_callback_t callback) -> void;
 
    auto set_error_callback(error_callback_t callback) -> void;
 
#if KCENON_WITH_COMMON_SYSTEM
    auto set_monitor(kcenon::common::interfaces::IMonitor* monitor) -> void;
 
    auto get_monitor() const -> kcenon::common::interfaces::IMonitor*;
#endif
 
private:
    // =====================================================================
    // Internal Implementation Methods
    // =====================================================================
 
    auto do_start_impl(uint16_t port) -> VoidResult;
    auto do_stop_impl() -> VoidResult;
 
    // =====================================================================
    // Internal Callback Helpers
    // =====================================================================
 
    [[nodiscard]] auto get_connection_callback() const -> connection_callback_t;
    [[nodiscard]] auto get_disconnection_callback() const -> disconnection_callback_t;
    [[nodiscard]] auto get_receive_callback() const -> receive_callback_t;
    [[nodiscard]] auto get_error_callback() const -> error_callback_t;
 
    auto invoke_connection_callback(session_ptr session) -> void;
 
    // =====================================================================
    // Internal Connection Handlers
    // =====================================================================
 
    auto do_accept() -> void;
    auto on_accept(std::error_code ec, asio::ip::tcp::socket socket) -> void;
    auto cleanup_dead_sessions() -> void;
    auto start_cleanup_timer() -> void;
 
#ifdef BUILD_TLS_SUPPORT
    auto on_handshake_complete(session_ptr session, std::error_code ec) -> void
        requires is_secure;
#endif
 
private:
    using callback_index = tcp_server_callback;
 
    using callbacks_t = utils::callback_manager<
        connection_callback_t,
        disconnection_callback_t,
        receive_callback_t,
        error_callback_t>;
 
    // =====================================================================
    // Member Variables
    // =====================================================================
 
    std::string server_id_;                      
    utils::lifecycle_manager lifecycle_;         
    callbacks_t callbacks_;                      
    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::unique_ptr<asio::ip::tcp::acceptor> acceptor_;
    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
 
    std::vector<session_ptr> sessions_;
    mutable std::mutex sessions_mutex_;
    mutable std::mutex acceptor_mutex_;
    std::unique_ptr<asio::steady_timer> cleanup_timer_;
 
#if KCENON_WITH_COMMON_SYSTEM
    kcenon::common::interfaces::IMonitor* monitor_ = nullptr;
    std::atomic<uint64_t> messages_received_{0};
    std::atomic<uint64_t> messages_sent_{0};
    std::atomic<uint64_t> connection_errors_{0};
#endif
};
 
// =====================================================================
// Type Aliases for Convenience
// =====================================================================
 
using tcp_server = unified_messaging_server<protocol::tcp_protocol, policy::no_tls>;
 
#ifdef BUILD_TLS_SUPPORT
using secure_tcp_server = unified_messaging_server<protocol::tcp_protocol, policy::tls_enabled>;
#endif
 
} // namespace kcenon::network::core
 
// Include template implementation
#include "unified_messaging_server.inl"
 
#endif // KCENON_NETWORK_INTERNAL_CORE_UNIFIED_MESSAGING_SERVER_H_