sysio::chain_plugin Class Reference

#include <chain_plugin.hpp>

Inheritance diagram for sysio::chain_plugin:

Collaboration diagram for sysio::chain_plugin:

Public Member Functions
	chain_plugin ()
virtual	~chain_plugin ()
virtual void	set_program_options (options_description &cli, options_description &cfg) override
void	plugin_initialize (const variables_map &options)
void	plugin_startup ()
void	plugin_shutdown ()
void	handle_sighup () override
chain_apis::read_write	get_read_write_api ()
chain_apis::read_only	get_read_only_api () const
bool	accept_block (const chain::signed_block_ptr &block, const chain::block_id_type &id, const chain::block_state_ptr &bsp)
void	accept_transaction (const chain::packed_transaction_ptr &trx, chain::plugin_interface::next_function< chain::transaction_trace_ptr > next)
controller &	chain ()
const controller &	chain () const
chain::chain_id_type	get_chain_id () const
fc::microseconds	get_abi_serializer_max_time () const
bool	api_accept_transactions () const
bool	accept_transactions () const
void	enable_accept_transactions ()
void	do_hard_replay (const variables_map &options)
bool	account_queries_enabled () const
bool	transaction_finality_status_enabled () const
fc::variant	get_log_trx_trace (const chain::transaction_trace_ptr &trx_trace) const
fc::variant	get_log_trx (const transaction &trx) const
Public Member Functions inherited from appbase::plugin< chain_plugin >
	plugin ()
virtual	~plugin ()
virtual state	get_state () const override
virtual const std::string &	name () const override
virtual void	register_dependencies ()
virtual void	initialize (const variables_map &options) override
virtual void	startup () override
virtual void	shutdown () override
Public Member Functions inherited from appbase::abstract_plugin
virtual	~abstract_plugin ()

Static Public Member Functions
static void	handle_guard_exception (const chain::guard_exception &e)
static void	handle_db_exhaustion ()
static void	handle_bad_alloc ()

Additional Inherited Members
Public Types inherited from appbase::abstract_plugin
enum	state { registered , initialized , started , stopped }
Protected Member Functions inherited from appbase::plugin< chain_plugin >
	plugin (const string &name)

Detailed Description

Definition at line 763 of file chain_plugin.hpp.

Constructor & Destructor Documentation

chain_plugin()

chain_plugin::chain_plugin

(

)

Definition at line 199 of file chain_plugin.cpp.

:my(new chain_plugin_impl()) {
   app().register_config_type<sysio::chain::db_read_mode>();
   app().register_config_type<sysio::chain::validation_mode>();
   app().register_config_type<chainbase::pinnable_mapped_file::map_mode>();
   app().register_config_type<sysio::chain::wasm_interface::vm_type>();
}

Here is the call graph for this function:

~chain_plugin()

chain_plugin::~chain_plugin ( )

virtual

Definition at line 207 of file chain_plugin.cpp.

{}

Member Function Documentation

accept_block()

bool chain_plugin::accept_block	(	const chain::signed_block_ptr &	block,
		const chain::block_id_type &	id,
		const chain::block_state_ptr &	bsp )

Definition at line 1334 of file chain_plugin.cpp.

                                                                                                                   {
   return my->incoming_block_sync_method(block, id, bsp);
}

Here is the caller graph for this function:

accept_transaction()

void chain_plugin::accept_transaction	(	const chain::packed_transaction_ptr &	trx,
		chain::plugin_interface::next_function< chain::transaction_trace_ptr >	next )

Definition at line 1338 of file chain_plugin.cpp.

                                                                                                                            {
   my->incoming_transaction_async_method(trx, false, false, false, std::move(next));
}

Here is the caller graph for this function:

accept_transactions()

bool chain_plugin::accept_transactions

(

)

const

Definition at line 1357 of file chain_plugin.cpp.

                                             {
   return my->accept_transactions;
}

Here is the caller graph for this function:

account_queries_enabled()

bool chain_plugin::account_queries_enabled

(

)

const

Definition at line 1395 of file chain_plugin.cpp.

                                                 {
   return my->account_queries_enabled;
}

api_accept_transactions()

bool chain_plugin::api_accept_transactions

(

)

const

Definition at line 1353 of file chain_plugin.cpp.

                                                {
   return my->api_accept_transactions;
}

chain() [1/2]

controller & chain_plugin::chain

(

)

Definition at line 1342 of file chain_plugin.cpp.

{ return *my->chain; }

Here is the caller graph for this function:

chain() [2/2]

const controller & chain_plugin::chain

(

)

const

Definition at line 1343 of file chain_plugin.cpp.

{ return *my->chain; }

do_hard_replay()

void chain_plugin::do_hard_replay

(

const variables_map &

options

)

Definition at line 648 of file chain_plugin.cpp.

                                                         {
         ilog( "Hard replay requested: deleting state database" );
         clear_directory_contents( my->chain_config->state_dir );
         auto backup_dir = block_log::repair_log( my->blocks_dir, options.at( "truncate-at-block" ).as<uint32_t>(), config::reversible_blocks_dir_name);
}

Here is the call graph for this function:

Here is the caller graph for this function:

enable_accept_transactions()

void chain_plugin::enable_accept_transactions

(

)

Definition at line 1361 of file chain_plugin.cpp.

                                              {
   my->accept_transactions = true;
}

Here is the caller graph for this function:

get_abi_serializer_max_time()

fc::microseconds chain_plugin::get_abi_serializer_max_time

(

)

const

Definition at line 1349 of file chain_plugin.cpp.

                                                               {
   return my->abi_serializer_max_time_us;
}

Here is the caller graph for this function:

get_chain_id()

chain::chain_id_type chain_plugin::get_chain_id

(

)

const

Definition at line 1345 of file chain_plugin.cpp.

                                                   {
   return my->chain->get_chain_id();
}

get_log_trx()

fc::variant chain_plugin::get_log_trx

(

const transaction &

trx

)

const

Definition at line 2747 of file chain_plugin.cpp.

                                                                {
    fc::variant pretty_output;
    try {
        abi_serializer::to_log_variant(trx, pretty_output,
                                       chain_apis::make_resolver(chain(), abi_serializer::create_yield_function(get_abi_serializer_max_time())),
                                       abi_serializer::create_yield_function(get_abi_serializer_max_time()));
    } catch (...) {
        pretty_output = trx;
    }
    return pretty_output;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_log_trx_trace()

fc::variant chain_plugin::get_log_trx_trace

(

const chain::transaction_trace_ptr &

trx_trace

)

const

Definition at line 2735 of file chain_plugin.cpp.

                                                                                       {
    fc::variant pretty_output;
    try {
        abi_serializer::to_log_variant(trx_trace, pretty_output,
                                       chain_apis::make_resolver(chain(), abi_serializer::create_yield_function(get_abi_serializer_max_time())),
                                       abi_serializer::create_yield_function(get_abi_serializer_max_time()));
    } catch (...) {
        pretty_output = trx_trace;
    }
    return pretty_output;
}

Here is the call graph for this function:

get_read_only_api()

chain_apis::read_only chain_plugin::get_read_only_api

(

)

const

Definition at line 1329 of file chain_plugin.cpp.

                                                          {
   return chain_apis::read_only(chain(), my->_account_query_db, get_abi_serializer_max_time(), my->producer_plug, my->_trx_finality_status_processing.get());
}

Here is the caller graph for this function:

get_read_write_api()

chain_apis::read_write chain_plugin::get_read_write_api

(

)

Definition at line 1325 of file chain_plugin.cpp.

                                                      {
   return chain_apis::read_write(chain(), my->_trx_retry_db, get_abi_serializer_max_time(), api_accept_transactions());
}

handle_bad_alloc()

void chain_plugin::handle_bad_alloc ( )

static

Definition at line 1389 of file chain_plugin.cpp.

                                    {
   elog("std::bad_alloc - memory exhausted");
   //return -2 -- it's what programs/nodeop/main.cpp reports for std::exception
   std::_Exit(-2);
}

Here is the caller graph for this function:

handle_db_exhaustion()

void chain_plugin::handle_db_exhaustion ( )

static

Definition at line 1383 of file chain_plugin.cpp.

                                        {
   elog("database memory exhausted: increase chain-state-db-size-mb");
   //return 1 -- it's what programs/nodeop/main.cpp considers "BAD_ALLOC"
   std::_Exit(1);
}

Here is the caller graph for this function:

handle_guard_exception()

void chain_plugin::handle_guard_exception ( const chain::guard_exception & e )

static

Definition at line 1375 of file chain_plugin.cpp.

                                                                       {
   log_guard_exception(e);
 
   elog("database chain::guard_exception, quitting..."); // log string searched for in: tests/nodeop_under_min_avail_ram.py
   // quit the app
   app().quit();
}

Here is the call graph for this function:

Here is the caller graph for this function:

handle_sighup()

void chain_plugin::handle_sighup ( )

overridevirtual

Reimplemented from appbase::plugin< chain_plugin >.

Definition at line 1308 of file chain_plugin.cpp.

                                 {
   _deep_mind_log.update_logger( deep_mind_logger_name );
}

Here is the call graph for this function:

Here is the caller graph for this function:

plugin_initialize()

void chain_plugin::plugin_initialize

(

const variables_map &

options

)

Definition at line 654 of file chain_plugin.cpp.

                                                                 {
   ilog("initializing chain plugin");
 
   try {
      try {
         genesis_state gs; // Check if SYSIO_ROOT_KEY is bad
      } catch ( const std::exception& ) {
         elog( "SYSIO_ROOT_KEY ('${root_key}') is invalid. Recompile with a valid public key.",
               ("root_key", genesis_state::sysio_root_key));
         throw;
      }
 
      my->chain_config = controller::config();
 
      if( options.at( "print-build-info" ).as<bool>() || options.count( "extract-build-info") ) {
         if( options.at( "print-build-info" ).as<bool>() ) {
            ilog( "Build environment JSON:\n${e}", ("e", json::to_pretty_string( chainbase::environment() )) );
         }
         if( options.count( "extract-build-info") ) {
            auto p = options.at( "extract-build-info" ).as<bfs::path>();
 
            if( p.is_relative()) {
               p = bfs::current_path() / p;
            }
 
            SYS_ASSERT( fc::json::save_to_file( chainbase::environment(), p, true ), misc_exception,
                        "Error occurred while writing build info JSON to '${path}'",
                        ("path", p.generic_string())
            );
 
            ilog( "Saved build info JSON to '${path}'", ("path", p.generic_string()) );
         }
 
         SYS_THROW( node_management_success, "reported build environment information" );
      }
 
      LOAD_VALUE_SET( options, "sender-bypass-whiteblacklist", my->chain_config->sender_bypass_whiteblacklist );
      LOAD_VALUE_SET( options, "actor-whitelist", my->chain_config->actor_whitelist );
      LOAD_VALUE_SET( options, "actor-blacklist", my->chain_config->actor_blacklist );
      LOAD_VALUE_SET( options, "contract-whitelist", my->chain_config->contract_whitelist );
      LOAD_VALUE_SET( options, "contract-blacklist", my->chain_config->contract_blacklist );
 
      LOAD_VALUE_SET( options, "trusted-producer", my->chain_config->trusted_producers );
 
      if( options.count( "action-blacklist" )) {
         const std::vector<std::string>& acts = options["action-blacklist"].as<std::vector<std::string>>();
         auto& list = my->chain_config->action_blacklist;
         for( const auto& a : acts ) {
            auto pos = a.find( "::" );
            SYS_ASSERT( pos != std::string::npos, plugin_config_exception, "Invalid entry in action-blacklist: '${a}'", ("a", a));
            account_name code( a.substr( 0, pos ));
            action_name act( a.substr( pos + 2 ));
            list.emplace( code, act );
         }
      }
 
      if( options.count( "key-blacklist" )) {
         const std::vector<std::string>& keys = options["key-blacklist"].as<std::vector<std::string>>();
         auto& list = my->chain_config->key_blacklist;
         for( const auto& key_str : keys ) {
            list.emplace( key_str );
         }
      }
 
      if( options.count( "blocks-dir" )) {
         auto bld = options.at( "blocks-dir" ).as<bfs::path>();
         if( bld.is_relative())
            my->blocks_dir = app().data_dir() / bld;
         else
            my->blocks_dir = bld;
      }
 
      protocol_feature_set pfs;
      {
         fc::path protocol_features_dir;
         auto pfd = options.at( "protocol-features-dir" ).as<bfs::path>();
         if( pfd.is_relative())
            protocol_features_dir = app().config_dir() / pfd;
         else
            protocol_features_dir = pfd;
 
         pfs = initialize_protocol_features( protocol_features_dir );
      }
 
      if( options.count("checkpoint") ) {
         auto cps = options.at("checkpoint").as<vector<string>>();
         my->loaded_checkpoints.reserve(cps.size());
         for( const auto& cp : cps ) {
            auto item = fc::json::from_string(cp).as<std::pair<uint32_t,block_id_type>>();
            auto itr = my->loaded_checkpoints.find(item.first);
            if( itr != my->loaded_checkpoints.end() ) {
               SYS_ASSERT( itr->second == item.second,
                           plugin_config_exception,
                          "redefining existing checkpoint at block number ${num}: original: ${orig} new: ${new}",
                          ("num", item.first)("orig", itr->second)("new", item.second)
               );
            } else {
               my->loaded_checkpoints[item.first] = item.second;
            }
         }
      }
 
      if( options.count( "wasm-runtime" ))
         my->wasm_runtime = options.at( "wasm-runtime" ).as<vm_type>();
 
      LOAD_VALUE_SET( options, "profile-account", my->chain_config->profile_accounts );
 
      if(options.count("abi-serializer-max-time-ms"))
         my->abi_serializer_max_time_us = fc::microseconds(options.at("abi-serializer-max-time-ms").as<uint32_t>() * 1000);
 
      my->chain_config->blocks_dir = my->blocks_dir;
      my->chain_config->state_dir = app().data_dir() / config::default_state_dir_name;
      my->chain_config->read_only = my->readonly;
 
      if (auto resmon_plugin = app().find_plugin<resource_monitor_plugin>()) {
        resmon_plugin->monitor_directory(my->chain_config->blocks_dir);
        resmon_plugin->monitor_directory(my->chain_config->state_dir);
      }
 
      if( options.count( "chain-state-db-size-mb" ))
         my->chain_config->state_size = options.at( "chain-state-db-size-mb" ).as<uint64_t>() * 1024 * 1024;
 
      if( options.count( "chain-state-db-guard-size-mb" ))
         my->chain_config->state_guard_size = options.at( "chain-state-db-guard-size-mb" ).as<uint64_t>() * 1024 * 1024;
 
      if( options.count( "max-nonprivileged-inline-action-size" ))
         my->chain_config->max_nonprivileged_inline_action_size = options.at( "max-nonprivileged-inline-action-size" ).as<uint32_t>();
 
      if( options.count( "transaction-finality-status-max-storage-size-gb" )) {
         const uint64_t max_storage_size = options.at( "transaction-finality-status-max-storage-size-gb" ).as<uint64_t>() * 1024 * 1024 * 1024;
         if (max_storage_size > 0) {
            const fc::microseconds success_duration = fc::seconds(options.at( "transaction-finality-status-success-duration-sec" ).as<uint64_t>());
            const fc::microseconds failure_duration = fc::seconds(options.at( "transaction-finality-status-failure-duration-sec" ).as<uint64_t>());
            my->_trx_finality_status_processing.reset(
               new chain_apis::trx_finality_status_processing(max_storage_size, success_duration, failure_duration));
         }
      }
 
      if( options.count( "chain-threads" )) {
         my->chain_config->thread_pool_size = options.at( "chain-threads" ).as<uint16_t>();
         SYS_ASSERT( my->chain_config->thread_pool_size > 0, plugin_config_exception,
                     "chain-threads ${num} must be greater than 0", ("num", my->chain_config->thread_pool_size) );
      }
 
      my->chain_config->sig_cpu_bill_pct = options.at("signature-cpu-billable-pct").as<uint32_t>();
      SYS_ASSERT( my->chain_config->sig_cpu_bill_pct >= 0 && my->chain_config->sig_cpu_bill_pct <= 100, plugin_config_exception,
                  "signature-cpu-billable-pct must be 0 - 100, ${pct}", ("pct", my->chain_config->sig_cpu_bill_pct) );
      my->chain_config->sig_cpu_bill_pct *= config::percent_1;
 
      if( my->wasm_runtime )
         my->chain_config->wasm_runtime = *my->wasm_runtime;
 
      my->chain_config->force_all_checks = options.at( "force-all-checks" ).as<bool>();
      my->chain_config->disable_replay_opts = options.at( "disable-replay-opts" ).as<bool>();
      my->chain_config->contracts_console = options.at( "contracts-console" ).as<bool>();
      my->chain_config->allow_ram_billing_in_notify = options.at( "disable-ram-billing-notify-checks" ).as<bool>();
 
#ifdef SYSIO_DEVELOPER
      my->chain_config->disable_all_subjective_mitigations = options.at( "disable-all-subjective-mitigations" ).as<bool>();
#endif
 
      my->chain_config->maximum_variable_signature_length = options.at( "maximum-variable-signature-length" ).as<uint32_t>();
 
      if( options.count( "terminate-at-block" ))
         my->chain_config->terminate_at_block = options.at( "terminate-at-block" ).as<uint32_t>();
 
      if( options.count( "extract-genesis-json" ) || options.at( "print-genesis-json" ).as<bool>()) {
         std::optional<genesis_state> gs;
 
         if( fc::exists( my->blocks_dir / "blocks.log" )) {
            gs = block_log::extract_genesis_state( my->blocks_dir );
            SYS_ASSERT( gs,
                        plugin_config_exception,
                        "Block log at '${path}' does not contain a genesis state, it only has the chain-id.",
                        ("path", (my->blocks_dir / "blocks.log").generic_string())
            );
         } else {
            wlog( "No blocks.log found at '${p}'. Using default genesis state.",
                  ("p", (my->blocks_dir / "blocks.log").generic_string()));
            gs.emplace();
         }
 
         if( options.at( "print-genesis-json" ).as<bool>()) {
            ilog( "Genesis JSON:\n${genesis}", ("genesis", json::to_pretty_string( *gs )));
         }
 
         if( options.count( "extract-genesis-json" )) {
            auto p = options.at( "extract-genesis-json" ).as<bfs::path>();
 
            if( p.is_relative()) {
               p = bfs::current_path() / p;
            }
 
            SYS_ASSERT( fc::json::save_to_file( *gs, p, true ),
                        misc_exception,
                        "Error occurred while writing genesis JSON to '${path}'",
                        ("path", p.generic_string())
            );
 
            ilog( "Saved genesis JSON to '${path}'", ("path", p.generic_string()) );
         }
 
         SYS_THROW( extract_genesis_state_exception, "extracted genesis state from blocks.log" );
      }
 
      // move fork_db to new location
      upgrade_from_reversible_to_fork_db( my.get() );
 
      if(options.count( "block-log-retain-blocks" )) {
         my->chain_config->prune_config.emplace();
         my->chain_config->prune_config->prune_blocks = options.at( "block-log-retain-blocks" ).as<uint32_t>();
         SYS_ASSERT(my->chain_config->prune_config->prune_blocks, plugin_config_exception, "block-log-retain-blocks cannot be 0");
      }
 
      if( options.at( "delete-all-blocks" ).as<bool>()) {
         ilog( "Deleting state database and blocks" );
         if( options.at( "truncate-at-block" ).as<uint32_t>() > 0 )
            wlog( "The --truncate-at-block option does not make sense when deleting all blocks." );
         clear_directory_contents( my->chain_config->state_dir );
         clear_directory_contents( my->blocks_dir );
      } else if( options.at( "hard-replay-blockchain" ).as<bool>()) {
         do_hard_replay(options);
      } else if( options.at( "replay-blockchain" ).as<bool>()) {
         ilog( "Replay requested: deleting state database" );
         if( options.at( "truncate-at-block" ).as<uint32_t>() > 0 )
            wlog( "The --truncate-at-block option does not work for a regular replay of the blockchain." );
         clear_chainbase_files( my->chain_config->state_dir );
      } else if( options.at( "truncate-at-block" ).as<uint32_t>() > 0 ) {
         wlog( "The --truncate-at-block option can only be used with --hard-replay-blockchain." );
      }
 
      std::optional<chain_id_type> chain_id;
      if (options.count( "snapshot" )) {
         my->snapshot_path = options.at( "snapshot" ).as<bfs::path>();
         SYS_ASSERT( fc::exists(*my->snapshot_path), plugin_config_exception,
                     "Cannot load snapshot, ${name} does not exist", ("name", my->snapshot_path->generic_string()) );
 
         // recover genesis information from the snapshot
         // used for validation code below
         auto infile = std::ifstream(my->snapshot_path->generic_string(), (std::ios::in | std::ios::binary));
         istream_snapshot_reader reader(infile);
         reader.validate();
         chain_id = controller::extract_chain_id(reader);
         infile.close();
 
         SYS_ASSERT( options.count( "genesis-timestamp" ) == 0,
                 plugin_config_exception,
                 "--snapshot is incompatible with --genesis-timestamp as the snapshot contains genesis information");
         SYS_ASSERT( options.count( "genesis-json" ) == 0,
                     plugin_config_exception,
                     "--snapshot is incompatible with --genesis-json as the snapshot contains genesis information");
 
         auto shared_mem_path = my->chain_config->state_dir / "shared_memory.bin";
         SYS_ASSERT( !fc::is_regular_file(shared_mem_path),
                 plugin_config_exception,
                 "Snapshot can only be used to initialize an empty database." );
 
         if( fc::is_regular_file( my->blocks_dir / "blocks.log" )) {
            auto block_log_genesis = block_log::extract_genesis_state(my->blocks_dir);
            if( block_log_genesis ) {
               const auto& block_log_chain_id = block_log_genesis->compute_chain_id();
               SYS_ASSERT( *chain_id == block_log_chain_id,
                           plugin_config_exception,
                           "snapshot chain ID (${snapshot_chain_id}) does not match the chain ID from the genesis state in the block log (${block_log_chain_id})",
                           ("snapshot_chain_id",  *chain_id)
                           ("block_log_chain_id", block_log_chain_id)
               );
            } else {
               const auto& block_log_chain_id = block_log::extract_chain_id(my->blocks_dir);
               SYS_ASSERT( *chain_id == block_log_chain_id,
                           plugin_config_exception,
                           "snapshot chain ID (${snapshot_chain_id}) does not match the chain ID (${block_log_chain_id}) in the block log",
                           ("snapshot_chain_id",  *chain_id)
                           ("block_log_chain_id", block_log_chain_id)
               );
            }
         }
 
      } else {
 
         chain_id = controller::extract_chain_id_from_db( my->chain_config->state_dir );
 
         std::optional<genesis_state> block_log_genesis;
         std::optional<chain_id_type> block_log_chain_id;
 
         if( fc::is_regular_file( my->blocks_dir / "blocks.log" ) ) {
            block_log_genesis = block_log::extract_genesis_state( my->blocks_dir );
            if( block_log_genesis ) {
               block_log_chain_id = block_log_genesis->compute_chain_id();
            } else {
               block_log_chain_id = block_log::extract_chain_id( my->blocks_dir );
            }
 
            if( chain_id ) {
               SYS_ASSERT( *block_log_chain_id == *chain_id, block_log_exception,
                           "Chain ID in blocks.log (${block_log_chain_id}) does not match the existing "
                           " chain ID in state (${state_chain_id}).",
                           ("block_log_chain_id", *block_log_chain_id)
                           ("state_chain_id", *chain_id)
               );
            } else if( block_log_genesis ) {
               ilog( "Starting fresh blockchain state using genesis state extracted from blocks.log." );
               my->genesis = block_log_genesis;
               // Delay setting chain_id until later so that the code handling genesis-json below can know
               // that chain_id still only represents a chain ID extracted from the state (assuming it exists).
            }
         }
 
         if( options.count( "genesis-json" ) ) {
            bfs::path genesis_file = options.at( "genesis-json" ).as<bfs::path>();
            if( genesis_file.is_relative()) {
               genesis_file = bfs::current_path() / genesis_file;
            }
 
            SYS_ASSERT( fc::is_regular_file( genesis_file ),
                        plugin_config_exception,
                       "Specified genesis file '${genesis}' does not exist.",
                       ("genesis", genesis_file.generic_string()));
 
            genesis_state provided_genesis = fc::json::from_file( genesis_file ).as<genesis_state>();
 
            if( options.count( "genesis-timestamp" ) ) {
               provided_genesis.initial_timestamp = calculate_genesis_timestamp( options.at( "genesis-timestamp" ).as<string>() );
 
               ilog( "Using genesis state provided in '${genesis}' but with adjusted genesis timestamp",
                     ("genesis", genesis_file.generic_string()) );
            } else {
               ilog( "Using genesis state provided in '${genesis}'", ("genesis", genesis_file.generic_string()));
            }
 
            if( block_log_genesis ) {
               SYS_ASSERT( *block_log_genesis == provided_genesis, plugin_config_exception,
                           "Genesis state, provided via command line arguments, does not match the existing genesis state"
                           " in blocks.log. It is not necessary to provide genesis state arguments when a full blocks.log "
                           "file already exists."
               );
            } else {
               const auto& provided_genesis_chain_id = provided_genesis.compute_chain_id();
               if( chain_id ) {
                  SYS_ASSERT( provided_genesis_chain_id == *chain_id, plugin_config_exception,
                              "Genesis state, provided via command line arguments, has a chain ID (${provided_genesis_chain_id}) "
                              "that does not match the existing chain ID in the database state (${state_chain_id}). "
                              "It is not necessary to provide genesis state arguments when an initialized database state already exists.",
                              ("provided_genesis_chain_id", provided_genesis_chain_id)
                              ("state_chain_id", *chain_id)
                  );
               } else {
                  if( block_log_chain_id ) {
                     SYS_ASSERT( provided_genesis_chain_id == *block_log_chain_id, plugin_config_exception,
                                 "Genesis state, provided via command line arguments, has a chain ID (${provided_genesis_chain_id}) "
                                 "that does not match the existing chain ID in blocks.log (${block_log_chain_id}).",
                                 ("provided_genesis_chain_id", provided_genesis_chain_id)
                                 ("block_log_chain_id", *block_log_chain_id)
                     );
                  }
 
                  chain_id = provided_genesis_chain_id;
 
                  ilog( "Starting fresh blockchain state using provided genesis state." );
                  my->genesis = std::move(provided_genesis);
               }
            }
         } else {
            SYS_ASSERT( options.count( "genesis-timestamp" ) == 0,
                        plugin_config_exception,
                        "--genesis-timestamp is only valid if also passed in with --genesis-json");
         }
 
         if( !chain_id ) {
            if( my->genesis ) {
               // Uninitialized state database and genesis state extracted from block log
               chain_id = my->genesis->compute_chain_id();
            } else {
               // Uninitialized state database and no genesis state provided
 
               SYS_ASSERT( !block_log_chain_id, plugin_config_exception,
                           "Genesis state is necessary to initialize fresh blockchain state but genesis state could not be "
                           "found in the blocks log. Please either load from snapshot or find a blocks log that starts "
                           "from genesis."
               );
 
               ilog( "Starting fresh blockchain state using default genesis state." );
               my->genesis.emplace();
               chain_id = my->genesis->compute_chain_id();
            }
         }
      }
 
      if ( options.count("read-mode") ) {
         my->chain_config->read_mode = options.at("read-mode").as<db_read_mode>();
      }
      my->api_accept_transactions = options.at( "api-accept-transactions" ).as<bool>();
 
      if( my->chain_config->read_mode == db_read_mode::IRREVERSIBLE || my->chain_config->read_mode == db_read_mode::READ_ONLY ) {
         if( my->chain_config->read_mode == db_read_mode::READ_ONLY ) {
            wlog( "read-mode = read-only is deprecated use p2p-accept-transactions = false, api-accept-transactions = false instead." );
         }
         if( my->api_accept_transactions ) {
            my->api_accept_transactions = false;
            std::stringstream ss; ss << my->chain_config->read_mode;
            wlog( "api-accept-transactions set to false due to read-mode: ${m}", ("m", ss.str()) );
         }
      }
      if( my->api_accept_transactions ) {
         enable_accept_transactions();
      }
 
      if ( options.count("validation-mode") ) {
         my->chain_config->block_validation_mode = options.at("validation-mode").as<validation_mode>();
      }
 
      my->chain_config->db_map_mode = options.at("database-map-mode").as<pinnable_mapped_file::map_mode>();
 
#ifdef SYSIO_SYS_VM_OC_RUNTIME_ENABLED
      if( options.count("sys-vm-oc-cache-size-mb") )
         my->chain_config->eosvmoc_config.cache_size = options.at( "sys-vm-oc-cache-size-mb" ).as<uint64_t>() * 1024u * 1024u;
      if( options.count("sys-vm-oc-compile-threads") )
         my->chain_config->eosvmoc_config.threads = options.at("sys-vm-oc-compile-threads").as<uint64_t>();
      if( options["sys-vm-oc-enable"].as<bool>() )
         my->chain_config->eosvmoc_tierup = true;
#endif
 
      my->account_queries_enabled = options.at("enable-account-queries").as<bool>();
 
      my->chain.emplace( *my->chain_config, std::move(pfs), *chain_id );
 
      if( options.count( "transaction-retry-max-storage-size-gb" )) {
         SYS_ASSERT( !options.count( "producer-name"), plugin_config_exception,
                     "Transaction retry not allowed on producer nodes." );
         const uint64_t max_storage_size = options.at( "transaction-retry-max-storage-size-gb" ).as<uint64_t>() * 1024 * 1024 * 1024;
         if( max_storage_size > 0 ) {
            const uint32_t p2p_dedup_time_s = options.at( "p2p-dedup-cache-expire-time-sec" ).as<uint32_t>();
            const uint32_t trx_retry_interval = options.at( "transaction-retry-interval-sec" ).as<uint32_t>();
            const uint32_t trx_retry_max_expire = options.at( "transaction-retry-max-expiration-sec" ).as<uint32_t>();
            SYS_ASSERT( trx_retry_interval >= 2 * p2p_dedup_time_s, plugin_config_exception,
                        "transaction-retry-interval-sec ${ri} must be greater than 2 times p2p-dedup-cache-expire-time-sec ${dd}",
                        ("ri", trx_retry_interval)("dd", p2p_dedup_time_s) );
            SYS_ASSERT( trx_retry_max_expire > trx_retry_interval, plugin_config_exception,
                        "transaction-retry-max-expiration-sec ${m} should be configured larger than transaction-retry-interval-sec ${i}",
                        ("m", trx_retry_max_expire)("i", trx_retry_interval) );
            my->_trx_retry_db.emplace( *my->chain, max_storage_size,
                                       fc::seconds(trx_retry_interval), fc::seconds(trx_retry_max_expire),
                                       my->abi_serializer_max_time_us );
         }
      }
 
      // initialize deep mind logging
      if ( options.at( "deep-mind" ).as<bool>() ) {
         // The actual `fc::dmlog_appender` implementation that is currently used by deep mind
         // logger is using `stdout` to prints it's log line out. Deep mind logging outputs
         // massive amount of data out of the process, which can lead under pressure to some
         // of the system calls (i.e. `fwrite`) to fail abruptly without fully writing the
         // entire line.
         //
         // Recovering from errors on a buffered (line or full) and continuing retrying write
         // is merely impossible to do right, because the buffer is actually held by the
         // underlying `libc` implementation nor the operation system.
         //
         // To ensure good functionalities of deep mind tracer, the `stdout` is made unbuffered
         // and the actual `fc::dmlog_appender` deals with retry when facing error, enabling a much
         // more robust deep mind output.
         //
         // Changing the standard `stdout` behavior from buffered to unbuffered can is disruptive
         // and can lead to weird scenarios in the logging process if `stdout` is used there too.
         //
         // In a future version, the `fc::dmlog_appender` implementation will switch to a `FIFO` file
         // approach, which will remove the dependency on `stdout` and hence this call.
         //
         // For the time being, when `deep-mind = true` is activated, we set `stdout` here to
         // be an unbuffered I/O stream.
         setbuf(stdout, NULL);
         
         //verify configuration is correct
         SYS_ASSERT( options.at("api-accept-transactions").as<bool>() == false, plugin_config_exception,
            "api-accept-transactions must be set to false in order to enable deep-mind logging.");
 
         SYS_ASSERT( options.at("p2p-accept-transactions").as<bool>() == false, plugin_config_exception,
            "p2p-accept-transactions must be set to false in order to enable deep-mind logging.");
 
         my->chain->enable_deep_mind( &_deep_mind_log );
      }
 
      // set up method providers
      my->get_block_by_number_provider = app().get_method<methods::get_block_by_number>().register_provider(
            [this]( uint32_t block_num ) -> signed_block_ptr {
               return my->chain->fetch_block_by_number( block_num );
            } );
 
      my->get_block_by_id_provider = app().get_method<methods::get_block_by_id>().register_provider(
            [this]( block_id_type id ) -> signed_block_ptr {
               return my->chain->fetch_block_by_id( id );
            } );
 
      my->get_head_block_id_provider = app().get_method<methods::get_head_block_id>().register_provider( [this]() {
         return my->chain->head_block_id();
      } );
 
      my->get_last_irreversible_block_number_provider = app().get_method<methods::get_last_irreversible_block_number>().register_provider(
            [this]() {
               return my->chain->last_irreversible_block_num();
            } );
 
      // relay signals to channels
      my->pre_accepted_block_connection = my->chain->pre_accepted_block.connect([this](const signed_block_ptr& blk) {
         auto itr = my->loaded_checkpoints.find( blk->block_num() );
         if( itr != my->loaded_checkpoints.end() ) {
            auto id = blk->calculate_id();
            SYS_ASSERT( itr->second == id, checkpoint_exception,
                        "Checkpoint does not match for block number ${num}: expected: ${expected} actual: ${actual}",
                        ("num", blk->block_num())("expected", itr->second)("actual", id)
            );
         }
 
         my->pre_accepted_block_channel.publish(priority::medium, blk);
      });
 
      my->accepted_block_header_connection = my->chain->accepted_block_header.connect(
            [this]( const block_state_ptr& blk ) {
               my->accepted_block_header_channel.publish( priority::medium, blk );
            } );
 
      my->accepted_block_connection = my->chain->accepted_block.connect( [this]( const block_state_ptr& blk ) {
         if (my->_account_query_db) {
            my->_account_query_db->commit_block(blk);
         }
 
         if (my->_trx_retry_db) {
            my->_trx_retry_db->on_accepted_block(blk);
         }
 
         if (my->_trx_finality_status_processing) {
            my->_trx_finality_status_processing->signal_accepted_block(blk);
         }
 
         my->accepted_block_channel.publish( priority::high, blk );
      } );
 
      my->irreversible_block_connection = my->chain->irreversible_block.connect( [this]( const block_state_ptr& blk ) {
         if (my->_trx_retry_db) {
            my->_trx_retry_db->on_irreversible_block(blk);
         }
 
         if (my->_trx_finality_status_processing) {
            my->_trx_finality_status_processing->signal_irreversible_block(blk);
         }
 
         my->irreversible_block_channel.publish( priority::low, blk );
      } );
 
      my->accepted_transaction_connection = my->chain->accepted_transaction.connect(
            [this]( const transaction_metadata_ptr& meta ) {
               my->accepted_transaction_channel.publish( priority::low, meta );
            } );
 
      my->applied_transaction_connection = my->chain->applied_transaction.connect(
            [this]( std::tuple<const transaction_trace_ptr&, const packed_transaction_ptr&> t ) {
               if (my->_account_query_db) {
                  my->_account_query_db->cache_transaction_trace(std::get<0>(t));
               }
 
               if (my->_trx_retry_db) {
                  my->_trx_retry_db->on_applied_transaction(std::get<0>(t), std::get<1>(t));
               }
 
               if (my->_trx_finality_status_processing) {
                  my->_trx_finality_status_processing->signal_applied_transaction(std::get<0>(t), std::get<1>(t));
               }
 
               my->applied_transaction_channel.publish( priority::low, std::get<0>(t) );
            } );
 
      if (my->_trx_finality_status_processing || my->_trx_retry_db) {
         my->block_start_connection = my->chain->block_start.connect(
            [this]( uint32_t block_num ) {
               if (my->_trx_retry_db) {
                  my->_trx_retry_db->on_block_start(block_num);
               }
               if (my->_trx_finality_status_processing) {
                  my->_trx_finality_status_processing->signal_block_start( block_num );
               }
            } );
      }
      my->chain->add_indices();
   } FC_LOG_AND_RETHROW()
 
}

Here is the call graph for this function:

plugin_shutdown()

void chain_plugin::plugin_shutdown

(

)

Definition at line 1295 of file chain_plugin.cpp.

                                   {
   my->pre_accepted_block_connection.reset();
   my->accepted_block_header_connection.reset();
   my->accepted_block_connection.reset();
   my->irreversible_block_connection.reset();
   my->accepted_transaction_connection.reset();
   my->applied_transaction_connection.reset();
   my->block_start_connection.reset();
   if(app().is_quiting())
      my->chain->get_wasm_interface().indicate_shutting_down();
   my->chain.reset();
}

Here is the call graph for this function:

plugin_startup()

void chain_plugin::plugin_startup

(

)

Definition at line 1241 of file chain_plugin.cpp.

{ try {
   handle_sighup(); // Sets loggers
 
   SYS_ASSERT( my->chain_config->read_mode != db_read_mode::IRREVERSIBLE || !accept_transactions(), plugin_config_exception,
               "read-mode = irreversible. transactions should not be enabled by enable_accept_transactions" );
   try {
      my->producer_plug = app().find_plugin<producer_plugin>();
      SYS_ASSERT(my->producer_plug, plugin_exception, "Failed to find producer_plugin");
 
      auto shutdown = [](){ return app().quit(); };
      auto check_shutdown = [](){ return app().is_quiting(); };
      if (my->snapshot_path) {
         auto infile = std::ifstream(my->snapshot_path->generic_string(), (std::ios::in | std::ios::binary));
         auto reader = std::make_shared<istream_snapshot_reader>(infile);
         my->chain->startup(shutdown, check_shutdown, reader);
         infile.close();
      } else if( my->genesis ) {
         my->chain->startup(shutdown, check_shutdown, *my->genesis);
      } else {
         my->chain->startup(shutdown, check_shutdown);
      }
   } catch (const database_guard_exception& e) {
      log_guard_exception(e);
      // make sure to properly close the db
      my->chain.reset();
      throw;
   }
 
   if(!my->readonly) {
      ilog("starting chain in read/write mode");
   }
 
   if (my->genesis) {
      ilog("Blockchain started; head block is #${num}, genesis timestamp is ${ts}",
           ("num", my->chain->head_block_num())("ts", (std::string)my->genesis->initial_timestamp));
   }
   else {
      ilog("Blockchain started; head block is #${num}", ("num", my->chain->head_block_num()));
   }
 
   my->chain_config.reset();
 
   if (my->account_queries_enabled) {
      my->account_queries_enabled = false;
      try {
         my->_account_query_db.emplace(*my->chain);
         my->account_queries_enabled = true;
      } FC_LOG_AND_DROP(("Unable to enable account queries"));
   }
 
 
} FC_CAPTURE_AND_RETHROW() }

Here is the call graph for this function:

set_program_options()

void chain_plugin::set_program_options ( options_description & cli, options_description & cfg )

overridevirtual

Implements appbase::abstract_plugin.

Definition at line 209 of file chain_plugin.cpp.

{
   // build wasm_runtime help text
   std::string wasm_runtime_opt = "Override default WASM runtime (";
   std::string wasm_runtime_desc;
   std::string delim;
#ifdef SYSIO_SYS_VM_JIT_RUNTIME_ENABLED
   wasm_runtime_opt += " \"sys-vm-jit\"";
   wasm_runtime_desc += "\"sys-vm-jit\" : A WebAssembly runtime that compiles WebAssembly code to native x86 code prior to execution.\n";
   delim = ", ";
#endif
 
#ifdef SYSIO_SYS_VM_RUNTIME_ENABLED
   wasm_runtime_opt += delim + "\"sys-vm\"";
   wasm_runtime_desc += "\"sys-vm\" : A WebAssembly interpreter.\n";
   delim = ", ";
#endif
 
#ifdef SYSIO_SYS_VM_OC_DEVELOPER
   wasm_runtime_opt += delim + "\"sys-vm-oc\"";
   wasm_runtime_desc += "\"sys-vm-oc\" : Unsupported. Instead, use one of the other runtimes along with the option enable-sys-vm-oc.\n";
#endif
   wasm_runtime_opt += ")\n" + wasm_runtime_desc;
 
   std::string default_wasm_runtime_str= sysio::chain::wasm_interface::vm_type_string(sysio::chain::config::default_wasm_runtime);
 
   cfg.add_options()
         ("blocks-dir", bpo::value<bfs::path>()->default_value("blocks"),
          "the location of the blocks directory (absolute path or relative to application data dir)")
         ("protocol-features-dir", bpo::value<bfs::path>()->default_value("protocol_features"),
          "the location of the protocol_features directory (absolute path or relative to application config dir)")
         ("checkpoint", bpo::value<vector<string>>()->composing(), "Pairs of [BLOCK_NUM,BLOCK_ID] that should be enforced as checkpoints.")
         ("wasm-runtime", bpo::value<sysio::chain::wasm_interface::vm_type>()->value_name("runtime")->notifier([](const auto& vm){
#ifndef SYSIO_SYS_VM_OC_DEVELOPER
            //throwing an exception here (like SYS_ASSERT) is just gobbled up with a "Failed to initialize" error :(
            if(vm == wasm_interface::vm_type::eos_vm_oc) {
               elog("SYS VM OC is a tier-up compiler and works in conjunction with the configured base WASM runtime. Enable SYS VM OC via 'sys-vm-oc-enable' option");
               SYS_ASSERT(false, plugin_exception, "");
            }
#endif
         })->default_value(sysio::chain::config::default_wasm_runtime, default_wasm_runtime_str), wasm_runtime_opt.c_str()
         )
         ("profile-account", boost::program_options::value<vector<string>>()->composing(),
          "The name of an account whose code will be profiled")
         ("abi-serializer-max-time-ms", bpo::value<uint32_t>()->default_value(config::default_abi_serializer_max_time_us / 1000),
          "Override default maximum ABI serialization time allowed in ms")
         ("chain-state-db-size-mb", bpo::value<uint64_t>()->default_value(config::default_state_size / (1024  * 1024)), "Maximum size (in MiB) of the chain state database")
         ("chain-state-db-guard-size-mb", bpo::value<uint64_t>()->default_value(config::default_state_guard_size / (1024  * 1024)), "Safely shut down node when free space remaining in the chain state database drops below this size (in MiB).")
         ("signature-cpu-billable-pct", bpo::value<uint32_t>()->default_value(config::default_sig_cpu_bill_pct / config::percent_1),
          "Percentage of actual signature recovery cpu to bill. Whole number percentages, e.g. 50 for 50%")
         ("chain-threads", bpo::value<uint16_t>()->default_value(config::default_controller_thread_pool_size),
          "Number of worker threads in controller thread pool")
         ("contracts-console", bpo::bool_switch()->default_value(false),
          "print contract's output to console")
         ("deep-mind", bpo::bool_switch()->default_value(false),
          "print deeper information about chain operations")
         ("actor-whitelist", boost::program_options::value<vector<string>>()->composing()->multitoken(),
          "Account added to actor whitelist (may specify multiple times)")
         ("actor-blacklist", boost::program_options::value<vector<string>>()->composing()->multitoken(),
          "Account added to actor blacklist (may specify multiple times)")
         ("contract-whitelist", boost::program_options::value<vector<string>>()->composing()->multitoken(),
          "Contract account added to contract whitelist (may specify multiple times)")
         ("contract-blacklist", boost::program_options::value<vector<string>>()->composing()->multitoken(),
          "Contract account added to contract blacklist (may specify multiple times)")
         ("action-blacklist", boost::program_options::value<vector<string>>()->composing()->multitoken(),
          "Action (in the form code::action) added to action blacklist (may specify multiple times)")
         ("key-blacklist", boost::program_options::value<vector<string>>()->composing()->multitoken(),
          "Public key added to blacklist of keys that should not be included in authorities (may specify multiple times)")
         ("sender-bypass-whiteblacklist", boost::program_options::value<vector<string>>()->composing()->multitoken(),
          "Deferred transactions sent by accounts in this list do not have any of the subjective whitelist/blacklist checks applied to them (may specify multiple times)")
         ("read-mode", boost::program_options::value<sysio::chain::db_read_mode>()->default_value(sysio::chain::db_read_mode::SPECULATIVE),
          "Database read mode (\"speculative\", \"head\", \"read-only\", \"irreversible\").\n"
          "In \"speculative\" mode: database contains state changes by transactions in the blockchain up to the head block as well as some transactions not yet included in the blockchain.\n"
          "In \"head\" mode: database contains state changes by only transactions in the blockchain up to the head block; transactions received by the node are relayed if valid.\n"
          "In \"read-only\" mode: (DEPRECATED: see p2p-accept-transactions & api-accept-transactions) database contains state changes by only transactions in the blockchain up to the head block; transactions received via the P2P network are not relayed and transactions cannot be pushed via the chain API.\n"
          "In \"irreversible\" mode: database contains state changes by only transactions in the blockchain up to the last irreversible block; transactions received via the P2P network are not relayed and transactions cannot be pushed via the chain API.\n"
          )
         ( "api-accept-transactions", bpo::value<bool>()->default_value(true), "Allow API transactions to be evaluated and relayed if valid.")
         ("validation-mode", boost::program_options::value<sysio::chain::validation_mode>()->default_value(sysio::chain::validation_mode::FULL),
          "Chain validation mode (\"full\" or \"light\").\n"
          "In \"full\" mode all incoming blocks will be fully validated.\n"
          "In \"light\" mode all incoming blocks headers will be fully validated; transactions in those validated blocks will be trusted \n")
         ("disable-ram-billing-notify-checks", bpo::bool_switch()->default_value(false),
          "Disable the check which subjectively fails a transaction if a contract bills more RAM to another account within the context of a notification handler (i.e. when the receiver is not the code of the action).")
#ifdef SYSIO_DEVELOPER
         ("disable-all-subjective-mitigations", bpo::bool_switch()->default_value(false),
          "Disable all subjective mitigations checks in the entire codebase.")
#endif
         ("maximum-variable-signature-length", bpo::value<uint32_t>()->default_value(16384u),
          "Subjectively limit the maximum length of variable components in a variable legnth signature to this size in bytes")
         ("trusted-producer", bpo::value<vector<string>>()->composing(), "Indicate a producer whose blocks headers signed by it will be fully validated, but transactions in those validated blocks will be trusted.")
         ("database-map-mode", bpo::value<chainbase::pinnable_mapped_file::map_mode>()->default_value(chainbase::pinnable_mapped_file::map_mode::mapped),
          "Database map mode (\"mapped\", \"heap\", or \"locked\").\n"
          "In \"mapped\" mode database is memory mapped as a file.\n"
#ifndef _WIN32
          "In \"heap\" mode database is preloaded in to swappable memory and will use huge pages if available.\n"
          "In \"locked\" mode database is preloaded, locked in to memory, and will use huge pages if available.\n"
#endif
         )
 
#ifdef SYSIO_SYS_VM_OC_RUNTIME_ENABLED
         ("sys-vm-oc-cache-size-mb", bpo::value<uint64_t>()->default_value(eosvmoc::config().cache_size / (1024u*1024u)), "Maximum size (in MiB) of the SYS VM OC code cache")
         ("sys-vm-oc-compile-threads", bpo::value<uint64_t>()->default_value(1u)->notifier([](const auto t) {
               if(t == 0) {
                  elog("sys-vm-oc-compile-threads must be set to a non-zero value");
                  SYS_ASSERT(false, plugin_exception, "");
               }
         }), "Number of threads to use for SYS VM OC tier-up")
         ("sys-vm-oc-enable", bpo::bool_switch(), "Enable SYS VM OC tier-up runtime")
#endif
         ("enable-account-queries", bpo::value<bool>()->default_value(false), "enable queries to find accounts by various metadata.")
         ("max-nonprivileged-inline-action-size", bpo::value<uint32_t>()->default_value(config::default_max_nonprivileged_inline_action_size), "maximum allowed size (in bytes) of an inline action for a nonprivileged account")
         ("transaction-retry-max-storage-size-gb", bpo::value<uint64_t>(),
          "Maximum size (in GiB) allowed to be allocated for the Transaction Retry feature. Setting above 0 enables this feature.")
         ("transaction-retry-interval-sec", bpo::value<uint32_t>()->default_value(20),
          "How often, in seconds, to resend an incoming transaction to network if not seen in a block.")
         ("transaction-retry-max-expiration-sec", bpo::value<uint32_t>()->default_value(120),
          "Maximum allowed transaction expiration for retry transactions, will retry transactions up to this value.")
         ("transaction-finality-status-max-storage-size-gb", bpo::value<uint64_t>(),
          "Maximum size (in GiB) allowed to be allocated for the Transaction Finality Status feature. Setting above 0 enables this feature.")
         ("transaction-finality-status-success-duration-sec", bpo::value<uint64_t>()->default_value(config::default_max_transaction_finality_status_success_duration_sec),
          "Duration (in seconds) a successful transaction's Finality Status will remain available from being first identified.")
         ("transaction-finality-status-failure-duration-sec", bpo::value<uint64_t>()->default_value(config::default_max_transaction_finality_status_failure_duration_sec),
          "Duration (in seconds) a failed transaction's Finality Status will remain available from being first identified.");
 
   if(cfile::supports_hole_punching())
      cfg.add_options()("block-log-retain-blocks", bpo::value<uint32_t>(), "if set, periodically prune the block log to store only configured number of most recent blocks");
 
 
// TODO: rate limiting
         /*("per-authorized-account-transaction-msg-rate-limit-time-frame-sec", bpo::value<uint32_t>()->default_value(default_per_auth_account_time_frame_seconds),
          "The time frame, in seconds, that the per-authorized-account-transaction-msg-rate-limit is imposed over.")
         ("per-authorized-account-transaction-msg-rate-limit", bpo::value<uint32_t>()->default_value(default_per_auth_account),
          "Limits the maximum rate of transaction messages that an account is allowed each per-authorized-account-transaction-msg-rate-limit-time-frame-sec.")
          ("per-code-account-transaction-msg-rate-limit-time-frame-sec", bpo::value<uint32_t>()->default_value(default_per_code_account_time_frame_seconds),
           "The time frame, in seconds, that the per-code-account-transaction-msg-rate-limit is imposed over.")
          ("per-code-account-transaction-msg-rate-limit", bpo::value<uint32_t>()->default_value(default_per_code_account),
           "Limits the maximum rate of transaction messages that an account's code is allowed each per-code-account-transaction-msg-rate-limit-time-frame-sec.")*/
 
   cli.add_options()
         ("genesis-json", bpo::value<bfs::path>(), "File to read Genesis State from")
         ("genesis-timestamp", bpo::value<string>(), "override the initial timestamp in the Genesis State file")
         ("print-genesis-json", bpo::bool_switch()->default_value(false),
          "extract genesis_state from blocks.log as JSON, print to console, and exit")
         ("extract-genesis-json", bpo::value<bfs::path>(),
          "extract genesis_state from blocks.log as JSON, write into specified file, and exit")
         ("print-build-info", bpo::bool_switch()->default_value(false),
          "print build environment information to console as JSON and exit")
         ("extract-build-info", bpo::value<bfs::path>(),
          "extract build environment information as JSON, write into specified file, and exit")
         ("force-all-checks", bpo::bool_switch()->default_value(false),
          "do not skip any validation checks while replaying blocks (useful for replaying blocks from untrusted source)")
         ("disable-replay-opts", bpo::bool_switch()->default_value(false),
          "disable optimizations that specifically target replay")
         ("replay-blockchain", bpo::bool_switch()->default_value(false),
          "clear chain state database and replay all blocks")
         ("hard-replay-blockchain", bpo::bool_switch()->default_value(false),
          "clear chain state database, recover as many blocks as possible from the block log, and then replay those blocks")
         ("delete-all-blocks", bpo::bool_switch()->default_value(false),
          "clear chain state database and block log")
         ("truncate-at-block", bpo::value<uint32_t>()->default_value(0),
          "stop hard replay / block log recovery at this block number (if set to non-zero number)")
         ("terminate-at-block", bpo::value<uint32_t>()->default_value(0),
          "terminate after reaching this block number (if set to a non-zero number)")
         ("snapshot", bpo::value<bfs::path>(), "File to read Snapshot State from")
         ;
 
}

Here is the call graph for this function:

transaction_finality_status_enabled()

bool chain_plugin::transaction_finality_status_enabled

(

)

const

Definition at line 1399 of file chain_plugin.cpp.

                                                             {
   return my->_trx_finality_status_processing.get();
}

---

The documentation for this class was generated from the following files:

• plugins/chain_plugin/include/sysio/chain_plugin/chain_plugin.hpp
• plugins/chain_plugin/chain_plugin.cpp