http_server.hpp

浏览该文件的文档.

#ifndef NEFORCE_NETWORK_HTTP_HTTP_SERVER_HPP__
#define NEFORCE_NETWORK_HTTP_HTTP_SERVER_HPP__

 
#include "NeForce/core/async/condition_variable.hpp"
#include "NeForce/core/async/io_context.hpp"
#include "NeForce/network/http/http_router.hpp"
#include "NeForce/network/http/session_store.hpp"
#include "NeForce/network/http/websocket.hpp"
#include "NeForce/network/ssl/sni_manager.hpp"
#include "NeForce/network/tcp/tcp_server.hpp"
NEFORCE_BEGIN_NAMESPACE__
NEFORCE_BEGIN_HTTP__


class NEFORCE_API http_server {
public:
    using socket_type = tcp_socket; 

    struct NEFORCE_API session_manager {
        unordered_map<string, http_session> sessions_; 
        mutable mutex mutex_;                          
        condition_variable cv_;                        
        atomic<bool> cleanup_running_;                 
        thread cleanup_thread_;                        
        seconds cleanup_interval_{300};                
        size_t max_sessions_{10000};                   
 
        session_manager();
        ~session_manager();
 
        session_manager(const session_manager&) = delete;
        session_manager& operator=(const session_manager&) = delete;
 
        session_manager(session_manager&&) noexcept = delete;
        session_manager& operator=(session_manager&&) noexcept = delete;
 
        http_session* get_session(const string& session_id, bool create = true);
        void remove_session(const string& session_id) noexcept;
        void cleanup_expired_sessions();
        bool session_exists(const string& session_id) const noexcept;
 
        size_t session_count() const noexcept;
        void set_cleanup_interval(seconds interval) noexcept;
        void set_max_sessions(size_t max) noexcept;
    };
 
private:
    io_context* ctx_{nullptr};           
    unique_ptr<tcp_server_base> server_; 
    vector<thread> h2c_threads_;         
    mutable mutex h2c_mutex_;            
    http_router router_;                 
    websocket_server ws_server_;         
    session_manager session_manager_;    
    sni_manager sni_;                    
 
    http_cookie_name cookie_name_{http_cookie_name::JSESSIONID()}; 
    unique_ptr<http::session_store> session_store_;                
 
    mutable mutex conn_mutex_;
    unordered_map<string, size_t> conn_per_ip_; 
 
    static http_request parse_request(tcp_socket* client_socket, session_manager& manager, const http_cookie_name& name,
                                      byte_size max_header_size, byte_size max_body_size, size_t max_header_count,
                                      milliseconds body_read_timeout);
 
    static http_session* get_or_create_session(http_request& request, bool create, session_manager& manager,
                                               const http_cookie_name& name);
 
public:
    byte_size max_server_header_size{16_KB}; 
    byte_size max_server_body_size{100_MB};  
    bool enable_websocket{true};             
    bool enable_connect{true};               
 
    size_t max_connections_per_ip{0};      
    size_t max_header_count{100};          
    size_t max_h2c_upgrades{32};           
    milliseconds body_read_timeout{30000}; 
 
    // TODO: HTTP/3 (QUIC) protocol support — integrate QUIC transport (RFC 9114) for 0-RTT, reduced head-of-line blocking
    // TODO: Configuration file support — load server settings from YAML/JSON config files (port, SSL, worker_count, limits)
    // TODO: Server-sent events (SSE) — add SSE stream support for unidirectional real-time data push to browsers
    // TODO: Actuator-style management endpoints — /actuator/metrics, /actuator/env, /actuator/loggers, /actuator/threaddump
    // TODO: Hot reload / DevTools — watch static file directory for changes and notify connected browsers (LiveReload)
 
private:
    unordered_map<string, function<bool(http_request&, tcp_socket*)>> upgrade_handlers_;
 
    void handle_client(unique_ptr<tcp_socket> client_socket);
    bool try_upgrade(unique_ptr<tcp_socket>& client_socket, http_request& request);
    void handle_connect(const unique_ptr<tcp_socket>& client_socket, http_request& request);
    void handle_request_with_forward(tcp_socket& client_socket, http_request& request, http_session* sess);
 
public:
    explicit http_server(ports port, io_context& ioc, size_t worker_count = 0);

    http_server(ports port, io_context& ioc, ssl_context ctx, size_t worker_count = 0);
 
    ~http_server();
 
    http_server(const http_server&) = delete;
    http_server& operator=(const http_server&) = delete;
 
    http_server(http_server&&) noexcept = delete;
    http_server& operator=(http_server&&) noexcept = delete;

    bool load_certificate(const string& cert_file, const string& key_file);

    void add_sni_host(const string& hostname, ssl_context ctx) { sni_.add_host(hostname, move(ctx)); }

    NEFORCE_NODISCARD sni_manager& sni() noexcept { return sni_; }

    NEFORCE_NODISCARD const sni_manager& sni() const noexcept { return sni_; }

    NEFORCE_NODISCARD http_router& router() noexcept { return router_; }

    NEFORCE_NODISCARD const http_router& router() const noexcept { return router_; }

    NEFORCE_NODISCARD websocket_server& websocket() noexcept { return ws_server_; }

    NEFORCE_NODISCARD const websocket_server& websocket() const noexcept { return ws_server_; }

    void set_cookie_name(http_cookie_name name) noexcept { cookie_name_ = move(name); }

    void set_session_store(unique_ptr<session_store> store) noexcept { session_store_ = move(store); }

    NEFORCE_NODISCARD http::session_store* session_store() noexcept { return session_store_.get(); }

    NEFORCE_NODISCARD const http_cookie_name& cookie_name() const noexcept { return cookie_name_; }

    void set_session_cleanup_interval(seconds interval) noexcept { session_manager_.set_cleanup_interval(interval); }

    void set_max_sessions(size_t max) noexcept { session_manager_.set_max_sessions(max); }

    void set_upgrade_handler(string protocol, function<bool(http_request&, tcp_socket*)> handler) {
        upgrade_handlers_[move(protocol)] = move(handler);
    }

    NEFORCE_NODISCARD ports port() const noexcept { return server_->port(); }

    NEFORCE_NODISCARD bool is_running() const noexcept { return server_->is_running(); }

    NEFORCE_NODISCARD http_session* get_session(http_request& request, bool create = false);

    bool start(int backlog = SOMAXCONN) { return server_->start(backlog); }

    void stop() noexcept { server_->stop(); }

    NEFORCE_NODISCARD tcp_server_base* server() noexcept { return server_.get(); }

    NEFORCE_NODISCARD const tcp_server_base* server() const noexcept { return server_.get(); }
};
 // HTTP
 
NEFORCE_END_HTTP__
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_NETWORK_HTTP_HTTP_SERVER_HPP__