init.cpp

Go to the documentation of this file.

 
#include <fstream>
 
#include <pqxx/except>
 
#include <cc/command_interpreter.h>
#include <hooks/hooks.h>
#include <log/macros.h>
 
#include "AdminDBClient.hpp"
#include "Config.hpp"
#include "LocalDBClient.hpp"
#include "callout.hpp"
#include "common_vars.hpp"
#include "log_admindb_host_reservation_importer.h"
 
namespace ahri::globals
{
// NOLINTBEGIN(*-non-const-global-variables)
isc::asiolink::IOServicePtr io_context{nullptr};
std::unique_ptr<ahri::Config> config{nullptr};
isc::log::Logger logger{"ahri"};
// NOLINTEND(*-non-const-global-variables)
} // namespace ahri::globals
 
namespace
{
constexpr const char* DEFAULT_CONFIG_FILE_LOCATION{"/etc/admindb-host-reservation-importer.conf"};
 
// NOLINTBEGIN(*-non-const-global-variables)
std::unique_ptr<ahri::AdminDBClient> admindb{nullptr};
std::unique_ptr<ahri::LocalDBClient> localdb{nullptr};
// NOLINTEND(*-non-const-global-variables)
 
std::unique_ptr<ahri::LocalDBClient> init_localdb(ahri::Config& config);
std::unique_ptr<ahri::AdminDBClient> init_admindb(ahri::Config& config);
void update_dhcp_incrementally();
int full_sync_command_hdl(isc::hooks::CalloutHandle& hdl);
size_t full_sync();
} // namespace
 
extern "C" {
int unload();
 
int load(isc::hooks::LibraryHandle& hdl)
{
    std::string config_path = DEFAULT_CONFIG_FILE_LOCATION;
    try {
        auto raw_config_path = hdl.getParameter("config");
        // Only load the config if specified
        if (raw_config_path) {
            config_path = raw_config_path->stringValue();
        }
    }
    catch (isc::data::TypeError& e) {
        LOG_FATAL(ahri::globals::logger, ahri::AHRI_CONFIG_ERROR).arg("Invalid config file path");
    }
 
    LOG_INFO(ahri::globals::logger, ahri::AHRI_LOADING_CONFIG).arg(config_path);
    std::ifstream config_file{config_path};
    if (config_file.bad()) {
        LOG_FATAL(ahri::globals::logger, ahri::AHRI_CONFIG_ERROR)
          .arg("Failed to load configuration file ");
        return 1;
    }
 
    LOG_DEBUG(ahri::globals::logger, 50, ahri::AHRI_PARSING_CONFIG);
    try {
        ahri::globals::config = std::make_unique<ahri::Config>(config_file);
    }
    catch (ahri::Config::ParseError& e) {
        LOG_FATAL(ahri::globals::logger, ahri::AHRI_CONFIG_ERROR).arg(e.what());
        return 1;
    }
 
    // Example of how we might register the command callouts
    // hdl.registerCommandCallout("ahri-consistency-check", ahri::commands::consistency_check);
    // hdl.registerCommandCallout("ahri-get-last-consistency-check-result",
    // ahri::commands::get_last_consistency_check_result);
    hdl.registerCommandCallout("ahri-full-sync", full_sync_command_hdl);
 
    LOG_INFO(ahri::globals::logger, ahri::AHRI_INIT_LOCALDB);
    try {
        localdb = init_localdb(*ahri::globals::config);
    }
    catch (const std::exception& e) {
        LOG_ERROR(ahri::globals::logger, ahri::AHRI_INIT_LOCALDB_FAILED).arg(e.what());
        unload();
        return 1;
    }
 
    LOG_INFO(ahri::globals::logger, ahri::AHRI_INIT_ADMINDB);
    try {
        admindb = init_admindb(*ahri::globals::config);
    }
    catch (const std::exception& e) {
        LOG_ERROR(ahri::globals::logger, ahri::AHRI_INIT_ADMINDB_FAILED).arg(e.what());
        unload();
        return 1;
    }
 
    assert(localdb);
    assert(admindb);
 
    try {
        full_sync();
    }
    catch (const std::exception& e) {
        LOG_FATAL(ahri::globals::logger, ahri::AHRI_FULL_SYNC_FAILED).arg(e.what());
        unload();
        return 1;
    }
 
    try {
        LOG_INFO(ahri::globals::logger, ahri::AHRI_INIT_REGISTER_HANDLER);
        admindb->handle_notifications(update_dhcp_incrementally);
    }
    catch (const std::exception& e) {
        LOG_FATAL(ahri::globals::logger, ahri::AHRI_INIT_REGISTER_HANDLER_FAILED).arg(e.what());
        unload();
        return 1;
    }
 
    LOG_INFO(ahri::globals::logger, ahri::AHRI_INIT_OK);
    return 0;
}
 
int unload()
{
    if (ahri::globals::io_context) {
        ahri::globals::io_context = nullptr;
    }
    if (admindb) {
        admindb.reset(nullptr);
    }
    if (localdb) {
        localdb.reset(nullptr);
    }
    return 0;
}
}
 
namespace
{
std::unique_ptr<ahri::LocalDBClient> init_localdb(ahri::Config& config)
{
    return std::make_unique<ahri::LocalDBClient>(
      config.localdb().server.host, config.localdb().server.port, config.localdb().user,
      config.localdb().password, config.localdb().database);
}
 
std::unique_ptr<ahri::AdminDBClient> init_admindb(ahri::Config& config)
{
    assert(!config.admindb().servers.empty());
    return std::make_unique<ahri::AdminDBClient>(
      config.admindb().servers.at(0).host, config.admindb().servers.at(0).port,
      config.admindb().user, config.admindb().password, config.admindb().database);
}
 
void update_dhcp_incrementally()
{
    try {
        LOG_INFO(ahri::globals::logger, ahri::AHRI_RECEIVED_HOST_UPDATES);
        const std::vector<ahri::AdminDBClient::HostUpdate> updates =
          admindb->fetch_pending_host_updates();
        localdb->apply_host_updates(updates);
    }
    catch (pqxx::sql_error& e) {
        LOG_ERROR(ahri::globals::logger, ahri::AHRI_HOST_UPDATES_SQL_ERROR)
          .arg(e.what())
          .arg(e.query())
          .arg(e.sqlstate());
        full_sync();
    }
}
 
int full_sync_command_hdl(isc::hooks::CalloutHandle& hdl)
{
    isc::data::ConstElementPtr response;
    try {
        const size_t full_sync_diff = full_sync();
        response = isc::config::createAnswer(
          isc::config::CONTROL_RESULT_SUCCESS,
          isc::data::Element::create(static_cast<long long int>(full_sync_diff)));
    }
    catch (std::exception& e) {
        response = isc::config::createAnswer(isc::config::CONTROL_RESULT_ERROR,
                                             "Exception during command execution");
        LOG_WARN(ahri::globals::logger, ahri::AHRI_FULL_SYNC_FAILED).arg(e.what());
    }
    hdl.setArgument("response", response);
    return 0;
}
 
size_t full_sync()
{
    LOG_INFO(ahri::globals::logger, ahri::AHRI_FULL_SYNC_START);
    const std::vector<ahri::AdminDBClient::HostUpdate> full_sync =
      admindb->fetch_all_host_reservations();
    LOG_INFO(ahri::globals::logger, ahri::AHRI_FULL_SYNC_HOSTS_FETCHED);
    const std::vector<ahri::AdminDBClient::HostUpdate> table_diff =
      localdb->compare_full_sync(full_sync);
    LOG_INFO(ahri::globals::logger, ahri::AHRI_FULL_SYNC_DIFF).arg(table_diff.size());
    localdb->apply_host_updates(table_diff);
    LOG_INFO(ahri::globals::logger, ahri::AHRI_FULL_SYNC_COMPLETE);
    return table_diff.size();
}
} // namespace