http_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 "internal/core/messaging_server.h"
#include "internal/http/http_types.h"
#include "internal/http/http_parser.h"
#include "internal/http/http_error.h"
#include "kcenon/network/detail/utils/result_types.h"
#include "internal/utils/compression_pipeline.h"
#include <string>
#include <map>
#include <functional>
#include <memory>
#include <regex>
#include <vector>
#include <chrono>
 
namespace kcenon::network::core
{
    struct http_request_buffer
    {
        std::vector<uint8_t> data;
        bool headers_complete = false;
        std::size_t headers_end_pos = 0;
        std::size_t content_length = 0;
 
        static constexpr std::size_t MAX_REQUEST_SIZE = 10 * 1024 * 1024;  // 10MB
        static constexpr std::size_t MAX_HEADER_SIZE = 64 * 1024;          // 64KB
 
        auto append(const std::vector<uint8_t>& chunk) -> bool;
 
        auto is_complete() const -> bool;
 
        static auto find_header_end(const std::vector<uint8_t>& data) -> std::size_t;
 
        static auto parse_content_length(const std::vector<uint8_t>& data,
                                         std::size_t headers_end) -> std::size_t;
    };
 
    struct http_request_context
    {
        internal::http_request request;
        std::map<std::string, std::string> path_params; // Extracted path parameters (e.g., /users/:id)
 
        auto get_query_param(const std::string& name) const -> std::optional<std::string>
        {
            auto it = request.query_params.find(name);
            if (it != request.query_params.end())
            {
                return it->second;
            }
            return std::nullopt;
        }
 
        auto get_path_param(const std::string& name) const -> std::optional<std::string>
        {
            auto it = path_params.find(name);
            if (it != path_params.end())
            {
                return it->second;
            }
            return std::nullopt;
        }
    };
 
    using http_handler = std::function<internal::http_response(const http_request_context& ctx)>;
 
    using error_handler = std::function<internal::http_response(const internal::http_error& error)>;
 
    struct http_route
    {
        internal::http_method method;
        std::string pattern;        // e.g., "/users/:id"
        std::regex regex_pattern;   // Compiled regex for matching
        std::vector<std::string> param_names; // Parameter names extracted from pattern
        http_handler handler;
 
        auto matches(internal::http_method method, const std::string& path,
                     std::map<std::string, std::string>& path_params) const -> bool;
    };
 
    class http_server : public std::enable_shared_from_this<http_server>
    {
    public:
        explicit http_server(const std::string& server_id);
 
        ~http_server();
 
        auto start(unsigned short port) -> VoidResult;
 
        auto stop() -> VoidResult;
 
        auto wait_for_stop() -> void;
 
        auto get(const std::string& pattern, http_handler handler) -> void;
 
        auto post(const std::string& pattern, http_handler handler) -> void;
 
        auto put(const std::string& pattern, http_handler handler) -> void;
 
        auto del(const std::string& pattern, http_handler handler) -> void;
 
        auto patch(const std::string& pattern, http_handler handler) -> void;
 
        auto head(const std::string& pattern, http_handler handler) -> void;
 
        auto options(const std::string& pattern, http_handler handler) -> void;
 
        auto set_not_found_handler(http_handler handler) -> void;
 
        auto set_error_handler(http_handler handler) -> void;
 
        auto set_error_handler(internal::http_error_code code, error_handler handler) -> void;
 
        auto set_default_error_handler(error_handler handler) -> void;
 
        auto set_request_timeout(std::chrono::milliseconds timeout) -> void;
 
        auto set_json_error_responses(bool enable) -> void;
 
        auto set_compression_enabled(bool enable) -> void;
 
        auto set_compression_threshold(size_t threshold_bytes) -> void;
 
    private:
        auto register_route(internal::http_method method,
                           const std::string& pattern,
                           http_handler handler) -> void;
 
        auto find_route(internal::http_method method,
                       const std::string& path,
                       std::map<std::string, std::string>& path_params) const
            -> const http_route*;
 
        auto handle_request(const std::vector<uint8_t>& request_data) -> std::vector<uint8_t>;
 
        auto process_http_request(const internal::http_request& request) -> internal::http_response;
 
        auto should_close_connection(const internal::http_request& request,
                                     const internal::http_response& response) const -> bool;
 
        auto create_error_response(int status_code, const std::string& message)
            -> internal::http_response;
 
        static auto pattern_to_regex(const std::string& pattern,
                                      std::vector<std::string>& param_names) -> std::string;
 
        auto apply_compression(const internal::http_request& request,
                              internal::http_response& response) -> void;
 
        auto choose_compression_algorithm(const std::string& accept_encoding) const
            -> utils::compression_algorithm;
 
        auto build_error_response(const internal::http_error& error) -> internal::http_response;
 
        std::shared_ptr<messaging_server> tcp_server_;
        std::vector<http_route> routes_;
        std::mutex routes_mutex_;
        http_handler not_found_handler_;
        http_handler error_handler_;
 
        // Request buffering support
        std::map<std::shared_ptr<session::messaging_session>, http_request_buffer> session_buffers_;
        std::mutex buffers_mutex_;
 
        // Compression settings
        bool compression_enabled_ = false;
        size_t compression_threshold_ = 1024;  // 1KB default
        std::mutex compression_mutex_;
 
        // Error handling settings
        std::map<internal::http_error_code, error_handler> error_handlers_;
        std::mutex error_handlers_mutex_;
        error_handler default_error_handler_;
        bool use_json_errors_ = false;
        std::chrono::milliseconds request_timeout_{30000};  // 30 seconds default
    };
 
} // namespace kcenon::network::core