parsec/runtime_locking_shard/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_RUNTIME_LOCKING_SHARD_INTERFACE_H_
#define OPENCBDC_TX_SRC_PARSEC_RUNTIME_LOCKING_SHARD_INTERFACE_H_
 
#include "parsec/ticket_machine/interface.hpp"
#include "util/common/buffer.hpp"
#include "util/common/hashmap.hpp"
 
#include <functional>
#include <unordered_map>
 
namespace cbdc::parsec::runtime_locking_shard {
    using ticket_number_type = parsec::ticket_machine::ticket_number_type;
    using key_type = buffer;
    using value_type = buffer;
    using broker_id_type = size_t;
 
    using state_update_type = std::
        unordered_map<key_type, value_type, hashing::const_sip_hash<key_type>>;
 
    enum class lock_type : uint8_t {
        read = 0,
        write = 1,
    };
 
    enum class error_code : uint8_t {
        prepared,
        wounded,
        lock_held,
        lock_queued,
        unknown_ticket,
        lock_not_held,
        state_update_with_read_lock,
        not_prepared,
        committed,
        not_committed,
        internal_error
    };
 
    struct wounded_details {
        ticket_number_type m_wounding_ticket{};
 
        key_type m_wounding_key;
    };
 
    // An error occurring
    struct shard_error {
        error_code m_error_code{};
 
        std::optional<wounded_details> m_wounded_details;
    };
 
    enum class ticket_state : uint8_t {
        begun,
        wounded,
        prepared,
        committed
    };
 
    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;
 
        using try_lock_return_type = std::variant<value_type, shard_error>;
        using try_lock_callback_type
            = std::function<void(try_lock_return_type)>;
 
        virtual auto try_lock(ticket_number_type ticket_number,
                              broker_id_type broker_id,
                              key_type key,
                              lock_type locktype,
                              bool first_lock,
                              try_lock_callback_type result_callback) -> bool
            = 0;
 
        using prepare_return_type = std::optional<shard_error>;
        using prepare_callback_type = std::function<void(prepare_return_type)>;
 
        virtual auto prepare(ticket_number_type ticket_number,
                             broker_id_type broker_id,
                             state_update_type state_update,
                             prepare_callback_type result_callback) -> bool
            = 0;
 
        using commit_return_type = std::optional<shard_error>;
        using commit_callback_type = std::function<void(commit_return_type)>;
 
        virtual auto commit(ticket_number_type ticket_number,
                            commit_callback_type result_callback) -> bool
            = 0;
 
        using rollback_return_type = std::optional<shard_error>;
        using rollback_callback_type
            = std::function<void(rollback_return_type)>;
 
        virtual auto rollback(ticket_number_type ticket_number,
                              rollback_callback_type result_callback) -> bool
            = 0;
 
        using finish_return_type = std::optional<shard_error>;
        using finish_callback_type = std::function<void(finish_return_type)>;
 
        virtual auto finish(ticket_number_type ticket_number,
                            finish_callback_type result_callback) -> bool
            = 0;
 
        using get_tickets_success_type
            = std::unordered_map<ticket_number_type, ticket_state>;
        using get_tickets_return_type
            = std::variant<get_tickets_success_type, error_code>;
        using get_tickets_callback_type
            = std::function<void(get_tickets_return_type)>;
 
        virtual auto get_tickets(broker_id_type broker_id,
                                 get_tickets_callback_type result_callback)
            -> bool
            = 0;
    };
}
 
#endif