Config.cpp

Go to the documentation of this file.

#include <boost/program_options.hpp>
 
#include "Config.hpp"
 
namespace ahri
{
struct ConfigPrivate
{
    ConfigPrivate(std::istream& config_stream)
    {
        read_config(config_stream);
        parse_config();
    }
 
    void read_config(std::istream& config_stream)
    {
        namespace bpo = boost::program_options;
        bpo::options_description config_options{"File"};
        // clang-format off
        config_options.add_options()
            ("admindb.user",
                bpo::value<std::string>()->default_value("dhcp"))
            ("admindb.password",
                bpo::value<std::string>())
            ("admindb.server",
                bpo::value<std::vector<std::string>>())
            ("admindb.database",
                bpo::value<std::string>()->default_value("admindb"))
            ("localdb.user",
                bpo::value<std::string>()->default_value("kea"))
            ("localdb.password",
                bpo::value<std::string>())
            ("localdb.server",
                bpo::value<std::string>())
            ("localdb.database",
                bpo::value<std::string>()->default_value("kea"))
            ("ahri.api-url",
                bpo::value<std::string>())
            ("ahri.kea-service",
                bpo::value<std::string>())
            ("ahri.icinga2-reporting-enabled",
                bpo::value<bool>())
            ("icinga2.api-url",
                bpo::value<std::string>())
            ("icinga2.api-user",
                bpo::value<std::string>())
            ("icinga2.api-password",
                bpo::value<std::string>())
            ("icinga2.host",
                bpo::value<std::string>())
            ("icinga2.service-full-sync",
                bpo::value<std::string>())
            ;
        // clang-format on
 
        bpo::store(bpo::parse_config_file(config_stream, config_options), vm);
        bpo::notify(vm);
    }
 
    void parse_config()
    {
        localdb.user = vm["localdb.user"].as<std::string>();
        if (vm.count("localdb.password"))
            localdb.password = vm["localdb.password"].as<std::string>();
        else
            throw Config::ParseError("Missing localdb.password");
        localdb.database = vm["localdb.database"].as<std::string>();
 
        if (vm.count("localdb.server")) {
            std::string localdb_server = vm["localdb.server"].as<std::string>();
            std::string_view localdb_server_view{localdb_server};
            auto colon_pos = localdb_server_view.find_first_of(':');
            localdb.server.host = localdb_server_view.substr(0, colon_pos);
            localdb.server.port = localdb_server_view.substr(colon_pos + 1);
        } else {
            throw Config::ParseError("Missing localdb.server");
        }
 
        admindb.user = vm["admindb.user"].as<std::string>();
        if (vm.count("admindb.password"))
            admindb.password = vm["admindb.password"].as<std::string>();
        else
            throw Config::ParseError("Missing admindb.password");
        admindb.database = vm["admindb.database"].as<std::string>();
 
        if (vm.count("admindb.server")) {
            for (const std::string& server : vm["admindb.server"].as<std::vector<std::string>>()) {
                std::string_view server_view{server};
                auto colon_pos = server_view.find_first_of(':');
                std::string_view host = server_view.substr(0, colon_pos);
                std::string_view port = server_view.substr(colon_pos + 1);
 
                Config::DBHost db_host = {.host = std::string{host}, .port = std::string{port}};
                admindb.servers.push_back(std::move(db_host));
            }
        }
        if (admindb.servers.empty())
            throw Config::ParseError("Missing admindb.server");
 
        if (vm.count("ahri.api-url"))
            ahri_node.api_url = vm["ahri.api-url"].as<std::string>();
        if (vm.count("ahri.kea-service"))
            ahri_node.kea_service = vm["ahri.kea-service"].as<std::string>();
        if (vm.count("ahri.icinga2-reporting-enabled"))
            ahri_node.icinga2_reporting_enabled = vm["ahri.icinga2-reporting-enabled"].as<bool>();
 
        if (vm.count("icinga2.api-url"))
            icinga2.api_url = vm["icinga2.api-url"].as<std::string>();
        if (vm.count("icinga2.api-user"))
            icinga2.api_user = vm["icinga2.api-user"].as<std::string>();
        if (vm.count("icinga2.api-password"))
            icinga2.api_password = vm["icinga2.api-password"].as<std::string>();
        if (vm.count("icinga2.host"))
            icinga2.host = vm["icinga2.host"].as<std::string>();
        if (vm.count("icinga2.service-full-sync"))
            icinga2.services.at("full-sync") = vm["icinga2.service-full-sync"].as<std::string>();
    }
 
    boost::program_options::variables_map vm;
 
    Config::AdminDB admindb;
    Config::LocalDB localdb;
    Config::AhriNode ahri_node;
    Config::Icinga2 icinga2;
};
 
Config::Config(std::istream& config_stream) : p_impl(new ConfigPrivate(config_stream))
{}
 
Config::~Config()
{
    if (p_impl)
        delete p_impl;
}
 
const Config::LocalDB& Config::localdb() const
{
    return p_impl->localdb;
}
 
const Config::AdminDB& Config::admindb() const
{
    return p_impl->admindb;
}
 
const Config::AhriNode& Config::ahri_node() const
{
    return p_impl->ahri_node;
}
 
const Config::Icinga2& Config::icinga2() const
{
    return p_impl->icinga2;
}
} // namespace ahri