LoadBalancer.cpp

/**
 * @file LoadBalancer.cpp
 * @brief Implements the LoadBalancer class -- the core simulation engine.
 */

#include "LoadBalancer.h"
#include <iostream>
#include <sstream>
#include <cstdlib>
#include <iomanip>

using namespace std;

// colors for terminal output
string RESET   = "\033[0m";
string RED     = "\033[31m";
string GREEN   = "\033[32m";
string YELLOW  = "\033[33m";
string CYAN    = "\033[36m";
string MAGENTA = "\033[35m";
string BOLD    = "\033[1m";
string WHITE   = "\033[37m";

unsigned long LoadBalancer::ipToInt(const string& ip) {
    unsigned long result = 0;
    istringstream ss(ip);
    string part;
    for (int i = 0; i < 4; i++) {
        getline(ss, part, '.');
        result = (result << 8) | (stoul(part) & 0xFF);
    }
    return result;
}

void LoadBalancer::parseBlockedIPs(const string& raw) {
    if (raw.empty()) return;

    istringstream stream(raw);
    string range;
    while (getline(stream, range, ',')) {
        size_t dash = range.find('-');
        if (dash == string::npos) continue;

        string startIP = range.substr(0, dash);
        string endIP = range.substr(dash + 1);

        // trim spaces
        while (!startIP.empty() && startIP.front() == ' ') startIP.erase(0, 1);
        while (!startIP.empty() && startIP.back() == ' ') startIP.pop_back();
        while (!endIP.empty() && endIP.front() == ' ') endIP.erase(0, 1);
        while (!endIP.empty() && endIP.back() == ' ') endIP.pop_back();

        blockedRanges.push_back(make_pair(ipToInt(startIP), ipToInt(endIP)));
    }
}

LoadBalancer::LoadBalancer(int numServers, int initialQueueSize, const Config& cfg) {
    clockCycle = 0;
    totalProcessed = 0;
    totalRejected = 0;
    serversAdded = 0;
    serversRemoved = 0;
    startingQueueSize = 0;
    nextServerId = 0;
    cumulativeQueueSize = 0;
    balanceWaitTimer = 0;

    minTaskTime = cfg.getInt("min_task_time", 5);
    maxTaskTime = cfg.getInt("max_task_time", 500);
    balanceCooldown = cfg.getInt("balance_cooldown", 10);
    newRequestChance = cfg.getInt("new_request_chance", 30);
    newRequestBatch = cfg.getInt("new_request_batch", 3);
    logInterval = cfg.getInt("log_interval", 500);

    parseBlockedIPs(cfg.get("blocked_ips"));

    logFile.open("log.txt");

    // create the initial servers
    for (int i = 0; i < numServers; i++) {
        servers.push_back(new WebServer(nextServerId));
        nextServerId++;
    }

    // fill the initial queue
    for (int i = 0; i < initialQueueSize; i++) {
        Request r = Request::generateRandom(minTaskTime, maxTaskTime);
        if (!isBlocked(r.ipIn)) {
            queue.enqueue(r);
        } else {
            totalRejected++;
        }
    }
    startingQueueSize = queue.getSize();
}

LoadBalancer::~LoadBalancer() {
    for (int i = 0; i < (int)servers.size(); i++) {
        delete servers[i];
    }
    if (logFile.is_open()) logFile.close();
}

bool LoadBalancer::isBlocked(const string& ip) {
    unsigned long val = ipToInt(ip);
    for (int i = 0; i < (int)blockedRanges.size(); i++) {
        if (val >= blockedRanges[i].first && val <= blockedRanges[i].second) {
            return true;
        }
    }
    return false;
}

void LoadBalancer::log(const string& message, const string& colorCode) {
    cout << colorCode << message << RESET << endl;
    if (logFile.is_open()) {
        logFile << message << endl;
    }
}

void LoadBalancer::logStatus() {
    int busyCount = 0;
    for (int i = 0; i < (int)servers.size(); i++) {
        if (servers[i]->isBusy()) busyCount++;
    }
    int idleCount = (int)servers.size() - busyCount;

    ostringstream oss;
    oss << "[Cycle " << setw(6) << clockCycle << "] "
        << "Queue: " << setw(5) << queue.getSize()
        << " | Servers: " << servers.size()
        << " (busy " << busyCount << " / idle " << idleCount << ")"
        << " | Processed: " << totalProcessed
        << " | Rejected: " << totalRejected;

    log(oss.str(), BOLD + WHITE);
}

void LoadBalancer::addServer() {
    servers.push_back(new WebServer(nextServerId));
    serversAdded++;

    cout << CYAN << "[Cycle " << clockCycle << "] +++ Added server "
         << nextServerId << " (total: " << servers.size() << ")" << RESET << endl;
    if (logFile.is_open()) {
        logFile << "[Cycle " << clockCycle << "] +++ Added server "
                << nextServerId << " (total: " << servers.size() << ")" << endl;
    }
    nextServerId++;
}

void LoadBalancer::removeServer() {
    if (servers.size() <= 1) return;

    // look for an idle server to remove, starting from the back
    for (int i = (int)servers.size() - 1; i >= 0; i--) {
        if (!servers[i]->isBusy()) {
            int rid = servers[i]->getId();
            delete servers[i];
            servers.erase(servers.begin() + i);
            serversRemoved++;

            cout << MAGENTA << "[Cycle " << clockCycle << "] --- Removed server "
                 << rid << " (total: " << servers.size() << ")" << RESET << endl;
            if (logFile.is_open()) {
                logFile << "[Cycle " << clockCycle << "] --- Removed server "
                        << rid << " (total: " << servers.size() << ")" << endl;
            }
            return;
        }
    }
}

void LoadBalancer::balanceServers() {
    if (balanceWaitTimer > 0) {
        balanceWaitTimer--;
        return;
    }

    int qSize = queue.getSize();
    int nServers = (int)servers.size();

    if (qSize > 80 * nServers) {
        addServer();
        balanceWaitTimer = balanceCooldown;
    }
    else if (qSize < 50 * nServers && nServers > 1) {
        removeServer();
        balanceWaitTimer = balanceCooldown;
    }
}

void LoadBalancer::distributeRequests() {
    for (int i = 0; i < (int)servers.size(); i++) {
        if (!servers[i]->isBusy() && !queue.isEmpty()) {
            Request r = queue.dequeue();
            servers[i]->assignRequest(r);
        }
    }
}

void LoadBalancer::run(int totalCycles) {
    log("========================================", BOLD + WHITE);
    log("  Load Balancer Simulation Starting", BOLD + WHITE);
    log("========================================", BOLD + WHITE);

    ostringstream startMsg;
    startMsg << "Starting queue size: " << startingQueueSize
             << " | Servers: " << servers.size()
             << " | Task time range: " << minTaskTime << "-" << maxTaskTime;
    log(startMsg.str(), BOLD + WHITE);
    log("", RESET);

    for (clockCycle = 1; clockCycle <= totalCycles; clockCycle++) {

        // randomly generate new requests each cycle
        int roll = (rand() % 100) + 1;
        if (roll <= newRequestChance) {
            int batch = (rand() % newRequestBatch) + 1;
            for (int j = 0; j < batch; j++) {
                Request r = Request::generateRandom(minTaskTime, maxTaskTime);
                if (isBlocked(r.ipIn)) {
                    totalRejected++;
                    cout << RED << "[Cycle " << clockCycle
                         << "] BLOCKED request from " << r.ipIn << RESET << endl;
                    if (logFile.is_open()) {
                        logFile << "[Cycle " << clockCycle
                                << "] BLOCKED request from " << r.ipIn << endl;
                    }
                } else {
                    queue.enqueue(r);
                }
            }
        }

        // hand out requests to idle servers
        distributeRequests();

        // tick all the servers forward one cycle
        for (int i = 0; i < (int)servers.size(); i++) {
            if (servers[i]->tick()) {
                totalProcessed++;
            }
        }

        // check if we need to add or remove servers
        balanceServers();

        // keep running total for average queue size
        cumulativeQueueSize += queue.getSize();

        // print status every logInterval cycles
        if (clockCycle % logInterval == 0) {
            logStatus();
        }
    }

    log("", RESET);
    log("========================================", BOLD + WHITE);
    log("  Simulation Complete", BOLD + WHITE);
    log("========================================", BOLD + WHITE);
}

void LoadBalancer::printSummary(int totalCycles) {
    int busyCount = 0;
    for (int i = 0; i < (int)servers.size(); i++) {
        if (servers[i]->isBusy()) busyCount++;
    }
    int idleCount = (int)servers.size() - busyCount;

    double avgQueue = 0.0;
    if (totalCycles > 0) {
        avgQueue = (double)cumulativeQueueSize / totalCycles;
    }

    ostringstream oss;
    oss << "\n===== SIMULATION SUMMARY =====\n"
        << "Total clock cycles run     : " << totalCycles << "\n"
        << "Task time range            : " << minTaskTime << " - " << maxTaskTime << "\n"
        << "Starting queue size        : " << startingQueueSize << "\n"
        << "Ending queue size          : " << queue.getSize() << "\n"
        << "Total requests processed   : " << totalProcessed << "\n"
        << "Total requests rejected    : " << totalRejected << "\n"
        << "Servers added during sim   : " << serversAdded << "\n"
        << "Servers removed during sim : " << serversRemoved << "\n"
        << "Final server count         : " << servers.size() << "\n"
        << "  Active (busy) servers    : " << busyCount << "\n"
        << "  Inactive (idle) servers  : " << idleCount << "\n"
        << "Average queue size         : " << fixed << setprecision(1) << avgQueue << "\n"
        << "==============================\n";

    log(oss.str(), BOLD + WHITE);
}