unified_udp_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
 
#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 "internal/core/callback_indices.h"
#include "internal/interfaces/i_udp_client.h"
#include "kcenon/network/integration/thread_integration.h"
#include "kcenon/network/policy/tls_policy.h"
#include "kcenon/network/detail/protocol/protocol_tags.h"
#include "kcenon/network/detail/utils/callback_manager.h"
#include "kcenon/network/detail/utils/lifecycle_manager.h"
#include "kcenon/network/detail/utils/result_types.h"
 
#ifdef BUILD_TLS_SUPPORT
#include <openssl/ssl.h>
#endif
 
namespace kcenon::network::internal
{
class udp_socket;
#ifdef BUILD_TLS_SUPPORT
class dtls_socket;
#endif
}  // namespace kcenon::network::internal
 
namespace kcenon::network::core
{
 
template <policy::TlsPolicy TlsPolicy = policy::no_tls>
class unified_udp_messaging_client
    : public std::enable_shared_from_this<unified_udp_messaging_client<TlsPolicy>>
    , public interfaces::i_udp_client
{
public:
    static constexpr bool is_secure = policy::is_tls_enabled_v<TlsPolicy>;
 
    using receive_callback_t =
        std::function<void(const std::vector<uint8_t>&, const asio::ip::udp::endpoint&)>;
    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_udp_messaging_client(std::string_view client_id)
        requires(!policy::is_tls_enabled_v<TlsPolicy>);
 
    unified_udp_messaging_client(std::string_view client_id, const TlsPolicy& tls_config)
        requires policy::is_tls_enabled_v<TlsPolicy>;
 
    ~unified_udp_messaging_client() noexcept override;
 
    // Non-copyable, non-movable
    unified_udp_messaging_client(const unified_udp_messaging_client&) = delete;
    unified_udp_messaging_client& operator=(const unified_udp_messaging_client&) = delete;
    unified_udp_messaging_client(unified_udp_messaging_client&&) = delete;
    unified_udp_messaging_client& operator=(unified_udp_messaging_client&&) = delete;
 
    // =====================================================================
    // Lifecycle Management
    // =====================================================================
 
    [[nodiscard]] auto start_client(std::string_view host, uint16_t port) -> VoidResult;
 
    [[nodiscard]] auto stop_client() -> VoidResult;
 
    [[nodiscard]] auto client_id() const -> const std::string&;
 
    // =====================================================================
    // i_network_component interface implementation
    // =====================================================================
 
    [[nodiscard]] auto is_running() const -> bool override;
 
    auto wait_for_stop() -> void override;
 
    // =====================================================================
    // i_udp_client interface implementation
    // =====================================================================
 
    [[nodiscard]] auto start(std::string_view host, uint16_t port) -> VoidResult override;
    [[nodiscard]] auto stop() -> VoidResult override;
    [[nodiscard]] auto send(std::vector<uint8_t>&& data,
                            interfaces::i_udp_client::send_callback_t handler = nullptr)
        -> VoidResult override;
    [[nodiscard]] auto set_target(std::string_view host, uint16_t port) -> VoidResult override;
    auto set_receive_callback(interfaces::i_udp_client::receive_callback_t callback)
        -> void override;
    auto set_error_callback(error_callback_t callback) -> void override;
 
    // =====================================================================
    // Extended API (not in interface)
    // =====================================================================
 
    [[nodiscard]] auto is_connected() const noexcept -> bool;
 
    [[nodiscard]] auto send_packet(std::vector<uint8_t>&& data) -> VoidResult;
 
    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;
 
private:
    // =====================================================================
    // Internal Socket Type Selection
    // =====================================================================
 
#ifdef BUILD_TLS_SUPPORT
    using socket_type =
        std::conditional_t<is_secure, internal::dtls_socket, internal::udp_socket>;
#else
    using socket_type = internal::udp_socket;
#endif
 
    // =====================================================================
    // Internal Implementation Methods
    // =====================================================================
 
    auto do_start_impl(std::string_view host, uint16_t port) -> VoidResult;
    auto do_stop_impl() -> VoidResult;
 
#ifdef BUILD_TLS_SUPPORT
    auto init_ssl_context() -> VoidResult
        requires is_secure;
    auto do_handshake() -> VoidResult
        requires is_secure;
#endif
 
    // =====================================================================
    // Internal Callback Helpers
    // =====================================================================
 
    auto set_connected(bool connected) -> void;
    auto invoke_receive_callback(const std::vector<uint8_t>& data,
                                 const asio::ip::udp::endpoint& endpoint) -> void;
    auto invoke_connected_callback() -> void;
    auto invoke_disconnected_callback() -> void;
    auto invoke_error_callback(std::error_code ec) -> void;
 
    [[nodiscard]] auto get_receive_callback() const -> receive_callback_t;
    [[nodiscard]] auto get_error_callback() const -> error_callback_t;
 
private:
    using callback_index = unified_udp_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::unique_ptr<asio::io_context> io_context_;  
    std::shared_ptr<socket_type> socket_;           
    std::shared_ptr<integration::thread_pool_interface> thread_pool_;
    std::future<void> io_context_future_;  
    std::mutex endpoint_mutex_;              
    asio::ip::udp::endpoint target_endpoint_;  
    mutable std::mutex socket_mutex_;  
#ifdef BUILD_TLS_SUPPORT
    SSL_CTX* ssl_ctx_{nullptr};                    
    [[no_unique_address]] TlsPolicy tls_config_;  
#endif
};
 
// =====================================================================
// Type Aliases for Convenience
// =====================================================================
 
using udp_client = unified_udp_messaging_client<policy::no_tls>;
 
#ifdef BUILD_TLS_SUPPORT
using secure_udp_client = unified_udp_messaging_client<policy::tls_enabled>;
#endif
 
}  // namespace kcenon::network::core
 
// Include template implementation
#include "unified_udp_messaging_client.inl"