agent/impl.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_AGENT_IMPL_H_
#define OPENCBDC_TX_SRC_PARSEC_AGENT_IMPL_H_
 
#include "interface.hpp"
#include "parsec/agent/runners/interface.hpp"
#include "parsec/broker/interface.hpp"
#include "util/common/logging.hpp"
 
namespace cbdc::parsec::agent {
    class impl : public interface {
      public:
        enum class state {
            init,
            begin_sent,
            begin_failed,
            function_get_sent,
            function_get_failed,
            function_get_error,
            function_started,
            function_failed,
            function_exception,
            commit_sent,
            commit_failed,
            commit_error,
            finish_sent,
            finish_failed,
            finish_complete,
            rollback_sent,
            rollback_failed,
            rollback_complete
        };
 
        impl(std::shared_ptr<logging::log> logger,
             cbdc::parsec::config cfg,
             runner::interface::factory_type runner_factory,
             std::shared_ptr<broker::interface> broker,
             runtime_locking_shard::key_type function,
             parameter_type param,
             exec_callback_type result_callback,
             broker::lock_type initial_lock_type,
             bool is_readonly_run,
             std::shared_ptr<secp256k1_context> secp,
             std::shared_ptr<thread_pool> t_pool);
 
        ~impl() override;
 
        impl(const impl&) = delete;
        auto operator=(const impl&) -> impl& = delete;
        impl(impl&&) = delete;
        auto operator=(impl&&) -> impl& = delete;
 
        auto exec() -> bool override;
 
        auto get_ticket_number() const
            -> std::optional<ticket_machine::ticket_number_type>;
 
        auto get_state() const -> state;
 
      private:
        std::shared_ptr<logging::log> m_log;
        const cbdc::parsec::config m_cfg;
        runner::interface::factory_type m_runner_factory;
        std::shared_ptr<broker::interface> m_broker;
        std::optional<ticket_machine::ticket_number_type> m_ticket_number;
        std::optional<exec_return_type> m_result;
        std::unique_ptr<runner::interface> m_runner;
        state m_state{state::init};
        bool m_permanent_error{false};
        mutable std::recursive_mutex m_mut;
        broker::lock_type m_initial_lock_type;
        bool m_is_readonly_run;
        std::shared_ptr<secp256k1_context> m_secp;
        std::shared_ptr<thread_pool> m_threads;
        std::optional<hash_t> m_tx_id;
        bool m_wounded{false};
        broker::held_locks_set_type m_requested_locks{};
        bool m_restarted{false};
 
        void handle_begin(broker::interface::ticketnum_or_errcode_type res);
 
        void
        handle_function(const broker::interface::try_lock_return_type& res);
 
        void handle_run(const runner::interface::run_return_type& res);
 
        void handle_commit(broker::interface::commit_return_type res);
 
        void do_start();
 
        void do_result();
 
        void do_finish();
 
        void do_runner(broker::value_type v);
 
        void do_rollback(bool finish);
 
        void do_commit();
 
        [[nodiscard]] auto
        do_try_lock_request(broker::key_type key,
                            broker::lock_type locktype,
                            broker::interface::try_lock_callback_type res_cb)
            -> bool;
 
        void
        handle_rollback(broker::interface::rollback_return_type rollback_res);
 
        void handle_finish(broker::interface::finish_return_type finish_res);
 
        void handle_try_lock_response(
            const broker::interface::try_lock_callback_type& res_cb,
            broker::interface::try_lock_return_type res);
    };
}
 
#endif