main.cpp

Go to the documentation of this file.

#include <cassert>
#include <chrono>
#include <cstdlib>
#include <fstream>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <optional>
#include <sstream>
#include <string>
#include <string_view>
 
#include <pqxx/except>
 
#include <asiolink/io_address.h>
#include <dhcp/hwaddr.h>
 
#include <boost/program_options.hpp>
 
#include <nlohmann/json.hpp>
 
#include <curl/curl.h>
 
#include "admindb-host-reservation-importer/AdminDBClient.hpp"
#include "admindb-host-reservation-importer/Config.hpp"
#include "admindb-host-reservation-importer/LocalDBClient.hpp"
#include "kch_config.h"
 
namespace po = boost::program_options;
 
namespace
{
enum class Icinga2CheckResult : unsigned int
{
    OK = 0,
    WARNING = 1,
    CRITICAL = 2,
    UNKNOWN = 3
};
 
template <typename T = std::int64_t>
struct Icinga2PerfValue
{
    T value;
    std::optional<std::string> unit{};
    std::optional<T> min{};
    std::optional<T> max{};
    std::optional<T> warning_threshold{};
    std::optional<T> critical_threshold{};
};
 
template <typename T>
std::ostream& operator<<(std::ostream& os, const Icinga2PerfValue<T>& perf)
{
    os << perf.value;
    if (perf.unit) {
        os << *perf.unit;
    }
    os << (perf.min ? std::to_string(*perf.min) : "") << ";";
    os << (perf.max ? std::to_string(*perf.max) : "") << ";";
    os << (perf.warning_threshold ? std::to_string(*perf.warning_threshold) : "") << ";";
    os << (perf.critical_threshold ? std::to_string(*perf.critical_threshold) : "");
    return os;
}
 
using curl_ptr = std::unique_ptr<CURL, std::function<void(CURL*)>>;
using icinga2_perfdata = std::map<std::string, Icinga2PerfValue<>>;
 
std::ostream& vout();
po::variables_map parse_command_line(int argc, char** argv);
void print_usage(std::string_view argv0, const po::options_description& opt_desc);
int run_action(const po::variables_map& args, const ahri::Config& config);
int run_full_sync(const po::variables_map& args, const ahri::Config& config);
int run_prune(const po::variables_map& args, const ahri::Config& config);
int run_show_reservation(const po::variables_map& vm, const ahri::Config& config);
void submit_icinga2_check_result(const ahri::Config& config,
                                 std::string_view service,
                                 Icinga2CheckResult result,
                                 std::string_view message,
                                 curl_ptr curl,
                                 const icinga2_perfdata& perfdata = {});
nlohmann::json perfdata_to_json(const icinga2_perfdata& perfdata);
extern "C" std::size_t curl_buf_write(char* buffer, std::size_t size, std::size_t nmemb,
                                      void* userp);
 
bool verbose{false};
std::string config_file_path{"/etc/admindb-host-reservation-importer.conf"};
const std::map<
  std::string,
  std::pair<std::string, std::function<int(const po::variables_map&, const ahri::Config&)>>>
  ACTION_MAP{
    {"full-sync", {"Synchronize the local hosts database with the AdminDB", run_full_sync}},
    {"prune", {"Prune old host reservation updates in the AdminDB", run_prune}},
    {"show-reservation",
     {"Show host reservation for a given MAC or IP address", run_show_reservation}}};
 
class NullOstream : public std::ostream
{
public:
    template <typename... T>
    std::ostream& operator<<([[maybe_unused]] T... /* unused */)
    {
        return *this;
    }
};
NullOstream null_out;
} // namespace
 
int main(int argc, char** argv)
{
    po::variables_map vm;
    try {
        vm = parse_command_line(argc, argv);
    }
    catch (po::unknown_option&) {
        return 1;
    }
 
    std::ifstream config_file{config_file_path};
    if (!config_file.good()) {
        std::clog << "Failed to read configuration at " << config_file_path << '\n';
        return 1;
    }
 
    try {
        ahri::Config config{config_file};
 
        curl_global_init(CURL_GLOBAL_ALL);
        int res = run_action(vm, config);
        curl_global_cleanup();
        return res;
    }
    catch (ahri::Config::ParseError& e) {
        std::clog << "Problem in configuration file: " << e.what() << '\n';
    }
    catch (boost::program_options::invalid_config_file_syntax& e) {
        std::clog << "Problem in configuration file: " << e.what() << '\n';
    }
 
    return 1;
}
 
namespace
{
 
std::ostream& vout()
{
    if (verbose) {
        return std::clog;
    }
 
    return null_out;
}
 
po::variables_map parse_command_line(int argc, char** argv)
{
    po::options_description common_opts{"Common options"};
    po::options_description positional_opts{"Positional options"};
    // clang-format off
    common_opts.add_options()
        ("help,h", "show help and exit")
        ("config,c", po::value(&config_file_path), "configuration file")
        ("verbose,v", po::bool_switch(&verbose), "enable verbose output")
        ("ip", po::value<std::string>(), "IP Address")
        ("mac", po::value<std::string>(), "MAC address")
    ;
    positional_opts.add_options()
        ("action", po::value<std::string>(), "action to run")
    ;
    // clang-format on
    po::options_description all_opts;
    all_opts.add(common_opts).add(positional_opts);
 
    po::positional_options_description po_desc;
    po_desc.add("action", 1);
 
    po::variables_map vm;
    po::command_line_parser parser{argc, argv};
    parser.options(all_opts).positional(po_desc);
    po::options_description visible_opts;
    visible_opts.add(common_opts);
 
    try {
        po::store(parser.run(), vm);
        po::notify(vm);
    }
    catch (po::unknown_option& e) {
        std::clog << "Unknown option " << e.get_option_name() << "\n\n";
        print_usage(argv[0], visible_opts); // NOLINT(*-pointer-arithmetic)
        throw e;
    }
 
    bool show_usage = false;
 
    if (vm.count("help") > 0U) {
        show_usage = true;
    }
 
    if (vm.count("help") == 0U && vm.count("action") == 0U) {
        std::clog << "Unspecified action\n\n";
        show_usage = true;
    }
 
    if (vm.count("help") == 0U && vm.count("action") > 0U
        && ACTION_MAP.find(vm["action"].as<std::string>()) == ACTION_MAP.end()) {
        std::clog << "Invalid action " << vm["action"].as<std::string>() << "\n\n";
        show_usage = true;
    }
 
    if (show_usage) {
        print_usage(argv[0], visible_opts);
        std::exit(1);
    }
 
    return vm;
}
 
void print_usage(std::string_view argv0, const po::options_description& opt_desc)
{
    std::clog << "kea-custom-hooks by FeM e.V., Version " << KCH_VERSION << "\n\n"
              << "Usage: " << argv0 << " [options...] [action]\n\n"
              << "Available actions:\n\n";
    int max_name_len = std::numeric_limits<int>::min();
    for (const auto& [name, action] : ACTION_MAP) {
        max_name_len = std::max(static_cast<int>(name.length()), max_name_len);
    }
    const auto fmtflags = std::clog.flags();
    for (const auto& [name, action] : ACTION_MAP) {
        const auto& [desc, fun] = action;
        std::clog << std::setw(max_name_len) << std::left << name << "    " << desc << '\n';
    }
    std::clog << '\n' << opt_desc;
    std::clog.flags(fmtflags);
}
 
int run_action(const po::variables_map& args, const ahri::Config& config)
{
    for (const auto& [name, action] : ACTION_MAP) {
        const auto& [desc, fun] = action;
        if (name == args["action"].as<std::string>()) {
            return fun(args, config);
        }
    }
    // We should never get here in the first place
    throw std::logic_error{"Invalid action " + args["action"].as<std::string>()};
}
 
int run_full_sync([[maybe_unused]] const po::variables_map& /* unused */,
                  const ahri::Config& config)
{
    vout() << "Starting full sync for node " << config.ahri_node().api_url << '\n';
    std::unique_ptr<CURL, std::function<void(CURL*)>> hdl{curl_easy_init(), curl_easy_cleanup};
    // TODO handle a broken handle
    assert(hdl);
 
    nlohmann::json req{{"command", "ahri-full-sync"},
                       {"service", {config.ahri_node().kea_service}}};
    std::string post_data{req.dump()};
    std::ostringstream curl_write_buf;
 
    struct curl_slist* headers_ptr = nullptr;
    headers_ptr = curl_slist_append(headers_ptr, "Content-Type: application/json");
    std::unique_ptr<struct curl_slist, std::function<void(struct curl_slist*)>> headers{
      headers_ptr, curl_slist_free_all};
    headers_ptr = nullptr;
 
    curl_easy_setopt(hdl.get(), CURLOPT_URL, config.ahri_node().api_url.c_str());
    curl_easy_setopt(hdl.get(), CURLOPT_WRITEFUNCTION, curl_buf_write);
    curl_easy_setopt(hdl.get(), CURLOPT_WRITEDATA, &curl_write_buf);
    curl_easy_setopt(hdl.get(), CURLOPT_POSTFIELDS, post_data.c_str());
    curl_easy_setopt(hdl.get(), CURLOPT_POSTFIELDSIZE, post_data.size());
    curl_easy_setopt(hdl.get(), CURLOPT_HTTPHEADER, headers.get());
 
    const auto start_time = std::chrono::steady_clock::now();
    CURLcode res = curl_easy_perform(hdl.get());
    const auto end_time = std::chrono::steady_clock::now();
    const auto sync_duration = end_time - start_time;
    const auto sync_duration_ms =
      std::chrono::duration_cast<std::chrono::milliseconds>(sync_duration).count();
 
    if (res != CURLE_OK) {
        std::clog << "Error syncing local state with AdminDB: " << curl_easy_strerror(res) << '\n';
        if (config.ahri_node().icinga2_reporting_enabled) {
            submit_icinga2_check_result(
              config, "full-sync", Icinga2CheckResult::CRITICAL,
              "full-sync CRITICAL - Error syncing local state with AdminDB", std::move(hdl),
              {{"duration", Icinga2PerfValue<>{sync_duration_ms, "ms"}}});
        }
        return 1;
    }
 
    nlohmann::json response = nlohmann::json::parse(curl_write_buf.str());
    assert(response[0]["result"].is_number());
    const std::int64_t return_code = response[0]["result"];
 
    if (return_code == 0) {
        assert(response[0]["arguments"].is_number());
        const std::int64_t sync_diff = response[0]["arguments"];
        std::clog << "Full sync complete\n";
        std::cout << "Difference: " << sync_diff << '\n';
 
        if (config.ahri_node().icinga2_reporting_enabled) {
            submit_icinga2_check_result(
              config, "full-sync", Icinga2CheckResult::OK,
              "full-sync OK - " + std::to_string(sync_diff) + " differences", std::move(hdl),
              {{"differences", Icinga2PerfValue<>{sync_diff}},
               {"duration", Icinga2PerfValue<>{sync_duration_ms, "ms"}}});
        }
        return 0;
    }
 
    std::clog << "Error syncing local state with AdminDB. Control agent returned " << return_code
              << '\n';
    if (response.contains("text")) {
        std::clog << "The error message was: " << response["text"] << '\n';
    }
 
    if (config.ahri_node().icinga2_reporting_enabled) {
        submit_icinga2_check_result(config, "full-sync", Icinga2CheckResult::CRITICAL,
                                    "full-sync CRITICAL - Error syncing local state with AdminDB",
                                    std::move(hdl),
                                    {{"duration", Icinga2PerfValue<>{sync_duration_ms, "ms"}}});
    }
    return 1;
}
 
int run_prune([[maybe_unused]] const po::variables_map& /* unused */, const ahri::Config& config)
{
    vout() << "Connecting to AdminDB... ";
    ahri::AdminDBClient db{config.admindb().servers.at(0).host, config.admindb().servers.at(0).port,
                           config.admindb().user, config.admindb().password,
                           config.admindb().database};
    vout() << "done\n";
    try {
        std::cout << "Pruning old host updates... ";
        db.prune_old_host_updates();
        std::cout << "done\n";
        return 0;
    }
    catch (pqxx::failure& e) {
        std::cout << "failed\n";
        std::clog << "Error whilst pruning old host updates:\n" << e.what() << '\n';
    }
    return 1;
}
 
int run_show_reservation(const po::variables_map& vm, const ahri::Config& config)
{
    if (vm.count("ip") + vm.count("mac") != 1) {
        std::clog << "Error: must specify exactly one of --ip or --mac\n";
        return 1;
    }
 
    ahri::LocalDBClient db{config.localdb().server.host, config.localdb().server.port,
                           config.localdb().user, config.localdb().password,
                           config.localdb().database};
 
    std::vector<ahri::AdminDBClient::HostUpdate> hosts;
 
    if (vm.count("ip") > 0) {
        const isc::asiolink::IOAddress ip_addr{vm.at("ip").as<std::string>()};
        hosts = db.query_host_reservation(ip_addr);
    } else if (vm.count("mac") > 0) {
        const isc::dhcp::HWAddr mac_addr =
          isc::dhcp::HWAddr::fromText(vm.at("mac").as<std::string>());
        hosts = db.query_host_reservation(mac_addr);
    }
 
    for (auto& host : hosts) {
        std::cout << host.mac.toText(false) << "  ->  " << host.ipv4.toText() << " (subnet "
                  << host.subnet_id << ")\n";
    }
 
    return 0;
}
 
void submit_icinga2_check_result(const ahri::Config& config,
                                 std::string_view service,
                                 const Icinga2CheckResult result,
                                 std::string_view message,
                                 curl_ptr curl,
                                 const icinga2_perfdata& perfdata)
{
    assert(curl);
    std::clog << "Submitting check result to Icinga2\n";
    const std::string url = config.icinga2().api_url + "/v1/actions/process-check-result";
    const std::string userpwd = config.icinga2().api_user + ':' + config.icinga2().api_password;
    // clang-format off
    const nlohmann::json post_data{
        {"type", "Service"},
        {"filter",
            "host.name == \"" + config.icinga2().host
            + "\" && service.name == \"" + config.icinga2().services.at(std::string{service})
            + "\""
        },
        {"exit_status", static_cast<unsigned int>(result)},
        {"plugin_output", message},
        {"performance_data", perfdata_to_json(perfdata)}
    };
    // clang-format on
 
    const std::string post_data_str = post_data.dump();
    vout() << "URL: " << url << '\n' << "Request: " << post_data_str << '\n';
 
    struct curl_slist* headers_ptr = nullptr;
    headers_ptr = curl_slist_append(headers_ptr, "Content-Type: application/json");
    headers_ptr = curl_slist_append(headers_ptr, "Accept: application/json");
    std::unique_ptr<struct curl_slist, std::function<void(struct curl_slist*)>> headers{
      headers_ptr, curl_slist_free_all};
    headers_ptr = nullptr;
    std::ostringstream curl_write_buf;
 
    curl_easy_setopt(curl.get(), CURLOPT_URL, url.c_str());
    curl_easy_setopt(curl.get(), CURLOPT_WRITEFUNCTION, curl_buf_write);
    curl_easy_setopt(curl.get(), CURLOPT_WRITEDATA, &curl_write_buf);
    curl_easy_setopt(curl.get(), CURLOPT_POSTFIELDS, post_data_str.c_str());
    curl_easy_setopt(curl.get(), CURLOPT_POSTFIELDSIZE, post_data_str.size());
    curl_easy_setopt(curl.get(), CURLOPT_HTTPHEADER, headers.get());
    curl_easy_setopt(curl.get(), CURLOPT_USERPWD, userpwd.c_str());
 
    vout() << "Performing request ...";
    const CURLcode res = curl_easy_perform(curl.get());
    vout() << "done\n";
 
    if (res == CURLE_OK) {
        std::clog << "Submitting check results to Icinga2 done\n";
        vout() << "Response:\n" << nlohmann::json::parse(curl_write_buf.str()).dump(2) << '\n';
    } else {
        std::clog << "Failed to perform request: " << curl_easy_strerror(res) << '\n';
    }
}
 
nlohmann::json perfdata_to_json(const icinga2_perfdata& perfdata)
{
    nlohmann::json j = "[]"_json;
    for (const auto& [name, val] : perfdata) {
        std::ostringstream pd;
        pd << name << "=" << val << " ";
        j.push_back(pd.str());
    }
    return j;
}
 
extern "C" std::size_t curl_buf_write(char* buffer, [[maybe_unused]] std::size_t size,
                                      std::size_t nmemb, void* userp)
{
    assert(buffer);
    assert(userp);
    // size is constant according to CURLOPT_WRITEFUNCTION(3)
    assert(size == 1);
 
    // NOLINTNEXTLINE(*-reinterpret-cast)
    std::ostringstream& curl_write_buf = *reinterpret_cast<std::ostringstream*>(userp);
 
    vout() << "Received " << nmemb << " bytes of data\n";
    try {
        curl_write_buf.write(buffer, size * nmemb);
        return size * nmemb;
    }
    catch (std::ios_base::failure& e) {
        std::clog << "Failure storing received data: " << e.what() << '\n';
        return 0;
    }
}
} // namespace