Backend.hpp

#pragma once
 
#include "cluster/ClioNode.hpp"
#include "cluster/impl/RepeatedTask.hpp"
#include "data/BackendInterface.hpp"
#include "data/LedgerCacheLoadingState.hpp"
#include "etl/WriterState.hpp"
#include "util/log/Logger.hpp"
 
#include <boost/asio/any_io_executor.hpp>
#include <boost/asio/cancellation_signal.hpp>
#include <boost/asio/execution_context.hpp>
#include <boost/asio/executor.hpp>
#include <boost/asio/spawn.hpp>
#include <boost/asio/strand.hpp>
#include <boost/asio/thread_pool.hpp>
#include <boost/signals2/connection.hpp>
#include <boost/signals2/signal.hpp>
#include <boost/signals2/variadic_signal.hpp>
#include <boost/uuid/uuid.hpp>
 
#include <chrono>
#include <concepts>
#include <memory>
#include <string>
#include <vector>
 
namespace cluster {

class Backend {
public:
    using ClusterData = std::expected<std::vector<ClioNode>, std::string>;
 
private:
    util::Logger log_{"ClusterCommunication"};
 
    std::shared_ptr<data::BackendInterface> backend_;
    std::unique_ptr<etl::WriterStateInterface const> writerState_;
    std::unique_ptr<data::LedgerCacheLoadingStateInterface const> cacheLoadingState_;
 
    impl::RepeatedTask<boost::asio::thread_pool> readerTask_;
    impl::RepeatedTask<boost::asio::thread_pool> writerTask_;
 
    ClioNode::Uuid selfUuid_;
 
    boost::signals2::signal<void(ClioNode::CUuid, std::shared_ptr<ClusterData const>)> onNewState_;
 
public:
    Backend(
        boost::asio::thread_pool& ctx,
        std::shared_ptr<data::BackendInterface> backend,
        std::unique_ptr<etl::WriterStateInterface const> writerState,
        std::unique_ptr<data::LedgerCacheLoadingStateInterface const> cacheLoadingState,
        std::chrono::steady_clock::duration readInterval,
        std::chrono::steady_clock::duration writeInterval
    );
 
    ~Backend();
 
    Backend(Backend&&) = delete;
    Backend&
    operator=(Backend&&) = delete;
    Backend(Backend const&) = delete;
    Backend&
    operator=(Backend const&) = delete;

    void
    run();

    void
    stop();

    template <typename S>
        requires std::invocable<S, ClioNode::CUuid, std::shared_ptr<ClusterData const>>
    boost::signals2::connection
    subscribeToNewState(S&& s)
    {
        return onNewState_.connect(s);
    }

    ClioNode::CUuid
    selfId() const;
 
private:
    ClusterData
    doRead(boost::asio::yield_context yield);
 
    void
    doWrite();
};
 
}  // namespace cluster