uhs/atomizer/archiver/controller.hpp

Go to the documentation of this file.

// Copyright (c) 2021 MIT Digital Currency Initiative,
//                    Federal Reserve Bank of Boston
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
#ifndef OPENCBDC_TX_SRC_ARCHIVER_CONTROLLER_H_
#define OPENCBDC_TX_SRC_ARCHIVER_CONTROLLER_H_
 
#include "client.hpp"
#include "uhs/atomizer/atomizer/block.hpp"
#include "util/common/config.hpp"
#include "util/network/connection_manager.hpp"
 
#include <leveldb/db.h>
 
namespace cbdc::archiver {
 
    struct leveldbWriteOptions : public leveldb::WriteOptions {
        explicit leveldbWriteOptions(bool do_sync);
    };
 
    class controller {
      public:
        controller() = delete;
        controller(const controller&) = delete;
        auto operator=(const controller&) -> controller& = delete;
        controller(controller&&) = delete;
        auto operator=(controller&&) -> controller& = delete;
 
        controller(uint32_t archiver_id,
                   config::options opts,
                   std::shared_ptr<logging::log> log,
                   size_t max_samples);
 
        ~controller();
 
        auto init() -> bool;
 
        auto init_leveldb() -> bool;
 
        auto init_best_block() -> bool;
 
        auto init_sample_collection() -> bool;
 
        auto init_atomizer_connection() -> bool;
 
        auto init_archiver_server() -> bool;
 
        [[nodiscard]] auto best_block_height() const -> uint64_t;
 
        auto server_handler(cbdc::network::message_t&& pkt)
            -> std::optional<cbdc::buffer>;
 
        auto atomizer_handler(cbdc::network::message_t&& pkt)
            -> std::optional<cbdc::buffer>;
 
        void digest_block(const cbdc::atomizer::block& blk);
 
        auto get_block(uint64_t height)
            -> std::optional<cbdc::atomizer::block>;
 
        [[nodiscard]] auto running() const -> bool;
 
      private:
        uint32_t m_archiver_id;
        cbdc::config::options m_opts;
        std::shared_ptr<logging::log> m_logger;
 
        std::unique_ptr<leveldb::DB> m_db;
        uint64_t m_best_height{0};
        std::map<uint64_t, cbdc::atomizer::block> m_deferred;
        std::ofstream m_tp_sample_file;
        std::chrono::high_resolution_clock::time_point m_last_block_time;
        size_t m_max_samples{};
        size_t m_samples{};
 
        cbdc::network::connection_manager m_atomizer_network;
        cbdc::network::connection_manager m_archiver_network;
 
        bool m_sample_collection_active{false};
 
        std::thread m_atomizer_handler_thread;
        std::thread m_archiver_server;
 
        std::atomic_bool m_running{true};
 
        const std::string m_bestblock_key = "bestblock";
        static constexpr const leveldb::ReadOptions m_read_options{};
        static const leveldbWriteOptions m_write_options;
 
        void request_block(uint64_t height);
        void request_prune(uint64_t height);
    };
}
 
#endif // OPENCBDC_TX_SRC_ARCHIVER_CONTROLLER_H_