uhs/atomizer/atomizer/state_machine.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_ATOMIZER_STATE_MACHINE_H_
#define OPENCBDC_TX_SRC_ATOMIZER_STATE_MACHINE_H_
 
#include "atomizer.hpp"
#include "messages.hpp"
 
#include <libnuraft/nuraft.hxx>
#include <shared_mutex>
 
namespace cbdc::atomizer {
    class state_machine : public nuraft::state_machine {
      public:
        state_machine(size_t stxo_cache_depth, std::string snapshot_dir);
 
        using request = std::variant<aggregate_tx_notify_request,
                                     make_block_request,
                                     get_block_request,
                                     prune_request>;
 
        using response
            = std::variant<make_block_response, get_block_response, errors>;
 
        [[nodiscard]] auto commit(nuraft::ulong log_idx, nuraft::buffer& data)
            -> nuraft::ptr<nuraft::buffer> override;
 
        void commit_config(
            nuraft::ulong log_idx,
            nuraft::ptr<nuraft::cluster_config>& /*new_conf*/) override;
 
        [[nodiscard]] auto
        read_logical_snp_obj(nuraft::snapshot& s,
                             void*& user_snp_ctx,
                             nuraft::ulong obj_id,
                             nuraft::ptr<nuraft::buffer>& data_out,
                             bool& is_last_obj) -> int override;
 
        void save_logical_snp_obj(nuraft::snapshot& s,
                                  nuraft::ulong& obj_id,
                                  nuraft::buffer& data,
                                  bool is_first_obj,
                                  bool is_last_obj) override;
 
        [[nodiscard]] auto apply_snapshot(nuraft::snapshot& s)
            -> bool override;
 
        [[nodiscard]] auto last_snapshot()
            -> nuraft::ptr<nuraft::snapshot> override;
 
        [[nodiscard]] auto last_commit_index() -> nuraft::ulong override;
 
        void create_snapshot(
            nuraft::snapshot& s,
            nuraft::async_result<bool>::handler_type& when_done) override;
 
        [[nodiscard]] auto tx_notify_count() -> uint64_t;
 
        using blockstore_t
            = std::unordered_map<uint64_t, cbdc::atomizer::block>;
 
        struct snapshot {
            std::shared_ptr<cbdc::atomizer::atomizer> m_atomizer;
            nuraft::ptr<nuraft::snapshot> m_snp{};
            std::shared_ptr<blockstore_t> m_blocks{};
        };
 
      private:
        [[nodiscard]] auto get_snapshot_path(uint64_t idx) const
            -> std::string;
 
        [[nodiscard]] auto get_tmp_path() const -> std::string;
 
        [[nodiscard]] auto read_snapshot(uint64_t idx)
            -> std::optional<snapshot>;
 
        static constexpr auto m_tmp_file = "tmp";
 
        std::atomic<uint64_t> m_last_committed_idx{0};
 
        std::shared_ptr<cbdc::atomizer::atomizer> m_atomizer;
        std::shared_ptr<blockstore_t> m_blocks;
 
        std::atomic<uint64_t> m_tx_notify_count{0};
 
        std::string m_snapshot_dir;
 
        size_t m_stxo_cache_depth{};
 
        std::shared_mutex m_snp_mut;
    };
}
#endif // OPENCBDC_TX_SRC_ATOMIZER_STATE_MACHINE_H_