LoadBalancer.h

Go to the documentation of this file.

 
#ifndef LOADBALANCER_H
#define LOADBALANCER_H
 
#include <cstddef>
#include <iosfwd>
#include <queue>
#include <string>
#include <vector>
 
#include "Firewall.h"
#include "Logger.h"
#include "Request.h"
#include "WebServer.h"

struct ScalingPolicy {
    double upperFactor = 80.0;     
    double lowerFactor = 50.0;     
    unsigned int cooldownCycles = 10; 
    unsigned int minServers = 1;   
    unsigned int maxServers = 100; 
};

struct ScaleEvent {
    enum class Kind {
        Added,       
        Reactivated, 
        Removed,     
        Retiring,    
        Retired      
    };
    unsigned long cycle = 0;        
    Kind kind = Kind::Added;        
    unsigned int serverId = 0;      
    std::size_t queueSize = 0;      
    std::size_t activeServers = 0;  
};

struct Snapshot {
    unsigned long cycle = 0;       
    std::size_t queueSize = 0;     
    std::size_t liveServers = 0;   
    std::size_t busyServers = 0;   
    std::size_t idleServers = 0;   
    std::size_t retiringServers = 0; 
    unsigned long completed = 0;   
    unsigned long rejected = 0;    
};

struct LoadBalancerStats {
    unsigned long received = 0;      
    unsigned long admitted = 0;      
    unsigned long rejected = 0;      
    unsigned long discarded = 0;     
    unsigned long dispatched = 0;    
    unsigned long completed = 0;     
    unsigned long long totalWait = 0; 
    unsigned long maxWait = 0;       
    unsigned long scaleUps = 0;      
    unsigned long scaleDowns = 0;    
    std::size_t startingQueue = 0;   
    std::size_t queueAfterFirstDispatch = 0; 
    std::size_t peakQueue = 0;       
    unsigned long peakQueueCycle = 0; 
    std::size_t initialServers = 0;  
    std::size_t minActiveServers = 0;  
    std::size_t peakLiveServers = 0;   
    unsigned long long serverCycles = 0; 
    unsigned long long busyCycles = 0;   
};

class LoadBalancer {
public:
    LoadBalancer(std::string name, std::size_t initialServers, const ScalingPolicy& policy,
                 const Firewall& firewall, std::size_t maxQueue, Logger& logger);

    bool admit(const Request& request, unsigned long cycle);

    void start();

    void processCycle(unsigned long cycle, const std::vector<Request>& arrivals);

    void recordSnapshot(unsigned long cycle);

    std::string statusLine(unsigned long cycle) const;

    void summarize(std::ostream& out) const;

    const std::string& name() const;
    std::size_t queueSize() const;
    std::size_t liveServers() const;
    std::size_t activeServers() const;
    std::size_t busyServers() const;
    std::size_t idleServers() const;
    std::size_t retiringServers() const;
    std::size_t inService() const;
    const LoadBalancerStats& stats() const;
    const std::vector<ScaleEvent>& scaleEvents() const;
    const std::vector<Snapshot>& snapshots() const;
    const std::vector<WebServer>& servers() const;
    const ScalingPolicy& policy() const;
    const Firewall& firewall() const;
 
private:
    void completeWork(unsigned long cycle);
    void adjustCapacity(unsigned long cycle);
    void dispatch(unsigned long cycle);
    void addServer(unsigned long cycle);
    void recordScale(ScaleEvent::Kind kind, unsigned long cycle, unsigned int serverId);
    void updateExtremes(unsigned long cycle);
    std::string describe(const Request& request) const;
 
    std::string name_;
    ScalingPolicy policy_;
    Firewall firewall_;
    std::size_t maxQueue_;
    Logger& logger_;
    std::queue<Request> pending_;
    std::vector<WebServer> servers_;
    unsigned int nextServerId_ = 1;
    LoadBalancerStats stats_;
    std::vector<ScaleEvent> scaleEvents_;
    std::vector<Snapshot> snapshots_;
};
 
#endif