Config.cpp

Go to the documentation of this file.

 
#include "Config.h"
 
#include <istream>
#include <ostream>
#include <random>
#include <sstream>
#include <type_traits>
 
#include "Firewall.h"
 
namespace {

template <typename T>
bool parseNumber(const std::string& text, T& value) {
    if (text.empty() || (std::is_unsigned<T>::value && text[0] == '-')) {
        return false;
    }
    std::istringstream stream(text);
    T parsed{};
    stream >> parsed;
    if (!stream || !stream.eof()) {
        return false;
    }
    value = parsed;
    return true;
}

template <typename T>
void ask(std::istream& in, std::ostream& out, const std::string& question, T& value) {
    while (true) {
        out << question << " [" << value << "]: " << std::flush;
        std::string line;
        if (!std::getline(in, line) || line.empty()) {
            return;
        }
        if (parseNumber(line, value)) {
            return;
        }
        out << "  Please enter a number.\n";
    }
}
 
void askYesNo(std::istream& in, std::ostream& out, const std::string& question, bool& value) {
    out << question << " [" << (value ? "y" : "n") << "]: " << std::flush;
    std::string line;
    if (std::getline(in, line) && !line.empty()) {
        value = line[0] == 'y' || line[0] == 'Y';
    }
}
 
}  // namespace
 
void printUsage(std::ostream& out, const std::string& program) {
    out << "Usage: " << program << " [options]\n"
        << "Run with no options to be asked for the main settings.\n\n"
        << "Run settings\n"
        << "  --servers N          initial web servers (default 20)\n"
        << "  --cycles N           clock cycles to simulate (default 100000)\n"
        << "  --seed N|random      random seed (default 412)\n"
        << "  --verbose            print every event in color\n"
        << "  --quiet              print only status lines and the summary (default)\n"
        << "  --status-every N     cycles between status lines (default: cycles/20, 100 if verbose)\n"
        << "  --log FILE           write the summary (and events in verbose mode) to FILE\n"
        << "  --switch             bonus: route P and S jobs to two load balancers\n"
        << "  --interactive        ask for the main settings, then apply the options given\n"
        << "  --no-color           disable ANSI colors\n\n"
        << "Traffic\n"
        << "  --min-task N         shortest task time in cycles (default 10)\n"
        << "  --max-task N         longest task time in cycles (default 100)\n"
        << "  --arrival-rate X     average new requests per cycle (default 0.45)\n"
        << "  --wave-amplitude X   traffic wave size 0-1; rate swings by +/- X (default 0.6)\n"
        << "  --wave-period N      cycles per busy/quiet traffic wave, 0 = steady (default cycles/4)\n"
        << "  --streaming-share X  fraction of streaming jobs, 0-1 (default 0.35)\n"
        << "  --queue-per-server N initial queue = servers x N (default 100)\n\n"
        << "Scaling and protection\n"
        << "  --upper X            add a server when queue > X x servers (default 80)\n"
        << "  --lower X            remove a server when queue < X x servers (default 50)\n"
        << "  --cooldown N         cycles between scaling checks (default 10)\n"
        << "  --min-servers N      fewest active servers (default 1)\n"
        << "  --max-servers N      most live servers (default 100)\n"
        << "  --max-queue N        queue capacity, extra requests are discarded (default 0 = unlimited)\n"
        << "  --block CIDR         block a source range (repeatable), e.g. 203.0.113.0/24\n"
        << "  --no-default-blocks  clear the default blocked ranges 45.0.0.0/8 and 103.0.0.0/8\n"
        << "  --help               show this message\n";
}
 
bool parseArguments(int argc, char* argv[], Config& config, std::string& error) {
    bool keepDefaultBlocks = true;
    bool sawSetting = false;  // any option other than display flags such as --no-color
    std::vector<std::string> extraBlocks;
    for (int i = 1; i < argc; ++i) {
        const std::string option = argv[i];
        const auto needValue = [&](std::string& value) {
            if (i + 1 >= argc) {
                error = option + " needs a value";
                return false;
            }
            value = argv[++i];
            return true;
        };
        const auto number = [&](auto& target) {
            std::string value;
            if (!needValue(value)) {
                return false;
            }
            if (!parseNumber(value, target)) {
                error = "invalid value for " + option + ": " + value;
                return false;
            }
            return true;
        };
 
        if (option != "--no-color") {
            sawSetting = true;
        }
        if (option == "--help" || option == "-h") {
            config.showHelp = true;
        } else if (option == "--servers") {
            if (!number(config.servers)) return false;
        } else if (option == "--cycles") {
            if (!number(config.cycles)) return false;
        } else if (option == "--seed") {
            std::string value;
            if (!needValue(value)) return false;
            if (value == "random") {
                config.seed = std::random_device{}();
            } else if (!parseNumber(value, config.seed)) {
                error = "invalid value for --seed: " + value;
                return false;
            }
        } else if (option == "--verbose" || option == "-v") {
            config.verbose = true;
        } else if (option == "--quiet" || option == "-q") {
            config.verbose = false;
        } else if (option == "--status-every") {
            if (!number(config.statusEvery)) return false;
        } else if (option == "--log") {
            if (!needValue(config.logPath)) return false;
        } else if (option == "--switch") {
            config.useSwitch = true;
        } else if (option == "--interactive" || option == "-i") {
            config.interactive = true;
        } else if (option == "--no-color") {
            config.color = false;
        } else if (option == "--min-task") {
            if (!number(config.minTask)) return false;
        } else if (option == "--max-task") {
            if (!number(config.maxTask)) return false;
        } else if (option == "--arrival-rate") {
            if (!number(config.arrivalRate)) return false;
        } else if (option == "--wave-amplitude") {
            if (!number(config.waveAmplitude)) return false;
        } else if (option == "--wave-period") {
            if (!number(config.wavePeriod)) return false;
            config.autoWavePeriod = false;
        } else if (option == "--streaming-share") {
            if (!number(config.streamingShare)) return false;
        } else if (option == "--queue-per-server") {
            if (!number(config.queuePerServer)) return false;
        } else if (option == "--upper") {
            if (!number(config.upperFactor)) return false;
        } else if (option == "--lower") {
            if (!number(config.lowerFactor)) return false;
        } else if (option == "--cooldown") {
            if (!number(config.cooldown)) return false;
        } else if (option == "--min-servers") {
            if (!number(config.minServers)) return false;
        } else if (option == "--max-servers") {
            if (!number(config.maxServers)) return false;
        } else if (option == "--max-queue") {
            if (!number(config.maxQueue)) return false;
        } else if (option == "--block") {
            std::string range;
            if (!needValue(range)) return false;
            extraBlocks.push_back(range);
        } else if (option == "--no-default-blocks") {
            keepDefaultBlocks = false;
        } else {
            error = "unknown option: " + option + " (use --help)";
            return false;
        }
    }
    if (!sawSetting) {
        config.interactive = true;
    }
    if (!keepDefaultBlocks) {
        config.blockedRanges.clear();
    }
    config.blockedRanges.insert(config.blockedRanges.end(), extraBlocks.begin(), extraBlocks.end());
    return true;
}
 
void promptForSettings(Config& config, std::istream& in, std::ostream& out) {
    out << "Load balancer setup (press Enter to keep the value in brackets)\n";
    ask(in, out, "  Number of initial web servers", config.servers);
    ask(in, out, "  Clock cycles to run", config.cycles);
    ask(in, out, "  Shortest task time (cycles)", config.minTask);
    ask(in, out, "  Longest task time (cycles)", config.maxTask);
    ask(in, out, "  Average new requests per cycle", config.arrivalRate);
    ask(in, out, "  Random seed", config.seed);
    askYesNo(in, out, "  Verbose output (y/n)", config.verbose);
    askYesNo(in, out, "  Use the bonus switch for P/S jobs (y/n)", config.useSwitch);
    out << '\n';
}
 
bool validateConfig(const Config& config, std::string& error) {
    if (config.servers == 0) {
        error = "the number of servers must be at least 1";
    } else if (config.useSwitch && config.servers < 2) {
        error = "switch mode needs at least 2 servers (one per load balancer)";
    } else if (config.cycles == 0) {
        error = "the number of clock cycles must be at least 1";
    } else if (config.minTask == 0 || config.maxTask < config.minTask) {
        error = "task times need 1 <= min-task <= max-task";
    } else if (config.arrivalRate < 0.0 || config.arrivalRate > 1000.0) {
        error = "arrival rate must be between 0 and 1000 requests per cycle";
    } else if (config.waveAmplitude < 0.0 || config.waveAmplitude > 1.0) {
        error = "wave amplitude must be between 0 and 1";
    } else if (config.streamingShare < 0.0 || config.streamingShare > 1.0) {
        error = "streaming share must be between 0 and 1";
    } else if (config.lowerFactor < 0.0 || config.upperFactor <= config.lowerFactor) {
        error = "scaling thresholds need 0 <= lower < upper";
    } else if (config.cooldown == 0) {
        error = "cooldown must be at least 1 cycle";
    } else if (config.minServers == 0 || config.maxServers < config.minServers) {
        error = "server limits need 1 <= min-servers <= max-servers";
    } else if (config.servers > config.maxServers) {
        error = "initial servers cannot exceed max-servers";
    } else {
        Firewall firewall;
        for (const std::string& range : config.blockedRanges) {
            if (!firewall.addRange(range)) {
                error = "invalid blocked range: " + range;
                return false;
            }
        }
        return true;
    }
    return false;
}