AdminDBClient.hpp

Go to the documentation of this file.

#pragma once
 
#include <functional>
#include <memory>
#include <shared_mutex>
#include <stdexcept>
#include <string_view>
#include <vector>
 
#include <asiolink/io_address.h>
#include <dhcp/hwaddr.h>
 
#include "kch_config.h"
 
namespace ahri
{
struct AdminDBClientPrivate;
 
class AdminDBClient
{
public:
    using dhcp_update_callback_t = std::function<void()>;
 
    struct HostUpdate
    {
        enum class Type : int
        {
            ADD,
            REMOVE
        };
 
        Type type{Type::ADD};
        isc::asiolink::IOAddress ipv4;
        isc::dhcp::HWAddr mac;
        size_t subnet_id{0};
        size_t incremental_update_id{0};
    };
 
    constexpr static const char* NOTIFICATION_CHANNEL_NAME{"dhcp"};
    constexpr static const size_t BELOW_LOWEST_INCREMENTAL_UPDATE_ID{0};
    constexpr static const size_t UNDEFINED_SUBNET_ID{0};
    constexpr static const std::chrono::days DEFAULT_PRUNE_BEFORE{7};
 
    constexpr static const std::chrono::seconds NOTIFICATION_RECEIVER_TIMEOUT{1};
    // We need some sleep to others trying to access pqxx don't starve
    constexpr static const std::chrono::milliseconds NOTIFICATION_RECEIVER_SLEEP{500};
 
    AdminDBClient(std::string_view host,
                  std::string_view port,
                  std::string_view user,
                  std::string_view password,
                  std::string_view database,
                  size_t last_processed_host_update_id = 0);
    AdminDBClient(const AdminDBClient&) = delete;
    AdminDBClient& operator=(const AdminDBClient&) = delete;
    AdminDBClient(AdminDBClient&&) = delete;
    AdminDBClient& operator=(AdminDBClient&&) = delete;
    TEST_VIRTUAL ~AdminDBClient();
 
    TEST_VIRTUAL void handle_notifications(const dhcp_update_callback_t& cb);
 
    TEST_VIRTUAL void prune_old_host_updates(std::chrono::days prune_before = DEFAULT_PRUNE_BEFORE);
    TEST_VIRTUAL std::vector<HostUpdate> fetch_all_host_reservations();
    TEST_VIRTUAL std::vector<HostUpdate> fetch_pending_host_updates();
    TEST_VIRTUAL size_t fetch_latest_available_update_id();
 
    static inline HostUpdate make_host_update(HostUpdate::Type type, const std::string& mac,
                                              const std::string& ipv4, size_t incremental_update_id,
                                              size_t subnet_id = 0)
    {
        return HostUpdate{.type = type,
                          .ipv4 = isc::asiolink::IOAddress(ipv4),
                          .mac = isc::dhcp::HWAddr::fromText(mac),
                          .subnet_id = subnet_id,
                          .incremental_update_id = incremental_update_id};
    }
 
    static inline HostUpdate::Type host_update_type_from_string(std::string_view type_str)
    {
        if (type_str == "assign") {
            return HostUpdate::Type::ADD;
        }
        if (type_str == "unassign") {
            return HostUpdate::Type::REMOVE;
        }
        throw std::invalid_argument(
          "ahri::AdminDBClient: Type string doesn't match any "
          "ahri::AdminDBClient::HostUpdate::Type");
    }
 
private:
    std::unique_ptr<AdminDBClientPrivate> p_impl;
};
} // namespace ahri