http_server.hpp

浏览该文件的文档.

#ifndef NEFORCE_NETWORK_HTTP_HTTP_SERVER_HPP__
#define NEFORCE_NETWORK_HTTP_HTTP_SERVER_HPP__

 
#include "NeForce/core/numeric/random.hpp"
#include "NeForce/network/http/http_router.hpp"
#include "NeForce/network/http/websocket.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; 
 
private:
    struct NEFORCE_API session_manager {
        unordered_map<string, http_session> sessions_; 
        mutable mutex mutex_;                          
        atomic<bool> cleanup_running_;                 
        thread cleanup_thread_;                        
        random_mt rand_;                               
        seconds cleanup_interval_{300};                
        size_t max_sessions_{10000};                   
 
        string generate_session_id();
 
        session_manager();
        ~session_manager();
 
        session_manager(const session_manager&) = delete;
        session_manager& operator=(const session_manager&) = delete;
 
        session_manager(session_manager&&) noexcept = default;
        session_manager& operator=(session_manager&&) noexcept = default;
 
        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;
    };
 
    unique_ptr<tcp_server_base> server_; 
    http_router router_;                 
    websocket_server ws_server_;         
    session_manager session_manager_;    
 
    http_cookie_name cookie_name_{http_cookie_name::JSESSIONID()}; 
 
    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);
 
    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; 
    byte_size max_server_body_size;   
    bool enable_websocket{true};      
 
private:
    void handle_client(tcp_socket client_socket);
    bool try_websocket_upgrade(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, size_t worker_count = thread_pool::max_thread_threshhold());

    http_server(ports port, ssl_context ctx, size_t worker_count = thread_pool::max_thread_threshhold());
 
    ~http_server() = default;
 
    http_server(const http_server&) = delete;
    http_server& operator=(const http_server&) = delete;
 
    http_server(http_server&&) noexcept = default;
    http_server& operator=(http_server&&) noexcept = default;

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

    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); }

    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); }

    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__