init.cpp

Go to the documentation of this file.

 
#include <hooks/hooks.h>
#include <log/logger.h>
#include <log/macros.h>
 
#include "Exporter.hpp"
#include "common.hpp"
#include "exceptions.hpp"
#include "util/ArpwatchRPC.hpp"
#include "util/HiredisAdapter.hpp"
#include "util/HiredisMultiAdapter.hpp"
 
#include "log_admindb_arpwatch_exporter.h"
 
namespace arpwatch
{
// NOLINTBEGIN(*-non-const-global-variables)
std::unique_ptr<arpwatch::Exporter> exporter;
std::vector<HiredisAdapter> redis_adapters;
std::unique_ptr<HiredisMultiAdapter> redis_multi_adapter;
std::unique_ptr<ArpwatchRPC> arpwatch_rpc;
// NOLINTEND(*-non-const-global-variables)
} // namespace arpwatch
 
namespace
{
void create_redis_adapters_from_config(isc::hooks::LibraryHandle& handle);
void create_arpwatch_rpc_from_config(isc::hooks::LibraryHandle& handle);
void assert_config_exists(const isc::data::ConstElementPtr& config_element, const std::string& key);
template <typename T>
void try_add_server(T& raw_server);
void create_exporter();
} // namespace
 
extern "C" {
 
int load(isc::hooks::LibraryHandle& handle)
{
    isc::log::Logger logger("arpwatch-exporter");
    try {
        create_redis_adapters_from_config(handle);
        create_arpwatch_rpc_from_config(handle);
        create_exporter();
    }
    catch (InitFailure& f) {
        f.log(logger);
        return 1;
    }
 
    arpwatch::exporter->start_worker();
 
    return 0;
}
 
int unload()
{
    arpwatch::exporter->stop_worker();
 
    arpwatch::exporter.reset(nullptr);
    arpwatch::redis_multi_adapter.reset(nullptr);
    arpwatch::redis_adapters.clear();
    arpwatch::arpwatch_rpc.reset(nullptr);
    return 0;
}
}
 
namespace
{
void create_redis_adapters_from_config(isc::hooks::LibraryHandle& handle)
{
    isc::log::Logger logger("arpwatch-exporter");
    auto raw_server_list = handle.getParameter("servers");
 
    if (!raw_server_list) {
        LOG_WARN(logger, arpwatch::CONFIG_NO_REDIS_SERVERS);
        return;
    }
 
    auto server_list = [&raw_server_list]() {
        try {
            return raw_server_list->listValue();
        }
        catch (isc::data::TypeError& e) {
            throw InvalidConfig("servers", "List", raw_server_list->str());
        }
    }();
 
    for (auto& raw_server : server_list) {
        try_add_server(raw_server);
    }
 
    arpwatch::redis_adapters.shrink_to_fit();
 
    std::vector<HiredisMultiAdapter::adapter_refw_t> adapter_ref_list;
    adapter_ref_list.reserve(arpwatch::redis_adapters.size());
    for (auto& a : arpwatch::redis_adapters) {
        adapter_ref_list.emplace_back(a);
    }
 
    arpwatch::redis_multi_adapter = std::make_unique<HiredisMultiAdapter>(adapter_ref_list);
}
 
void create_arpwatch_rpc_from_config(isc::hooks::LibraryHandle& handle)
{
    const auto rpc_url_raw{handle.getParameter("arpwatch-rpc-url")};
    assert_config_exists(rpc_url_raw, "arpwatch-rpc-url");
    const auto rpc_url = [&rpc_url_raw]() {
        try {
            return rpc_url_raw->stringValue();
        }
        catch (isc::data::TypeError& e) {
            throw InvalidConfig("arpwatc-rpc-url", "String", rpc_url_raw->str());
        }
    }();
 
    arpwatch::arpwatch_rpc = std::make_unique<ArpwatchRPC>(rpc_url);
}
 
void assert_config_exists(const isc::data::ConstElementPtr& config_element, const std::string& key)
{
    if (!config_element) {
        throw InvalidConfigMissingElement(key);
    }
}
 
template <typename T>
void try_add_server(T& raw_server)
{
    assert_config_exists(raw_server, "servers.{}");
    auto server = [&raw_server]() {
        try {
            return raw_server->mapValue();
        }
        catch (isc::data::TypeError& e) {
            throw InvalidConfig("servers.{}", "Map", raw_server->str());
        }
    }();
 
    auto raw_server_ip = [&server]() {
        try {
            return server.at("ip");
        }
        catch (std::out_of_range&) {
            throw InvalidConfig("servers.{}.ip", "IP-Adress", "empty");
        }
    }();
    assert_config_exists(raw_server_ip, "servers.{}.ip");
    auto raw_server_port = [&server]() {
        try {
            return server.at("port");
        }
        catch (std::out_of_range&) {
            return isc::data::ConstElementPtr(
              new isc::data::IntElement(HiredisAdapter::REDIS_DEFAULT_PORT));
        }
    }();
    assert_config_exists(raw_server_port, "servers.{}.port");
 
    auto server_ip = [&raw_server_ip]() {
        try {
            return raw_server_ip->stringValue();
        }
        catch (isc::data::TypeError& e) {
            throw InvalidConfig("server.{}.ip", "IP-Adress", raw_server_ip->str());
        }
    }();
    auto server_port = [&raw_server_port]() {
        try {
            return raw_server_port->intValue();
        }
        catch (isc::data::TypeError& e) {
            throw InvalidConfig("server.{}.port", "Port number", raw_server_port->str());
        }
    }();
 
    isc::log::Logger logger("arpwatch-exporter");
    LOG_INFO(logger, arpwatch::CONFIG_REDIS_SERVER_ADD).arg(server_ip).arg(server_port);
    arpwatch::redis_adapters.emplace_back(server_ip, server_port);
}
 
void create_exporter()
{
    arpwatch::exporter =
      std::make_unique<arpwatch::Exporter>(*arpwatch::redis_multi_adapter, *arpwatch::arpwatch_rpc);
}
} // namespace