control_host_enrollment.hpp

Go to the documentation of this file.

#pragma once
 
#include <pulp/inspect/control_peer.hpp>
#include <pulp/inspect/control_trusted_host_inventory.hpp>
 
#include <chrono>
#include <cstddef>
#include <cstdint>
#include <functional>
#include <memory>
#include <optional>
#include <string>
#include <string_view>
 
namespace pulp::inspect {
 
inline constexpr std::size_t kControlMaximumHostEnrollments = 1024;
inline constexpr auto kControlMaximumHostEnrollmentTtl = std::chrono::seconds(30);
 
enum class ControlHostEnrollmentStatus : std::uint8_t {
    Created,
    InvalidRequest,
    ResourceExhausted,
    EntropyUnavailable,
};
 
struct ControlHostEnrollmentTicket {
    std::string enrollment_id;
    std::chrono::steady_clock::time_point expires_at;
};
 
struct ControlHostEnrollmentResult {
    ControlHostEnrollmentStatus status = ControlHostEnrollmentStatus::InvalidRequest;
    std::optional<ControlHostEnrollmentTicket> ticket;
};

class ControlHostEnrollmentPlan {
  public:
    ControlHostEnrollmentPlan(ControlHostEnrollmentPlan&&) noexcept;
    ControlHostEnrollmentPlan& operator=(ControlHostEnrollmentPlan&&) noexcept;
    ~ControlHostEnrollmentPlan();
    ControlHostEnrollmentPlan(const ControlHostEnrollmentPlan&) = delete;
    ControlHostEnrollmentPlan& operator=(const ControlHostEnrollmentPlan&) = delete;
 
    std::int64_t expected_process_id() const;
    const ControlPeerExpectation& expected_peer() const;
    std::uint64_t broker_generation() const;
    std::chrono::steady_clock::time_point expires_at() const;
    const ControlTrustedHostSnapshot& snapshot() const;
 
  private:
    struct Impl;
    explicit ControlHostEnrollmentPlan(std::unique_ptr<Impl> impl);
    friend class ControlHostEnrollmentStore;
    std::unique_ptr<Impl> impl_;
};
 
struct ControlHostEnrollmentStoreConfig {
    std::size_t maximum_enrollments = 64;
};

class ControlHostEnrollmentStore {
  public:
    using Clock = std::function<std::chrono::steady_clock::time_point()>;
 
    explicit ControlHostEnrollmentStore(
        ControlHostEnrollmentStoreConfig config = {},
        Clock clock = [] { return std::chrono::steady_clock::now(); });
    ~ControlHostEnrollmentStore();
    ControlHostEnrollmentStore(const ControlHostEnrollmentStore&) = delete;
    ControlHostEnrollmentStore& operator=(const ControlHostEnrollmentStore&) = delete;

    ControlHostEnrollmentResult create(ControlTrustedHostSnapshot snapshot,
                                       const VerifiedControlPeerIdentity& preobserved_child,
                                       std::uint64_t current_broker_generation,
                                       std::chrono::steady_clock::time_point expires_at);
    std::optional<ControlHostEnrollmentPlan> consume(std::string_view enrollment_id);
    std::size_t sweep();
    std::size_t size() const;
 
  private:
    struct Impl;
    std::unique_ptr<Impl> impl_;
};
 
} // namespace pulp::inspect