controller.hpp

#pragma once
 
#include <atomic>
#include <chrono>
#include <cstddef>
#include <optional>
#include <string>
 
#include <userver/congestion_control/config.hpp>
#include <userver/congestion_control/limiter.hpp>
#include <userver/congestion_control/sensor.hpp>
#include <userver/dynamic_config/source.hpp>
#include <userver/formats/json_fwd.hpp>
 
USERVER_NAMESPACE_BEGIN
 
/// Congestion Control
namespace congestion_control {
 
struct PolicyState {
    size_t times_with_overload{0};
    size_t times_wo_overload{0};
 
    bool is_overloaded{false};
    std::optional<size_t> current_limit;
 
    size_t max_up_delta{1};
};
 
struct Stats final {
    std::atomic<size_t> no_limit{0};
    std::atomic<size_t> not_overload_no_pressure{0};
    std::atomic<size_t> not_overload_pressure{0};
    std::atomic<size_t> overload_no_pressure{0};
    std::atomic<size_t> overload_pressure{0};
 
    std::atomic<size_t> current_state{0};
    std::atomic<std::chrono::seconds> last_overload_pressure{
        std::chrono::duration_cast<std::chrono::seconds>(std::chrono::steady_clock::now().time_since_epoch()) -
        std::chrono::hours(1)};
};
 
class Controller final {
public:
    Controller(std::string name, dynamic_config::Source config_source);
 
    void Feed(const Sensor::Data&);
 
    Limit GetLimit() const;
 
    Limit GetLimitRaw() const;
 
    void SetEnabled(bool enabled);
 
    bool IsEnabled() const;
 
    const Stats& GetStats() const;
 
private:
    bool IsOverloadedNow(const Sensor::Data& data, const Policy& policy) const;
 
    size_t CalcNewLimit(const Sensor::Data& data, const Policy& policy) const;
 
    static bool IsThresholdReached(const Sensor::Data& data, int percent);
 
    const std::string name_;
    Limit limit_;
    dynamic_config::Source config_source_;
    PolicyState state_;
    std::atomic<bool> is_enabled_;
 
    Stats stats_;
};
 
struct ControllerInfo {
    Sensor& sensor;
    Limiter& limiter;
    Controller& controller;
};
 
}  // namespace congestion_control
 
USERVER_NAMESPACE_END