Config.cpp

Go to the documentation of this file.

#include "bsc/config/Config.hpp"
#include <filesystem>
#include <fstream>
#include <iomanip>
#include <nlohmann/json.hpp>
#include <sstream>
#include <cstdlib>
#include <stdexcept>
 
namespace bsc::config {
using json = nlohmann::json;
 
namespace {
std::string expand_path(std::string path) {
    if (path.empty()) return path;
    if (path[0] == '~') {
        if (const char* home = std::getenv("HOME")) path.replace(0, 1, home);
    }
    return path;
}
 
nlohmann::json to_json(const Config& cfg) {
    return nlohmann::json{
        {"LogLevel", cfg.log_level},
        {"Firewall", cfg.firewall},
        {"DefaultAction", cfg.default_action},
        {"DefaultDuration", cfg.default_duration},
        {"ProcMonitorMethod", cfg.proc_monitor_method},
        {"EBPFObjPath",       cfg.ebpf_obj_path},
        {"InterceptUnknown", cfg.intercept_unknown},
        {"LogUTC", cfg.log_utc},
        {"LogMicro", cfg.log_micro},
        {"Server", {{"Address", cfg.server.address}, {"LogFile", cfg.server.log_file}, {"Authentication", {{"Type", cfg.server.authentication.type}}}}},
        {"Rules", {{"Path", cfg.rules.path}, {"EnableChecksums", cfg.rules.enable_checksums}}},
        {"FwOptions", {{"ConfigPath", cfg.fw_options.config_path}, {"MonitorInterval", cfg.fw_options.monitor_interval}, {"QueueNum", cfg.fw_options.queue_num}, {"QueueBypass", cfg.fw_options.queue_bypass}}},
        {"Stats", {{"MaxEvents", cfg.stats.max_events}, {"MaxStats", cfg.stats.max_stats}, {"Workers", cfg.stats.workers}}},
        {"Internal", {{"GCPercent", cfg.internal.gc_percent}, {"FlushConnsOnStart", cfg.internal.flush_conns_on_start}}},
        {"Tasks", {{"ConfigPath", cfg.tasks.config_path}}}
    };
}
}
 
std::string read_file(const std::string& path) {
    std::ifstream in(path);
    if (!in) throw std::runtime_error("cannot open config file: " + path);
    std::ostringstream ss;
    ss << in.rdbuf();
    return ss.str();
}
 
Config load_file(const std::string& path) {
    Config cfg;
    cfg.source_path = expand_path(path);
    auto raw = read_file(cfg.source_path);
    auto j = json::parse(raw);
    cfg.log_level = j.value("LogLevel", cfg.log_level);
    cfg.firewall = j.value("Firewall", cfg.firewall);
    cfg.default_action = j.value("DefaultAction", cfg.default_action);
    cfg.default_duration = j.value("DefaultDuration", cfg.default_duration);
    cfg.proc_monitor_method = j.value("ProcMonitorMethod", cfg.proc_monitor_method);
    cfg.ebpf_obj_path       = j.value("EBPFObjPath",       cfg.ebpf_obj_path);
    cfg.intercept_unknown = j.value("InterceptUnknown", cfg.intercept_unknown);
    cfg.log_utc = j.value("LogUTC", cfg.log_utc);
    cfg.log_micro = j.value("LogMicro", cfg.log_micro);
    if (j.contains("Server")) {
        const auto& s = j["Server"];
        cfg.server.address = expand_path(s.value("Address", cfg.server.address));
        cfg.server.log_file = expand_path(s.value("LogFile", cfg.server.log_file));
        if (s.contains("Authentication")) {
            const auto& a = s["Authentication"];
            cfg.server.authentication.type = a.value("Type", cfg.server.authentication.type);
        }
    }
    if (j.contains("Rules")) {
        const auto& r = j["Rules"];
        cfg.rules.path = expand_path(r.value("Path", cfg.rules.path));
        cfg.rules.enable_checksums = r.value("EnableChecksums", cfg.rules.enable_checksums);
    }
    if (j.contains("FwOptions")) {
        const auto& f = j["FwOptions"];
        cfg.fw_options.config_path = expand_path(f.value("ConfigPath", cfg.fw_options.config_path));
        cfg.fw_options.monitor_interval = f.value("MonitorInterval", cfg.fw_options.monitor_interval);
        cfg.fw_options.queue_num = f.value("QueueNum", cfg.fw_options.queue_num);
        cfg.fw_options.queue_bypass = f.value("QueueBypass", cfg.fw_options.queue_bypass);
    }
    if (j.contains("Stats")) {
        const auto& s = j["Stats"];
        cfg.stats.max_events = s.value("MaxEvents", cfg.stats.max_events);
        cfg.stats.max_stats = s.value("MaxStats", cfg.stats.max_stats);
        cfg.stats.workers = s.value("Workers", cfg.stats.workers);
    }
    if (j.contains("Internal")) {
        const auto& i = j["Internal"];
        cfg.internal.gc_percent = i.value("GCPercent", cfg.internal.gc_percent);
        cfg.internal.flush_conns_on_start = i.value("FlushConnsOnStart", cfg.internal.flush_conns_on_start);
    }
    if (j.contains("Tasks")) {
        const auto& t = j["Tasks"];
        cfg.tasks.config_path = expand_path(t.value("ConfigPath", cfg.tasks.config_path));
    }
    return cfg;
}
 
bool save_file(const Config& cfg, const std::string& path) {
    const auto out_path = expand_path(path);
    std::filesystem::create_directories(std::filesystem::path(out_path).parent_path());
    std::ofstream out(out_path);
    if (!out) return false;
    out << std::setw(2) << to_json(cfg) << "\n";
    return true;
}
 
} // namespace bsc::config