parsec/agent/runners/interface.hpp

Go to the documentation of this file.

// Copyright (c) 2022 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_RUNNERS_INTERFACE_H_
#define OPENCBDC_TX_SRC_PARSEC_AGENT_RUNNERS_INTERFACE_H_
 
#include "parsec/agent/interface.hpp"
#include "parsec/broker/interface.hpp"
#include "parsec/runtime_locking_shard/interface.hpp"
#include "parsec/util.hpp"
#include "util/common/logging.hpp"
#include "util/common/thread_pool.hpp"
 
#include <memory>
 
namespace cbdc::parsec::agent::runner {
    class interface {
      public:
        enum class error_code {
            result_value_type,
            result_key_type,
            result_type,
            result_count,
            exec_error,
            function_load,
            internal_error,
            yield_count,
            yield_type,
            lock_error,
            wounded
        };
 
        using ticket_number_type = parsec::ticket_machine::ticket_number_type;
 
        using run_return_type
            = std::variant<runtime_locking_shard::state_update_type,
                           error_code>;
        using run_callback_type = std::function<void(run_return_type)>;
 
        using try_lock_callback_type
            = std::function<bool(broker::key_type,
                                 broker::lock_type,
                                 broker::interface::try_lock_callback_type)>;
 
        using factory_type = std::function<std::unique_ptr<interface>(
            std::shared_ptr<logging::log> logger,
            const cbdc::parsec::config& cfg,
            runtime_locking_shard::value_type function,
            parameter_type param,
            bool is_readonly_run,
            runner::interface::run_callback_type result_callback,
            runner::interface::try_lock_callback_type try_lock_callback,
            std::shared_ptr<secp256k1_context>,
            std::shared_ptr<thread_pool> t_pool,
            ticket_number_type ticket_number)>;
 
        interface(std::shared_ptr<logging::log> logger,
                  const cbdc::parsec::config& cfg,
                  runtime_locking_shard::value_type function,
                  parameter_type param,
                  bool is_readonly_run,
                  run_callback_type result_callback,
                  try_lock_callback_type try_lock_callback,
                  std::shared_ptr<secp256k1_context> secp,
                  std::shared_ptr<thread_pool> t_pool,
                  ticket_number_type ticket_number);
 
        virtual ~interface() = default;
 
        interface(const interface&) = delete;
        auto operator=(const interface&) -> interface& = delete;
        interface(interface&&) = delete;
        auto operator=(interface&&) -> interface& = delete;
 
        [[nodiscard]] virtual auto run() -> bool = 0;
 
        friend class lua_runner;
        friend class evm_runner;
 
      private:
        std::shared_ptr<logging::log> m_log;
        const cbdc::parsec::config& m_cfg;
        runtime_locking_shard::value_type m_function;
        parameter_type m_param;
        bool m_is_readonly_run;
        run_callback_type m_result_callback;
        try_lock_callback_type m_try_lock_callback;
        std::shared_ptr<secp256k1_context> m_secp;
        std::shared_ptr<thread_pool> m_threads;
        ticket_number_type m_ticket_number;
    };
 
    template<class T>
    class factory {
      public:
        static auto
        create(std::shared_ptr<logging::log> logger,
               cbdc::parsec::config cfg,
               runtime_locking_shard::value_type function,
               parameter_type param,
               bool is_readonly_run,
               runner::interface::run_callback_type result_callback,
               runner::interface::try_lock_callback_type try_lock_callback,
               std::shared_ptr<secp256k1_context> secp,
               std::shared_ptr<thread_pool> t_pool,
               runner::interface::ticket_number_type ticket_number)
            -> std::unique_ptr<runner::interface> {
            return std::make_unique<T>(std::move(logger),
                                       std::move(cfg),
                                       std::move(function),
                                       std::move(param),
                                       is_readonly_run,
                                       std::move(result_callback),
                                       std::move(try_lock_callback),
                                       std::move(secp),
                                       std::move(t_pool),
                                       ticket_number);
        }
    };
}
 
#endif