parsec/broker/interface.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_PARSEC_BROKER_INTERFACE_H_
#define OPENCBDC_TX_SRC_PARSEC_BROKER_INTERFACE_H_
 
#include "parsec/runtime_locking_shard/interface.hpp"
#include "parsec/ticket_machine/interface.hpp"
 
namespace cbdc::parsec::broker {
    using ticket_number_type = ticket_machine::ticket_number_type;
    using key_type = runtime_locking_shard::key_type;
    using value_type = runtime_locking_shard::value_type;
    using state_update_type = runtime_locking_shard::state_update_type;
    using lock_type = runtime_locking_shard::lock_type;
    using held_locks_set_type = std::
        unordered_map<key_type, lock_type, hashing::const_sip_hash<key_type>>;
 
    class interface {
      public:
        virtual ~interface() = default;
 
        interface() = default;
        interface(const interface&) = delete;
        auto operator=(const interface&) -> interface& = delete;
        interface(interface&&) = delete;
        auto operator=(interface&&) -> interface& = delete;
 
        enum class error_code : uint8_t {
            ticket_number_assignment,
            unknown_ticket,
            prepared,
            shard_unreachable,
            ticket_machine_unreachable,
            committed,
            not_prepared,
            begun,
            aborted,
            directory_unreachable,
            invalid_shard_state,
            waiting_for_locks,
            commit_error,
            rollback_error,
            prepare_error,
            finish_error,
            get_tickets_error,
            commit_hazard
        };
 
        using ticketnum_or_errcode_type
            = std::variant<ticket_number_type, error_code>;
        using begin_callback_type
            = std::function<void(ticketnum_or_errcode_type)>;
 
        [[nodiscard]] virtual auto begin(begin_callback_type result_callback)
            -> bool
            = 0;
 
        using try_lock_return_type
            = std::variant<value_type,
                           error_code,
                           runtime_locking_shard::shard_error>;
        using try_lock_callback_type
            = std::function<void(try_lock_return_type)>;
 
        [[nodiscard]] virtual auto
        try_lock(ticket_number_type ticket_number,
                 key_type key,
                 lock_type locktype,
                 try_lock_callback_type result_callback) -> bool
            = 0;
 
        using commit_return_type = std::optional<
            std::variant<error_code, runtime_locking_shard::shard_error>>;
        using commit_callback_type = std::function<void(commit_return_type)>;
 
        [[nodiscard]] virtual auto commit(ticket_number_type ticket_number,
                                          state_update_type state_updates,
                                          commit_callback_type result_callback)
            -> bool
            = 0;
 
        using finish_return_type = std::optional<error_code>;
        using finish_callback_type = std::function<void(finish_return_type)>;
 
        [[nodiscard]] virtual auto finish(ticket_number_type ticket_number,
                                          finish_callback_type result_callback)
            -> bool
            = 0;
 
        using rollback_return_type = std::optional<
            std::variant<error_code, runtime_locking_shard::error_code>>;
        using rollback_callback_type
            = std::function<void(rollback_return_type)>;
 
        [[nodiscard]] virtual auto
        rollback(ticket_number_type ticket_number,
                 rollback_callback_type result_callback) -> bool
            = 0;
 
        using recover_return_type = std::optional<error_code>;
        using recover_callback_type = std::function<void(recover_return_type)>;
 
        [[nodiscard]] virtual auto
        recover(recover_callback_type result_callback) -> bool
            = 0;
 
        virtual auto highest_ticket() -> ticket_number_type = 0;
    };
}
 
#endif