rate_limiter.hpp

浏览该文件的文档.

#ifndef NEFORCE_NETWORK_HTTP_RATE_LIMITER_HPP__
#define NEFORCE_NETWORK_HTTP_RATE_LIMITER_HPP__

 
#include "NeForce/core/async/atomic.hpp"
#include "NeForce/core/time/clocks.hpp"
#include "NeForce/network/http/http_filter.hpp"
NEFORCE_BEGIN_NAMESPACE__
NEFORCE_BEGIN_HTTP__


struct NEFORCE_API token_bucket {
    double tokens{0.};          
    uint64_t last_refill_ms{0}; 
    double refill_rate{1.};     
    double capacity{1.};        
    mutable mutex mutex_;       
 
    token_bucket() = default;
    ~token_bucket() = default;
 
    token_bucket(double rate, double burst) :
    tokens(burst),
    last_refill_ms(static_cast<uint64_t>(steady_clock::now().since_epoch().count() / 1'000'000)),
    refill_rate(rate),
    capacity(burst) {}
 
    token_bucket(const token_bucket& other) :
    tokens(other.tokens),
    last_refill_ms(other.last_refill_ms),
    refill_rate(other.refill_rate),
    capacity(other.capacity) {}
 
    token_bucket& operator=(const token_bucket& other) {
        if (this != &other) {
            tokens = other.tokens;
            last_refill_ms = other.last_refill_ms;
            refill_rate = other.refill_rate;
            capacity = other.capacity;
        }
        return *this;
    }

    bool try_consume(uint64_t now_ms);

    void refill(uint64_t now_ms);
};

class NEFORCE_API token_bucket_limiter {
private:
    struct bucket_entry {
        token_bucket bucket;
        uint64_t last_access_ms;
    };
 
    double default_rate_{10.0};
    double default_burst_{20.0};
 
    mutable mutex mutex_;
    unordered_map<string, bucket_entry> buckets_;
 
    static constexpr size_t MAX_BUCKETS_COUNT{10000};
 
public:
    token_bucket_limiter() = default;

    bool allow(const string& key, double rate = 0.0, double burst = 0.0);

    void set_default_rate(double rate);
    void set_default_burst(double burst);
    NEFORCE_NODISCARD size_t size() const;

    void cleanup_expired(seconds max_age = seconds{300});
};
 

class NEFORCE_API token_bucket_filter final : public http_filter {
private:
    token_bucket_limiter limiter_;
 
public:
    double default_rate{10.0};  
    double default_burst{20.0}; 
    bool per_route{false};      
    bool enabled{true};         
 
    token_bucket_filter() = default;
 
    explicit token_bucket_filter(double rate, double burst) :
    default_rate(rate),
    default_burst(burst) {}
 
    bool pre_filter(http_request& request, http_response& response) override;
    void do_filter(http_request& request, http_response& response) override {}
 
    void cleanup_expired(seconds max_age = seconds{300});
 
    NEFORCE_NODISCARD string name() const override { return "token_bucket_filter"; }
 
    // TODO: Distributed rate limiting — Redis/Lua-script based shared counter for multi-instance rate limit coordination
    // TODO: Sliding window algorithm — more precise rate limiting using sliding log/window instead of token bucket
    // TODO: Rate limit response headers — X-RateLimit-Limit, X-RateLimit-Remaining, X-RateLimit-Reset in 429 responses
};
 // HTTP
 
NEFORCE_END_HTTP__
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_NETWORK_HTTP_RATE_LIMITER_HPP__