distributed_tx.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_COORDINATOR_DISTRIBUTED_TX_H_
#define OPENCBDC_TX_SRC_COORDINATOR_DISTRIBUTED_TX_H_
 
#include "state_machine.hpp"
#include "uhs/transaction/transaction.hpp"
#include "uhs/twophase/locking_shard/locking_shard.hpp"
#include "util/common/random_source.hpp"
#include "util/raft/node.hpp"
 
#include <memory>
#include <vector>
 
namespace cbdc::coordinator {
    class distributed_tx {
      public:
        distributed_tx(
            const hash_t& dtx_id,
            std::vector<std::shared_ptr<locking_shard::interface>> shards,
            std::shared_ptr<logging::log> logger);
 
        [[nodiscard]] auto execute() -> std::optional<std::vector<bool>>;
 
        auto add_tx(const transaction::compact_tx& tx) -> size_t;
 
        [[nodiscard]] auto get_id() const -> hash_t;
 
        using discard_cb_t = std::function<bool(const hash_t&)>;
        using done_cb_t = std::function<bool(const hash_t&)>;
        using commit_cb_t
            = std::function<bool(const hash_t&,
                                 const std::vector<bool>&,
                                 const std::vector<std::vector<uint64_t>>&)>;
        using prepare_cb_t
            = std::function<bool(const hash_t&,
                                 const std::vector<transaction::compact_tx>&)>;
 
        void set_prepare_cb(const prepare_cb_t& cb);
 
        void set_commit_cb(const commit_cb_t& cb);
 
        void set_discard_cb(const discard_cb_t& cb);
 
        void set_done_cb(const done_cb_t& cb);
 
        void recover_prepare(const std::vector<transaction::compact_tx>& txs);
 
        void recover_commit(const std::vector<bool>& complete_txs,
                            const std::vector<std::vector<uint64_t>>& tx_idxs);
 
        void recover_discard();
 
        [[nodiscard]] auto size() const -> size_t;
 
        enum class dtx_state {
            start,
            prepare,
            commit,
            discard,
            done,
            failed
        };
 
        [[nodiscard]] auto get_state() const -> dtx_state;
 
      private:
        [[nodiscard]] auto prepare() -> std::optional<std::vector<bool>>;
 
        [[nodiscard]] auto commit(const std::vector<bool>& complete_txs)
            -> bool;
 
        auto discard() -> bool;
 
        hash_t m_dtx_id;
        std::vector<std::shared_ptr<locking_shard::interface>> m_shards;
        std::vector<std::vector<locking_shard::tx>> m_txs;
        std::vector<transaction::compact_tx> m_full_txs;
        std::vector<std::vector<uint64_t>> m_tx_idxs;
        prepare_cb_t m_prepare_cb;
        commit_cb_t m_commit_cb;
        discard_cb_t m_discard_cb;
        done_cb_t m_done_cb;
        dtx_state m_state{dtx_state::start};
        std::vector<bool> m_complete_txs;
        std::shared_ptr<logging::log> m_logger;
    };
}
 
#endif // OPENCBDC_TX_SRC_COORDINATOR_DISTRIBUTED_TX_H_