load_balancer.hpp

浏览该文件的文档.

#ifndef NEFORCE_NETWORK_HTTP_LOAD_BALANCER_HPP__
#define NEFORCE_NETWORK_HTTP_LOAD_BALANCER_HPP__

 
#include "NeForce/core/async/atomic.hpp"
#include "NeForce/core/async/mutex.hpp"
#include "NeForce/core/container/vector.hpp"
#include "NeForce/core/functional/function.hpp"
#include "NeForce/core/time/clocks.hpp"
#include "NeForce/core/utility/packages.hpp"
#include "NeForce/network/util/ports.hpp"
NEFORCE_BEGIN_NAMESPACE__
NEFORCE_BEGIN_HTTP__


enum class lb_strategy : uint8_t {
    ROUND_ROBIN,       
    LEAST_CONNECTIONS, 
    WEIGHTED,          
    RANDOM             
};

struct lb_backend {
    string host;
    ports port;
    string scheme{"http"};
    size_t weight{1};
    atomic<size_t> active_connections{0};
    atomic<bool> healthy{true};
    uint64_t last_health_check_ms{0};
    size_t consecutive_failures{0};
 
    lb_backend() = default;
    lb_backend(string h, ports p, string s = "http", size_t w = 1) :
    host(move(h)),
    port(p),
    scheme(move(s)),
    weight(w) {}
};

class NEFORCE_API load_balancer {
public:
    using health_check_cb = function<bool(const lb_backend&)>;
 
private:
    vector<lb_backend> backends_;
    lb_strategy strategy_{lb_strategy::ROUND_ROBIN};
    mutable mutex mutex_;
    atomic<size_t> rr_counter_{0};
 
    size_t max_failures_{3};                    
    milliseconds health_check_interval_{10000}; 
    milliseconds health_check_timeout_{3000};   
 
    health_check_cb health_checker_; 
 
public:
    load_balancer() = default;
 
    void add_backend(lb_backend backend) {
        lock<mutex> lk(mutex_);
        backends_.push_back(move(backend));
    }
 
    void remove_backend(const string& host, ports port) {
        lock<mutex> lk(mutex_);
        for (auto it = backends_.begin(); it != backends_.end(); ++it) {
            if (it->host == host && it->port == port) {
                backends_.erase(it);
                return;
            }
        }
    }
 
    void set_strategy(lb_strategy s) {
        lock<mutex> lk(mutex_);
        strategy_ = s;
    }
 
    void set_health_check(health_check_cb cb) {
        lock<mutex> lk(mutex_);
        health_checker_ = move(cb);
    }

    void set_max_failures(size_t max) { max_failures_ = max; }
    void set_health_check_interval(milliseconds ms) { health_check_interval_ = ms; }
    void set_health_check_timeout(milliseconds ms) { health_check_timeout_ = ms; }

    lb_backend* select_backend();

    static void release_backend(lb_backend* backend);

    void mark_failure(lb_backend* backend);

    void run_health_checks();

    vector<string> backend_hosts() const {
        lock<mutex> lk(mutex_);
        vector<string> hosts;
        for (const auto& b: backends_) {
            hosts.push_back(b.host + ":" + to_string(b.port.value()));
        }
        return hosts;
    }
 
    size_t backend_count() const noexcept { return backends_.size(); }
    lb_strategy strategy() const noexcept { return strategy_; }

    size_t healthy_count() const;
 
private:
    lb_backend* select_round_robin();
    lb_backend* select_least_connections();
    lb_backend* select_weighted();
    lb_backend* select_random();
};
 
// TODO: Circuit breaker pattern — track failure rate per backend, auto-open circuit on threshold breach, half-open probing
// TODO: Service discovery integration — Consul / Eureka / Nacos / DNS-based backend registration and health sync
// TODO: Sticky sessions — session affinity based on cookie or client IP for stateful backends
 // HTTP
 
NEFORCE_END_HTTP__
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_NETWORK_HTTP_LOAD_BALANCER_HPP__