reverse_proxy.hpp

浏览该文件的文档.

#ifndef NEFORCE_NETWORK_HTTP_REVERSE_PROXY_HPP__
#define NEFORCE_NETWORK_HTTP_REVERSE_PROXY_HPP__
 
#include "NeForce/core/async/mutex.hpp"
#include "NeForce/core/container/unordered_map.hpp"
#include "NeForce/core/functional/function.hpp"
#include "NeForce/network/http/http_client.hpp"
#include "NeForce/network/http/http_filter.hpp"
NEFORCE_BEGIN_NAMESPACE__
NEFORCE_BEGIN_HTTP__


struct proxy_backend {
    string host;
    ports port;
    string scheme{"http"}; 
    size_t weight{1};      
    bool enabled{true};    
 
    NEFORCE_NODISCARD string to_url(const string& path) const {
        return scheme + "://" + host + ":" + to_string(port.value()) + path;
    }
};

class NEFORCE_API reverse_proxy_filter final : public http_filter {
public:
    using header_rewrite_cb = function<void(unordered_map<string, string>&)>;
    using backend_selector_cb = function<proxy_backend(const http_request&)>;

    milliseconds connect_timeout{5000};
    milliseconds send_timeout{5000};
    milliseconds receive_timeout{30000};
    bool follow_redirects{false};
    bool passthrough_host_header{false};

    explicit reverse_proxy_filter(io_context& ctx) :
    ctx_(&ctx) {}

    reverse_proxy_filter(io_context& ctx, string host, ports port, string scheme = "http") :
    ctx_(&ctx) {
        add_backend({move(host), port, move(scheme)});
    }

    void add_backend(proxy_backend backend) {
        lock<mutex> lk(mutex_);
        backends_.push_back(move(backend));
    }

    void set_path_prefix(string prefix) {
        lock<mutex> lk(mutex_);
        path_prefix_ = move(prefix);
    }

    void set_backend_selector(backend_selector_cb selector) {
        lock<mutex> lk(mutex_);
        selector_ = move(selector);
    }

    void set_header_rewrite(header_rewrite_cb cb) {
        lock<mutex> lk(mutex_);
        header_rewrite_ = move(cb);
    }

    void add_skip_response_header(string header) {
        lock<mutex> lk(mutex_);
        skip_resp_headers_.push_back(move(header));
    }
 
    bool pre_filter(http_request& request, http_response& response) override;
    void do_filter(http_request& request, http_response& response) override {}
    NEFORCE_NODISCARD string name() const override { return "reverse_proxy_filter"; }
 
private:
    io_context* ctx_{nullptr};
    vector<proxy_backend> backends_;
    string path_prefix_;
    backend_selector_cb selector_;
    header_rewrite_cb header_rewrite_;
    vector<string> skip_resp_headers_;
    mutable mutex mutex_;
    size_t rr_counter_{0}; 
 
    proxy_backend select_backend(const http_request& request);
    bool should_proxy(const string& path) const;
    http_client_response forward(const proxy_backend& backend, const http_request& request);
    void copy_response(const http_client_response& from, http_response& to);
 
    // TODO: WebSocket proxy — tunnel WebSocket connections through to backend with bidirectional frame forwarding
    // TODO: Response body transformation — modify/rewrite proxied response bodies (e.g., URL rewriting for CDN paths)
};
 // HTTP
 
NEFORCE_END_HTTP__
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_NETWORK_HTTP_REVERSE_PROXY_HPP__