locking_shard.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_LOCKING_SHARD_LOCKING_SHARD_H_
#define OPENCBDC_TX_SRC_LOCKING_SHARD_LOCKING_SHARD_H_
 
#include "client.hpp"
#include "interface.hpp"
#include "status_interface.hpp"
#include "uhs/transaction/transaction.hpp"
#include "util/common/cache_set.hpp"
#include "util/common/hash.hpp"
#include "util/common/hashmap.hpp"
#include "util/common/logging.hpp"
 
#include <filesystem>
#include <future>
#include <leveldb/db.h>
#include <memory>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <variant>
#include <vector>
 
namespace cbdc::locking_shard {
    class locking_shard final : public interface, public status_interface {
      public:
        locking_shard(const std::pair<uint8_t, uint8_t>& output_range,
                      std::shared_ptr<logging::log> logger,
                      size_t completed_txs_cache_size,
                      const std::string& preseed_file,
                      config::options opts);
        locking_shard() = delete;
 
        auto lock_outputs(std::vector<tx>&& txs, const hash_t& dtx_id)
            -> std::optional<std::vector<bool>> final;
 
        auto apply_outputs(std::vector<bool>&& complete_txs,
                           const hash_t& dtx_id) -> bool final;
 
        auto discard_dtx(const hash_t& dtx_id) -> bool final;
 
        void stop() final;
 
        [[nodiscard]] auto check_unspent(const hash_t& uhs_id)
            -> std::optional<bool> final;
 
        [[nodiscard]] auto check_tx_id(const hash_t& tx_id)
            -> std::optional<bool> final;
 
      private:
        auto read_preseed_file(const std::string& preseed_file) -> bool;
        auto check_and_lock_tx(const tx& t) -> bool;
 
        struct prepared_dtx {
            std::vector<tx> m_txs;
            std::vector<bool> m_results;
        };
        std::atomic_bool m_running{true};
 
        std::shared_ptr<logging::log> m_logger;
        mutable std::shared_mutex m_mut;
        std::unordered_set<hash_t, hashing::null> m_uhs;
        std::unordered_set<hash_t, hashing::null> m_locked;
        std::unordered_map<hash_t, prepared_dtx, hashing::null>
            m_prepared_dtxs;
        std::unordered_set<hash_t, hashing::null> m_applied_dtxs;
        cbdc::cache_set<hash_t, hashing::null> m_completed_txs;
        config::options m_opts;
    };
}
 
#endif // OPENCBDC_TX_SRC_LOCKING_SHARD_LOCKING_SHARD_H_