WriterState.hpp

#pragma once
 
#include "data/LedgerCacheInterface.hpp"
#include "etl/SystemState.hpp"
#include "util/prometheus/Bool.hpp"
#include "util/prometheus/Label.hpp"
#include "util/prometheus/Prometheus.hpp"
 
#include <functional>
#include <memory>
 
namespace etl {

class WriterStateInterface {
public:
    virtual ~WriterStateInterface() = default;

    [[nodiscard]] virtual bool
    isReadOnly() const = 0;

    [[nodiscard]] virtual bool
    isWriting() const = 0;

    virtual void
    startWriting() = 0;

    virtual void
    giveUpWriting() = 0;

    [[nodiscard]] virtual bool
    isFallback() const = 0;

    [[nodiscard]] virtual bool
    isFallbackRecovery() const = 0;

    virtual void
    setFallbackRecovery(bool newValue) = 0;

    virtual void
    setWriterDecidingFallback() = 0;

    [[nodiscard]] virtual bool
    isEtlStarted() const = 0;

    [[nodiscard]] virtual bool
    isCacheFull() const = 0;

    [[nodiscard]] virtual std::unique_ptr<WriterStateInterface>
    clone() const = 0;
};

class WriterState : public WriterStateInterface {
private:
    std::shared_ptr<SystemState>
        systemState_; 
    std::reference_wrapper<data::LedgerCacheInterface const> cache_;

    util::prometheus::Bool isFallbackRecovery_ = PrometheusService::boolMetric(
        "etl_writing_deciding_fallback_recovery",
        util::prometheus::Labels{},
        "Whether clio is in recovery from the fallback writer decision mechanism"
    );
 
public:
    WriterState(std::shared_ptr<SystemState> state, data::LedgerCacheInterface const& cache);
 
    [[nodiscard]] bool
    isReadOnly() const override;

    [[nodiscard]] bool
    isWriting() const override;

    void
    startWriting() override;

    void
    giveUpWriting() override;

    void
    setWriterDecidingFallback() override;

    [[nodiscard]] bool
    isFallback() const override;

    [[nodiscard]] bool
    isFallbackRecovery() const override;

    void
    setFallbackRecovery(bool newValue) override;

    [[nodiscard]] bool
    isEtlStarted() const override;

    [[nodiscard]] bool
    isCacheFull() const override;

    [[nodiscard]] std::unique_ptr<WriterStateInterface>
    clone() const override;
};
 
}  // namespace etl