http2_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
 
#include "frame.h"
#include "hpack.h"
#include "http2_client.h"
#include "http2_request.h"
#include "http2_server_stream.h"
#include "kcenon/network/detail/utils/result_types.h"
 
#include <asio.hpp>
#include <asio/ssl.hpp>
 
#include <atomic>
#include <chrono>
#include <cstdint>
#include <functional>
#include <future>
#include <map>
#include <memory>
#include <mutex>
#include <optional>
#include <string>
#include <string_view>
#include <vector>
 
#if defined(NETWORK_ENABLE_TEST_INJECTION)
namespace kcenon::network::tests::support
{
    class http2_server_test_access;
} // namespace kcenon::network::tests::support
#endif
 
namespace kcenon::network::protocols::http2
{
    // Forward declaration
    class http2_server_connection;
 
    struct tls_config
    {
        std::string cert_file;                    
        std::string key_file;                     
        std::string ca_file;                      
        bool verify_client = false;               
    };
 
    class http2_server : public std::enable_shared_from_this<http2_server>
    {
    public:
        using request_handler_t = std::function<void(
            http2_server_stream& stream,
            const http2_request& request)>;
 
        using error_handler_t = std::function<void(
            const std::string& error_message)>;
 
        explicit http2_server(std::string_view server_id);
 
        ~http2_server();
 
        // Non-copyable
        http2_server(const http2_server&) = delete;
        http2_server& operator=(const http2_server&) = delete;
 
        // Non-movable (contains std::atomic members)
        http2_server(http2_server&&) = delete;
        http2_server& operator=(http2_server&&) = delete;
 
        auto start(unsigned short port) -> VoidResult;
 
        auto start_tls(unsigned short port, const tls_config& config) -> VoidResult;
 
        auto stop() -> VoidResult;
 
        [[nodiscard]] auto is_running() const -> bool;
 
        auto wait() -> void;
 
        auto set_request_handler(request_handler_t handler) -> void;
 
        auto set_error_handler(error_handler_t handler) -> void;
 
        auto set_settings(const http2_settings& settings) -> void;
 
        [[nodiscard]] auto get_settings() const -> http2_settings;
 
        [[nodiscard]] auto active_connections() const -> size_t;
 
        [[nodiscard]] auto active_streams() const -> size_t;
 
        [[nodiscard]] auto server_id() const -> std::string_view;
 
    private:
        // Internal connection handling
        auto do_accept() -> void;
        auto do_accept_tls() -> void;
        auto handle_accept(std::error_code ec, asio::ip::tcp::socket socket) -> void;
        auto handle_accept_tls(std::error_code ec, asio::ip::tcp::socket socket) -> void;
 
        // Connection management
        auto add_connection(std::shared_ptr<http2_server_connection> conn) -> void;
        auto remove_connection(uint64_t connection_id) -> void;
        auto cleanup_dead_connections() -> void;
        auto start_cleanup_timer() -> void;
 
        // I/O thread management
        auto run_io() -> void;
        auto stop_io() -> void;
 
        // Member variables
        std::string server_id_;                   
 
        // ASIO context
        std::unique_ptr<asio::io_context> io_context_;
        std::unique_ptr<asio::ssl::context> ssl_context_;
        std::unique_ptr<asio::ip::tcp::acceptor> acceptor_;
        std::unique_ptr<asio::executor_work_guard<asio::io_context::executor_type>> work_guard_;
        std::future<void> io_future_;
 
        // Server state
        std::atomic<bool> is_running_{false};
        std::atomic<bool> use_tls_{false};
        std::promise<void> stop_promise_;
        std::future<void> stop_future_;
 
        // Handlers
        request_handler_t request_handler_;
        error_handler_t error_handler_;
 
        // Connection management
        std::mutex connections_mutex_;
        std::map<uint64_t, std::shared_ptr<http2_server_connection>> connections_;
        std::atomic<uint64_t> next_connection_id_{1};
 
        // Settings
        mutable std::mutex settings_mutex_;
        http2_settings settings_;
 
        // HPACK encoder for all connections
        std::shared_ptr<hpack_encoder> encoder_;
        std::shared_ptr<hpack_decoder> decoder_;
 
        // Cleanup timer
        std::unique_ptr<asio::steady_timer> cleanup_timer_;
 
        // Constants
        static constexpr std::string_view CONNECTION_PREFACE =
            "PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n";
        static constexpr size_t FRAME_HEADER_SIZE = 9;
    };
 
    class http2_server_connection : public std::enable_shared_from_this<http2_server_connection>
    {
    public:
        http2_server_connection(uint64_t connection_id,
                                asio::ip::tcp::socket socket,
                                const http2_settings& settings,
                                http2_server::request_handler_t request_handler,
                                http2_server::error_handler_t error_handler);
 
        http2_server_connection(uint64_t connection_id,
                                std::unique_ptr<asio::ssl::stream<asio::ip::tcp::socket>> socket,
                                const http2_settings& settings,
                                http2_server::request_handler_t request_handler,
                                http2_server::error_handler_t error_handler);
 
        ~http2_server_connection();
 
        // Non-copyable, non-movable
        http2_server_connection(const http2_server_connection&) = delete;
        http2_server_connection& operator=(const http2_server_connection&) = delete;
        http2_server_connection(http2_server_connection&&) = delete;
        http2_server_connection& operator=(http2_server_connection&&) = delete;
 
        auto start() -> VoidResult;
 
        auto stop() -> VoidResult;
 
        [[nodiscard]] auto is_alive() const -> bool;
 
        [[nodiscard]] auto connection_id() const -> uint64_t;
 
        [[nodiscard]] auto stream_count() const -> size_t;
 
    private:
        friend class http2_server;
        auto shutdown_transport() -> void;
 
        // Connection setup
        auto read_connection_preface() -> void;
        auto send_settings() -> VoidResult;
        auto handle_settings_frame(const settings_frame& frame) -> VoidResult;
        auto send_settings_ack() -> VoidResult;
 
        // Frame I/O
        auto start_reading() -> void;
        auto read_frame_header() -> void;
        auto read_frame_payload(uint32_t length) -> void;
        auto send_frame(const frame& f) -> VoidResult;
        auto process_frame(std::unique_ptr<frame> f) -> VoidResult;
 
        // Stream management
        auto get_or_create_stream(uint32_t stream_id) -> http2_stream*;
        auto close_stream(uint32_t stream_id) -> void;
 
        // Frame handlers
        auto handle_headers_frame(const headers_frame& f) -> VoidResult;
        auto handle_data_frame(const data_frame& f) -> VoidResult;
        auto handle_rst_stream_frame(const rst_stream_frame& f) -> VoidResult;
        auto handle_ping_frame(const ping_frame& f) -> VoidResult;
        auto handle_goaway_frame(const goaway_frame& f) -> VoidResult;
        auto handle_window_update_frame(const window_update_frame& f) -> VoidResult;
 
        // Request completion
        auto dispatch_request(uint32_t stream_id) -> void;
 
        uint64_t connection_id_;                  
        bool use_tls_;                            
 
        // Socket (one of these is used)
        std::unique_ptr<asio::ip::tcp::socket> plain_socket_;
        std::unique_ptr<asio::ssl::stream<asio::ip::tcp::socket>> tls_socket_;
        std::mutex transport_shutdown_mutex_;       
 
        // Connection state
        std::atomic<bool> is_alive_{true};
        std::atomic<bool> preface_received_{false};
        std::atomic<bool> goaway_sent_{false};
 
        // Stream management
        std::mutex streams_mutex_;
        std::map<uint32_t, http2_stream> streams_;
        uint32_t last_stream_id_{0};
 
        // Settings
        http2_settings local_settings_;
        http2_settings remote_settings_;
 
        // HPACK
        hpack_encoder encoder_;
        hpack_decoder decoder_;
 
        // Flow control
        int32_t connection_window_size_{65535};
 
        // Handlers
        http2_server::request_handler_t request_handler_;
        http2_server::error_handler_t error_handler_;
 
        // Read buffer
        std::vector<uint8_t> read_buffer_;
        std::array<uint8_t, 9> frame_header_buffer_;
 
#if defined(NETWORK_ENABLE_TEST_INJECTION)
        // Test-only: grants tests/support/http2_server_test_access access to
        // the private process_frame() dispatcher and selected member fields
        // without leaking them through the public API. Used by
        // tests/unit/http2_server_dispatcher_branch_test.cpp to bypass the
        // SETTINGS handshake gate so per-frame branches can be measured under
        // coverage instrumentation (Issue #1121).
        friend class kcenon::network::tests::support::http2_server_test_access;
#endif
    };
 
} // namespace kcenon::network::protocols::http2