unified_session_manager.h

Go to the documentation of this file.

/*****************************************************************************
BSD 3-Clause License
 
Copyright (c) 2025, kcenon
All rights reserved.
*****************************************************************************/
 
#pragma once
 
#include "internal/core/session_handle.h"
 
#include <atomic>
#include <chrono>
#include <functional>
#include <memory>
#include <shared_mutex>
#include <string>
#include <unordered_map>
#include <vector>
 
namespace kcenon::network::core {
 
struct unified_session_config {
    size_t max_sessions{1000};
    std::chrono::milliseconds idle_timeout{std::chrono::minutes(5)};
    std::chrono::milliseconds cleanup_interval{std::chrono::seconds(30)};
    bool enable_backpressure{true};
    double backpressure_threshold{0.8};
};
 
class unified_session_manager {
public:
    unified_session_manager();
 
    explicit unified_session_manager(const unified_session_config& config);
 
    ~unified_session_manager();
 
    // Non-copyable, non-movable
    unified_session_manager(const unified_session_manager&) = delete;
    unified_session_manager& operator=(const unified_session_manager&) = delete;
    unified_session_manager(unified_session_manager&&) = delete;
    unified_session_manager& operator=(unified_session_manager&&) = delete;
 
    // =========================================================================
    // Connection Acceptance
    // =========================================================================
 
    [[nodiscard]] auto can_accept_connection() const -> bool;
 
    [[nodiscard]] auto is_backpressure_active() const -> bool;
 
    // =========================================================================
    // Session CRUD - Type-Erased API
    // =========================================================================
 
    template <typename SessionType>
    auto add_session(std::shared_ptr<SessionType> session,
                     const std::string& session_id = "") -> bool {
        if (!can_accept_connection()) {
            increment_rejected();
            return false;
        }
 
        auto handle = session_handle(std::move(session));
        return add_session_impl(std::move(handle), session_id);
    }
 
    auto add_session(session_handle handle, const std::string& session_id = "")
        -> bool;
 
    template <typename SessionType>
    auto add_session_with_id(std::shared_ptr<SessionType> session,
                             const std::string& session_id = "") -> std::string {
        if (!can_accept_connection()) {
            increment_rejected();
            return "";
        }
 
        auto handle = session_handle(std::move(session));
        return add_session_with_id_impl(std::move(handle), session_id);
    }
 
    auto remove_session(const std::string& session_id) -> bool;
 
    [[nodiscard]] auto get_session(const std::string& session_id) -> session_handle*;
 
    [[nodiscard]] auto get_session(const std::string& session_id) const
        -> const session_handle*;
 
    auto with_session(const std::string& session_id,
                      const std::function<void(session_handle&)>& callback) -> bool;
 
    [[nodiscard]] auto has_session(const std::string& session_id) const -> bool;
 
    [[nodiscard]] auto get_all_session_ids() const -> std::vector<std::string>;
 
    // =========================================================================
    // Iteration
    // =========================================================================
 
    auto for_each(const std::function<void(session_handle&)>& callback) -> void;
 
    auto for_each(const std::function<void(const session_handle&)>& callback) const
        -> void;
 
    auto broadcast(std::vector<uint8_t> data) -> size_t;
 
    // =========================================================================
    // Activity Tracking & Cleanup
    // =========================================================================
 
    auto update_activity(const std::string& session_id) -> bool;
 
    auto cleanup_idle_sessions() -> size_t;
 
    // =========================================================================
    // Lifecycle Management
    // =========================================================================
 
    auto clear_all_sessions() -> void;
 
    auto stop_all_sessions() -> void;
 
    // =========================================================================
    // Metrics
    // =========================================================================
 
    [[nodiscard]] auto get_session_count() const -> size_t;
 
    [[nodiscard]] auto get_total_accepted() const -> uint64_t;
 
    [[nodiscard]] auto get_total_rejected() const -> uint64_t;
 
    [[nodiscard]] auto get_total_cleaned_up() const -> uint64_t;
 
    [[nodiscard]] auto get_utilization() const -> double;
 
    // =========================================================================
    // Configuration
    // =========================================================================
 
    auto set_max_sessions(size_t max_sessions) -> void;
 
    [[nodiscard]] auto get_config() const -> const unified_session_config&;
 
    // =========================================================================
    // Statistics
    // =========================================================================
 
    struct stats {
        size_t active_sessions;
        size_t max_sessions;
        uint64_t total_accepted;
        uint64_t total_rejected;
        uint64_t total_cleaned_up;
        double utilization;
        bool backpressure_active;
        std::chrono::milliseconds idle_timeout;
    };
 
    [[nodiscard]] auto get_stats() const -> stats;
 
    // =========================================================================
    // ID Generation
    // =========================================================================
 
    static auto generate_id(const std::string& prefix = "session_") -> std::string;
 
private:
    class impl;
    std::unique_ptr<impl> impl_;
 
    auto add_session_impl(session_handle handle, const std::string& session_id)
        -> bool;
    auto add_session_with_id_impl(session_handle handle,
                                  const std::string& session_id) -> std::string;
    auto increment_rejected() -> void;
};
 
} // namespace kcenon::network::core