sysio::producer_plugin Class Reference

#include <producer_plugin.hpp>

Inheritance diagram for sysio::producer_plugin:

Collaboration diagram for sysio::producer_plugin:

Classes
struct	get_account_ram_corrections_params
struct	get_account_ram_corrections_result
struct	get_supported_protocol_features_params
struct	greylist_params
struct	integrity_hash_information
struct	scheduled_protocol_feature_activations
struct	snapshot_information
struct	whitelist_blacklist

Public Types
template<typename T >
using	next_function = std::function<void(const std::variant<fc::exception_ptr, T>&)>
Public Types inherited from appbase::abstract_plugin
enum	state { registered , initialized , started , stopped }

Public Member Functions
	APPBASE_PLUGIN_REQUIRES ((chain_plugin)(http_client_plugin)) struct runtime_options
	producer_plugin ()
virtual	~producer_plugin ()
virtual void	set_program_options (boost::program_options::options_description &command_line_options, boost::program_options::options_description &config_file_options) override
bool	is_producer_key (const chain::public_key_type &key) const
chain::signature_type	sign_compact (const chain::public_key_type &key, const fc::sha256 &digest) const
int64_t	get_subjective_bill (const account_name &first_auth, const fc::time_point &now) const
virtual void	plugin_initialize (const boost::program_options::variables_map &options)
virtual void	plugin_startup ()
virtual void	plugin_shutdown ()
void	handle_sighup () override
void	pause ()
void	resume ()
bool	paused () const
void	update_runtime_options (const runtime_options &options)
runtime_options	get_runtime_options () const
void	add_greylist_accounts (const greylist_params &params)
void	remove_greylist_accounts (const greylist_params &params)
greylist_params	get_greylist () const
whitelist_blacklist	get_whitelist_blacklist () const
void	set_whitelist_blacklist (const whitelist_blacklist &params)
integrity_hash_information	get_integrity_hash () const
void	create_snapshot (next_function< snapshot_information > next)
scheduled_protocol_feature_activations	get_scheduled_protocol_feature_activations () const
void	schedule_protocol_feature_activations (const scheduled_protocol_feature_activations &schedule)
fc::variants	get_supported_protocol_features (const get_supported_protocol_features_params &params) const
get_account_ram_corrections_result	get_account_ram_corrections (const get_account_ram_corrections_params &params) const
void	log_failed_transaction (const transaction_id_type &trx_id, const chain::packed_transaction_ptr &packed_trx_ptr, const char *reason) const
void	received_block ()
Public Member Functions inherited from appbase::plugin< producer_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 ()
virtual void	set_program_options (options_description &cli, options_description &cfg)=0

Additional Inherited Members
Protected Member Functions inherited from appbase::plugin< producer_plugin >
	plugin (const string &name)

Detailed Description

Definition at line 12 of file producer_plugin.hpp.

Member Typedef Documentation

next_function

template<typename T >

using sysio::producer_plugin::next_function = std::function<void(const std::variant<fc::exception_ptr, T>&)>

Definition at line 75 of file producer_plugin.hpp.

Constructor & Destructor Documentation

producer_plugin()

sysio::producer_plugin::producer_plugin

(

)

Definition at line 825 of file producer_plugin.cpp.

   : my(new producer_plugin_impl(app().get_io_service())){
   }

Here is the call graph for this function:

~producer_plugin()

sysio::producer_plugin::~producer_plugin ( )

virtual

Definition at line 829 of file producer_plugin.cpp.

{}

Member Function Documentation

add_greylist_accounts()

void sysio::producer_plugin::add_greylist_accounts

(

const greylist_params &

params

)

Definition at line 1329 of file producer_plugin.cpp.

                                                                         {
   SYS_ASSERT(params.accounts.size() > 0, chain::invalid_http_request, "At least one account is required");
 
   chain::controller& chain = my->chain_plug->chain();
   for (auto &acc : params.accounts) {
      chain.add_resource_greylist(acc);
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

APPBASE_PLUGIN_REQUIRES()

sysio::producer_plugin::APPBASE_PLUGIN_REQUIRES ( (chain_plugin)(http_client_plugin) )

inline

Definition at line 14 of file producer_plugin.hpp.

                          {
      std::optional<int32_t>   max_transaction_time;
      std::optional<int32_t>   max_irreversible_block_age;
      std::optional<int32_t>   produce_time_offset_us;
      std::optional<int32_t>   last_block_time_offset_us;
      std::optional<int32_t>   max_scheduled_transaction_time_per_block_ms;
      std::optional<int32_t>   subjective_cpu_leeway_us;
      std::optional<double>    incoming_defer_ratio;
      std::optional<uint32_t>  greylist_limit;
   };

create_snapshot()

void sysio::producer_plugin::create_snapshot

(

next_function< snapshot_information >

next

)

Definition at line 1402 of file producer_plugin.cpp.

                                                                                                            {
   chain::controller& chain = my->chain_plug->chain();
 
   auto head_id = chain.head_block_id();
   const auto head_block_num = chain.head_block_num();
   const auto head_block_time = chain.head_block_time();
   const auto& snapshot_path = pending_snapshot::get_final_path(head_id, my->_snapshots_dir);
   const auto& temp_path     = pending_snapshot::get_temp_path(head_id, my->_snapshots_dir);
 
   // maintain legacy exception if the snapshot exists
   if( fc::is_regular_file(snapshot_path) ) {
      auto ex = snapshot_exists_exception( FC_LOG_MESSAGE( error, "snapshot named ${name} already exists", ("name", snapshot_path.generic_string()) ) );
      next(ex.dynamic_copy_exception());
      return;
   }
 
   auto write_snapshot = [&]( const bfs::path& p ) -> void {
      auto reschedule = fc::make_scoped_exit([this](){
         my->schedule_production_loop();
      });
 
      if (chain.is_building_block()) {
         // abort the pending block
         my->abort_block();
      } else {
         reschedule.cancel();
      }
 
      bfs::create_directory( p.parent_path() );
 
      // create the snapshot
      auto snap_out = std::ofstream(p.generic_string(), (std::ios::out | std::ios::binary));
      auto writer = std::make_shared<ostream_snapshot_writer>(snap_out);
      chain.write_snapshot(writer);
      writer->finalize();
      snap_out.flush();
      snap_out.close();
   };
 
   // If in irreversible mode, create snapshot and return path to snapshot immediately.
   if( chain.get_read_mode() == db_read_mode::IRREVERSIBLE ) {
      try {
         write_snapshot( temp_path );
 
         boost::system::error_code ec;
         bfs::rename(temp_path, snapshot_path, ec);
         SYS_ASSERT(!ec, snapshot_finalization_exception,
               "Unable to finalize valid snapshot of block number ${bn}: [code: ${ec}] ${message}",
               ("bn", head_block_num)
               ("ec", ec.value())
               ("message", ec.message()));
 
         next( producer_plugin::snapshot_information{head_id, head_block_num, head_block_time, chain_snapshot_header::current_version, snapshot_path.generic_string()} );
      } CATCH_AND_CALL (next);
      return;
   }
 
   // Otherwise, the result will be returned when the snapshot becomes irreversible.
 
   // determine if this snapshot is already in-flight
   auto& pending_by_id = my->_pending_snapshot_index.get<by_id>();
   auto existing = pending_by_id.find(head_id);
   if( existing != pending_by_id.end() ) {
      // if a snapshot at this block is already pending, attach this requests handler to it
      pending_by_id.modify(existing, [&next]( auto& entry ){
         entry.next = [prev = entry.next, next](const std::variant<fc::exception_ptr, producer_plugin::snapshot_information>& res){
            prev(res);
            next(res);
         };
      });
   } else {
      const auto& pending_path = pending_snapshot::get_pending_path(head_id, my->_snapshots_dir);
 
      try {
         write_snapshot( temp_path ); // create a new pending snapshot
 
         boost::system::error_code ec;
         bfs::rename(temp_path, pending_path, ec);
         SYS_ASSERT(!ec, snapshot_finalization_exception,
               "Unable to promote temp snapshot to pending for block number ${bn}: [code: ${ec}] ${message}",
               ("bn", head_block_num)
               ("ec", ec.value())
               ("message", ec.message()));
 
         my->_pending_snapshot_index.emplace(head_id, next, pending_path.generic_string(), snapshot_path.generic_string());
      } CATCH_AND_CALL (next);
   }
}

Here is the call graph for this function:

get_account_ram_corrections()

producer_plugin::get_account_ram_corrections_result sysio::producer_plugin::get_account_ram_corrections

(

const get_account_ram_corrections_params &

params

)

const

Definition at line 1553 of file producer_plugin.cpp.

                                                                                                     {
   get_account_ram_corrections_result result;
   const auto& db = my->chain_plug->chain().db();
 
   const auto& idx = db.get_index<chain::account_ram_correction_index, chain::by_name>();
   account_name lower_bound_value{ std::numeric_limits<uint64_t>::lowest() };
   account_name upper_bound_value{ std::numeric_limits<uint64_t>::max() };
 
   if( params.lower_bound ) {
      lower_bound_value = *params.lower_bound;
   }
 
   if( params.upper_bound ) {
      upper_bound_value = *params.upper_bound;
   }
 
   if( upper_bound_value < lower_bound_value )
      return result;
 
   auto walk_range = [&]( auto itr, auto end_itr ) {
      for( unsigned int count = 0;
           count < params.limit && itr != end_itr;
           ++itr )
      {
         result.rows.push_back( fc::variant( *itr ) );
         ++count;
      }
      if( itr != end_itr ) {
         result.more = itr->name;
      }
   };
 
   auto lower = idx.lower_bound( lower_bound_value );
   auto upper = idx.upper_bound( upper_bound_value );
   if( params.reverse ) {
      walk_range( boost::make_reverse_iterator(upper), boost::make_reverse_iterator(lower) );
   } else {
      walk_range( lower, upper );
   }
 
   return result;
}

get_greylist()

producer_plugin::greylist_params sysio::producer_plugin::get_greylist

(

)

const

Definition at line 1347 of file producer_plugin.cpp.

                                                                   {
   chain::controller& chain = my->chain_plug->chain();
   greylist_params result;
   const auto& list = chain.get_resource_greylist();
   result.accounts.reserve(list.size());
   for (auto &acc: list) {
      result.accounts.push_back(acc);
   }
   return result;
}

Here is the call graph for this function:

get_integrity_hash()

producer_plugin::integrity_hash_information sysio::producer_plugin::get_integrity_hash

(

)

const

Definition at line 1385 of file producer_plugin.cpp.

                                                                                    {
   chain::controller& chain = my->chain_plug->chain();
 
   auto reschedule = fc::make_scoped_exit([this](){
      my->schedule_production_loop();
   });
 
   if (chain.is_building_block()) {
      // abort the pending block
      my->abort_block();
   } else {
      reschedule.cancel();
   }
 
   return {chain.head_block_id(), chain.calculate_integrity_hash()};
}

Here is the call graph for this function:

get_runtime_options()

producer_plugin::runtime_options sysio::producer_plugin::get_runtime_options

(

)

const

Definition at line 1314 of file producer_plugin.cpp.

                                                                          {
   return {
      my->_max_transaction_time_ms,
      my->_max_irreversible_block_age_us.count() < 0 ? -1 : my->_max_irreversible_block_age_us.count() / 1'000'000,
      my->_produce_time_offset_us,
      my->_last_block_time_offset_us,
      my->_max_scheduled_transaction_time_per_block_ms,
      my->chain_plug->chain().get_subjective_cpu_leeway() ?
            my->chain_plug->chain().get_subjective_cpu_leeway()->count() :
            std::optional<int32_t>(),
      my->_incoming_defer_ratio,
      my->chain_plug->chain().get_greylist_limit()
   };
}

get_scheduled_protocol_feature_activations()

producer_plugin::scheduled_protocol_feature_activations sysio::producer_plugin::get_scheduled_protocol_feature_activations

(

)

const

Definition at line 1492 of file producer_plugin.cpp.

                                                                 {
   return {my->_protocol_features_to_activate};
}

get_subjective_bill()

int64_t sysio::producer_plugin::get_subjective_bill	(	const account_name &	first_auth,
		const fc::time_point &	now ) const

Definition at line 917 of file producer_plugin.cpp.

{
   return my->_subjective_billing.get_subjective_bill( first_auth, now );
}

get_supported_protocol_features()

fc::variants sysio::producer_plugin::get_supported_protocol_features

(

const get_supported_protocol_features_params &

params

)

const

Definition at line 1514 of file producer_plugin.cpp.

                                                                                                                        {
   fc::variants results;
   const chain::controller& chain = my->chain_plug->chain();
   const auto& pfs = chain.get_protocol_feature_manager().get_protocol_feature_set();
   const auto next_block_time = chain.head_block_time() + fc::milliseconds(config::block_interval_ms);
 
   flat_map<digest_type, bool>  visited_protocol_features;
   visited_protocol_features.reserve( pfs.size() );
 
   std::function<bool(const protocol_feature&)> add_feature =
   [&results, &pfs, &params, next_block_time, &visited_protocol_features, &add_feature]
   ( const protocol_feature& pf ) -> bool {
      if( ( params.exclude_disabled || params.exclude_unactivatable ) && !pf.enabled ) return false;
      if( params.exclude_unactivatable && ( next_block_time < pf.earliest_allowed_activation_time  ) ) return false;
 
      auto res = visited_protocol_features.emplace( pf.feature_digest, false );
      if( !res.second ) return res.first->second;
 
      const auto original_size = results.size();
      for( const auto& dependency : pf.dependencies ) {
         if( !add_feature( pfs.get_protocol_feature( dependency ) ) ) {
            results.resize( original_size );
            return false;
         }
      }
 
      res.first->second = true;
      results.emplace_back( pf.to_variant(true) );
      return true;
   };
 
   for( const auto& pf : pfs ) {
      add_feature( pf );
   }
 
   return results;
}

Here is the call graph for this function:

get_whitelist_blacklist()

producer_plugin::whitelist_blacklist sysio::producer_plugin::get_whitelist_blacklist

(

)

const

Definition at line 1358 of file producer_plugin.cpp.

                                                                                  {
   chain::controller& chain = my->chain_plug->chain();
   return {
      chain.get_actor_whitelist(),
      chain.get_actor_blacklist(),
      chain.get_contract_whitelist(),
      chain.get_contract_blacklist(),
      chain.get_action_blacklist(),
      chain.get_key_blacklist()
   };
}

Here is the call graph for this function:

handle_sighup()

void sysio::producer_plugin::handle_sighup ( )

overridevirtual

Reimplemented from appbase::plugin< producer_plugin >.

Definition at line 1239 of file producer_plugin.cpp.

                                    {
   fc::logger::update( logger_name, _log );
   fc::logger::update(trx_successful_trace_logger_name, _trx_successful_trace_log);
   fc::logger::update(trx_failed_trace_logger_name, _trx_failed_trace_log);
   fc::logger::update(trx_trace_success_logger_name, _trx_trace_success_log);
   fc::logger::update(trx_trace_failure_logger_name, _trx_trace_failure_log);
   fc::logger::update(trx_logger_name, _trx_log);
}

Here is the call graph for this function:

Here is the caller graph for this function:

is_producer_key()

bool sysio::producer_plugin::is_producer_key

(

const chain::public_key_type &

key

)

const

Definition at line 909 of file producer_plugin.cpp.

{
  auto private_key_itr = my->_signature_providers.find(key);
  if(private_key_itr != my->_signature_providers.end())
    return true;
  return false;
}

Here is the caller graph for this function:

log_failed_transaction()

void sysio::producer_plugin::log_failed_transaction	(	const transaction_id_type &	trx_id,
		const chain::packed_transaction_ptr &	packed_trx_ptr,
		const char *	reason ) const

Definition at line 2494 of file producer_plugin.cpp.

                                                                                                                                                      {
   fc_dlog(_trx_failed_trace_log, "[TRX_TRACE] Speculative execution is REJECTING tx: ${txid} : ${why}",
            ("txid", trx_id)("why", reason));
   fc_dlog(_trx_log, "[TRX_TRACE] Speculative execution is REJECTING tx: ${trx}",
            ("entire_trx", packed_trx_ptr ? my->chain_plug->get_log_trx(packed_trx_ptr->get_transaction()) : fc::variant{trx_id}));
   fc_dlog(_trx_trace_failure_log, "[TRX_TRACE] Speculative execution is REJECTING tx: ${entire_trx}",
            ("entire_trx", packed_trx_ptr ? my->chain_plug->get_log_trx(packed_trx_ptr->get_transaction()) : fc::variant{trx_id}));
}

pause()

void sysio::producer_plugin::pause

(

)

Definition at line 1248 of file producer_plugin.cpp.

                            {
   fc_ilog(_log, "Producer paused.");
   my->_pause_production = true;
}

paused()

bool sysio::producer_plugin::paused

(

)

const

Definition at line 1267 of file producer_plugin.cpp.

                                   {
   return my->_pause_production;
}

plugin_initialize()

void sysio::producer_plugin::plugin_initialize ( const boost::program_options::variables_map & options )

virtual

Definition at line 979 of file producer_plugin.cpp.

{ try {
   my->chain_plug = app().find_plugin<chain_plugin>();
   SYS_ASSERT( my->chain_plug, plugin_config_exception, "chain_plugin not found" );
   my->_options = &options;
   LOAD_VALUE_SET(options, "producer-name", my->_producers)
 
   chain::controller& chain = my->chain_plug->chain();
 
   if( options.count("private-key") )
   {
      const std::vector<std::string> key_id_to_wif_pair_strings = options["private-key"].as<std::vector<std::string>>();
      for (const std::string& key_id_to_wif_pair_string : key_id_to_wif_pair_strings)
      {
         try {
            auto key_id_to_wif_pair = dejsonify<std::pair<public_key_type, private_key_type>>(key_id_to_wif_pair_string);
            my->_signature_providers[key_id_to_wif_pair.first] = make_key_signature_provider(key_id_to_wif_pair.second);
            auto blanked_privkey = std::string(key_id_to_wif_pair.second.to_string().size(), '*' );
            wlog("\"private-key\" is DEPRECATED, use \"signature-provider=${pub}=KEY:${priv}\"", ("pub",key_id_to_wif_pair.first)("priv", blanked_privkey));
         } catch ( const std::exception& e ) {
            elog("Malformed private key pair");
         }
      }
   }
 
   if( options.count("signature-provider") ) {
      const std::vector<std::string> key_spec_pairs = options["signature-provider"].as<std::vector<std::string>>();
      for (const auto& key_spec_pair : key_spec_pairs) {
         try {
            auto delim = key_spec_pair.find("=");
            SYS_ASSERT(delim != std::string::npos, plugin_config_exception, "Missing \"=\" in the key spec pair");
            auto pub_key_str = key_spec_pair.substr(0, delim);
            auto spec_str = key_spec_pair.substr(delim + 1);
 
            auto spec_delim = spec_str.find(":");
            SYS_ASSERT(spec_delim != std::string::npos, plugin_config_exception, "Missing \":\" in the key spec pair");
            auto spec_type_str = spec_str.substr(0, spec_delim);
            auto spec_data = spec_str.substr(spec_delim + 1);
 
            auto pubkey = public_key_type(pub_key_str);
 
            if (spec_type_str == "KEY") {
               my->_signature_providers[pubkey] = make_key_signature_provider(private_key_type(spec_data));
            } else if (spec_type_str == "KSYSD") {
               my->_signature_providers[pubkey] = make_kiod_signature_provider(my, spec_data, pubkey);
            }
 
         } catch (...) {
            elog("Malformed signature provider: \"${val}\", ignoring!", ("val", key_spec_pair));
         }
      }
   }
 
   my->_kiod_provider_timeout_us = fc::milliseconds(options.at("kiod-provider-timeout").as<int32_t>());
 
   my->_account_fails.set_max_failures_per_account( options.at("subjective-account-max-failures").as<uint32_t>() );
 
   my->_produce_time_offset_us = options.at("produce-time-offset-us").as<int32_t>();
   SYS_ASSERT( my->_produce_time_offset_us <= 0 && my->_produce_time_offset_us >= -config::block_interval_us, plugin_config_exception,
               "produce-time-offset-us ${o} must be 0 .. -${bi}", ("bi", config::block_interval_us)("o", my->_produce_time_offset_us) );
 
   my->_last_block_time_offset_us = options.at("last-block-time-offset-us").as<int32_t>();
   SYS_ASSERT( my->_last_block_time_offset_us <= 0 && my->_last_block_time_offset_us >= -config::block_interval_us, plugin_config_exception,
               "last-block-time-offset-us ${o} must be 0 .. -${bi}", ("bi", config::block_interval_us)("o", my->_last_block_time_offset_us) );
 
   uint32_t cpu_effort_pct = options.at("cpu-effort-percent").as<uint32_t>();
   SYS_ASSERT( cpu_effort_pct >= 0 && cpu_effort_pct <= 100, plugin_config_exception,
               "cpu-effort-percent ${pct} must be 0 - 100", ("pct", cpu_effort_pct) );
      cpu_effort_pct *= config::percent_1;
   int32_t cpu_effort_offset_us =
         -SYS_PERCENT( config::block_interval_us, chain::config::percent_100 - cpu_effort_pct );
 
   uint32_t last_block_cpu_effort_pct = options.at("last-block-cpu-effort-percent").as<uint32_t>();
   SYS_ASSERT( last_block_cpu_effort_pct >= 0 && last_block_cpu_effort_pct <= 100, plugin_config_exception,
               "last-block-cpu-effort-percent ${pct} must be 0 - 100", ("pct", last_block_cpu_effort_pct) );
      last_block_cpu_effort_pct *= config::percent_1;
   int32_t last_block_cpu_effort_offset_us =
         -SYS_PERCENT( config::block_interval_us, chain::config::percent_100 - last_block_cpu_effort_pct );
 
   my->_produce_time_offset_us = std::min( my->_produce_time_offset_us, cpu_effort_offset_us );
   my->_last_block_time_offset_us = std::min( my->_last_block_time_offset_us, last_block_cpu_effort_offset_us );
 
   my->_max_block_cpu_usage_threshold_us = options.at( "max-block-cpu-usage-threshold-us" ).as<uint32_t>();
   SYS_ASSERT( my->_max_block_cpu_usage_threshold_us < config::block_interval_us, plugin_config_exception,
               "max-block-cpu-usage-threshold-us ${t} must be 0 .. ${bi}", ("bi", config::block_interval_us)("t", my->_max_block_cpu_usage_threshold_us) );
 
   my->_max_block_net_usage_threshold_bytes = options.at( "max-block-net-usage-threshold-bytes" ).as<uint32_t>();
 
   my->_max_scheduled_transaction_time_per_block_ms = options.at("max-scheduled-transaction-time-per-block-ms").as<int32_t>();
 
   if( options.at( "subjective-cpu-leeway-us" ).as<int32_t>() != config::default_subjective_cpu_leeway_us ) {
      chain.set_subjective_cpu_leeway( fc::microseconds( options.at( "subjective-cpu-leeway-us" ).as<int32_t>() ) );
   }
 
   fc::microseconds subjective_account_decay_time = fc::minutes(options.at( "subjective-account-decay-time-minutes" ).as<uint32_t>());
   SYS_ASSERT( subjective_account_decay_time.count() > 0, plugin_config_exception,
               "subjective-account-decay-time-minutes ${dt} must be greater than 0", ("dt", subjective_account_decay_time.to_seconds() / 60));
   my->_subjective_billing.set_expired_accumulator_average_window( subjective_account_decay_time );
 
   my->_max_transaction_time_ms = options.at("max-transaction-time").as<int32_t>();
 
   my->_max_irreversible_block_age_us = fc::seconds(options.at("max-irreversible-block-age").as<int32_t>());
 
   auto max_incoming_transaction_queue_size = options.at("incoming-transaction-queue-size-mb").as<uint16_t>() * 1024*1024;
 
   SYS_ASSERT( max_incoming_transaction_queue_size > 0, plugin_config_exception,
               "incoming-transaction-queue-size-mb ${mb} must be greater than 0", ("mb", max_incoming_transaction_queue_size) );
 
   my->_unapplied_transactions.set_max_transaction_queue_size( max_incoming_transaction_queue_size );
 
   my->_incoming_defer_ratio = options.at("incoming-defer-ratio").as<double>();
 
   my->_disable_persist_until_expired = options.at("disable-api-persisted-trx").as<bool>();
   bool disable_subjective_billing = options.at("disable-subjective-billing").as<bool>();
   my->_disable_subjective_p2p_billing = options.at("disable-subjective-p2p-billing").as<bool>();
   my->_disable_subjective_api_billing = options.at("disable-subjective-api-billing").as<bool>();
   dlog( "disable-subjective-billing: ${s}, disable-subjective-p2p-billing: ${p2p}, disable-subjective-api-billing: ${api}",
         ("s", disable_subjective_billing)("p2p", my->_disable_subjective_p2p_billing)("api", my->_disable_subjective_api_billing) );
   if( !disable_subjective_billing ) {
       my->_disable_subjective_p2p_billing = my->_disable_subjective_api_billing = false;
   } else if( !my->_disable_subjective_p2p_billing || !my->_disable_subjective_api_billing ) {
       disable_subjective_billing = false;
   }
   if( disable_subjective_billing ) {
       my->_subjective_billing.disable();
       ilog( "Subjective CPU billing disabled" );
   } else if( !my->_disable_subjective_p2p_billing && !my->_disable_subjective_api_billing ) {
       ilog( "Subjective CPU billing enabled" );
   } else {
       if( my->_disable_subjective_p2p_billing ) ilog( "Subjective CPU billing of P2P trxs disabled " );
       if( my->_disable_subjective_api_billing ) ilog( "Subjective CPU billing of API trxs disabled " );
   }
 
   auto thread_pool_size = options.at( "producer-threads" ).as<uint16_t>();
   SYS_ASSERT( thread_pool_size > 0, plugin_config_exception,
               "producer-threads ${num} must be greater than 0", ("num", thread_pool_size));
   my->_thread_pool.emplace( "prod", thread_pool_size );
 
   if( options.count( "snapshots-dir" )) {
      auto sd = options.at( "snapshots-dir" ).as<bfs::path>();
      if( sd.is_relative()) {
         my->_snapshots_dir = app().data_dir() / sd;
         if (!fc::exists(my->_snapshots_dir)) {
            fc::create_directories(my->_snapshots_dir);
         }
      } else {
         my->_snapshots_dir = sd;
      }
 
      SYS_ASSERT( fc::is_directory(my->_snapshots_dir), snapshot_directory_not_found_exception,
                  "No such directory '${dir}'", ("dir", my->_snapshots_dir.generic_string()) );
 
      if (auto resmon_plugin = app().find_plugin<resource_monitor_plugin>()) {
         resmon_plugin->monitor_directory(my->_snapshots_dir);
      }
   }
 
   my->_incoming_block_sync_provider = app().get_method<incoming::methods::block_sync>().register_provider(
         [this](const signed_block_ptr& block, const std::optional<block_id_type>& block_id, const block_state_ptr& bsp) {
      return my->on_incoming_block(block, block_id, bsp);
   });
 
   my->_incoming_transaction_async_provider = app().get_method<incoming::methods::transaction_async>().register_provider(
         [this](const packed_transaction_ptr& trx, bool persist_until_expired, bool read_only, bool return_failure_traces, next_function<transaction_trace_ptr> next) -> void {
      return my->on_incoming_transaction_async(trx, persist_until_expired, read_only, return_failure_traces, next );
   });
 
   if (options.count("greylist-account")) {
      std::vector<std::string> greylist = options["greylist-account"].as<std::vector<std::string>>();
      greylist_params param;
      for (auto &a : greylist) {
         param.accounts.push_back(account_name(a));
      }
      add_greylist_accounts(param);
   }
 
   {
      uint32_t greylist_limit = options.at("greylist-limit").as<uint32_t>();
      chain.set_greylist_limit( greylist_limit );
   }
 
   if( options.count("disable-subjective-account-billing") ) {
      std::vector<std::string> accounts = options["disable-subjective-account-billing"].as<std::vector<std::string>>();
      for( const auto& a : accounts ) {
         my->_subjective_billing.disable_account( account_name(a) );
      }
   }
 
} FC_LOG_AND_RETHROW() }

Here is the call graph for this function:

plugin_shutdown()

void sysio::producer_plugin::plugin_shutdown ( )

virtual

Definition at line 1218 of file producer_plugin.cpp.

                                      {
   try {
      my->_timer.cancel();
   } catch ( const std::bad_alloc& ) {
     chain_plugin::handle_bad_alloc();
   } catch ( const boost::interprocess::bad_alloc& ) {
     chain_plugin::handle_bad_alloc();
   } catch(const fc::exception& e) {
      edump((e.to_detail_string()));
   } catch(const std::exception& e) {
      edump((fc::std_exception_wrapper::from_current_exception(e).to_detail_string()));
   }
 
   if( my->_thread_pool ) {
      my->_thread_pool->stop();
   }
 
   app().post( 0, [me = my](){} ); // keep my pointer alive until queue is drained
   fc_ilog(_log, "exit shutdown");
}

Here is the call graph for this function:

Here is the caller graph for this function:

plugin_startup()

void sysio::producer_plugin::plugin_startup ( )

virtual

Definition at line 1169 of file producer_plugin.cpp.

{ try {
   handle_sighup(); // Sets loggers
 
   try {
   ilog("producer plugin:  plugin_startup() begin");
 
   chain::controller& chain = my->chain_plug->chain();
   SYS_ASSERT( my->_producers.empty() || chain.get_read_mode() == chain::db_read_mode::SPECULATIVE, plugin_config_exception,
              "node cannot have any producer-name configured because block production is impossible when read_mode is not \"speculative\"" );
 
   SYS_ASSERT( my->_producers.empty() || chain.get_validation_mode() == chain::validation_mode::FULL, plugin_config_exception,
              "node cannot have any producer-name configured because block production is not safe when validation_mode is not \"full\"" );
 
   SYS_ASSERT( my->_producers.empty() || my->chain_plug->accept_transactions(), plugin_config_exception,
              "node cannot have any producer-name configured because no block production is possible with no [api|p2p]-accepted-transactions" );
 
   my->_accepted_block_connection.emplace(chain.accepted_block.connect( [this]( const auto& bsp ){ my->on_block( bsp ); } ));
   my->_accepted_block_header_connection.emplace(chain.accepted_block_header.connect( [this]( const auto& bsp ){ my->on_block_header( bsp ); } ));
   my->_irreversible_block_connection.emplace(chain.irreversible_block.connect( [this]( const auto& bsp ){ my->on_irreversible_block( bsp->block ); } ));
 
   const auto lib_num = chain.last_irreversible_block_num();
   const auto lib = chain.fetch_block_by_number(lib_num);
   if (lib) {
      my->on_irreversible_block(lib);
   } else {
      my->_irreversible_block_time = fc::time_point::maximum();
   }
 
   if (!my->_producers.empty()) {
      ilog("Launching block production for ${n} producers at ${time}.", ("n", my->_producers.size())("time",fc::time_point::now()));
 
      if (my->_production_enabled) {
         if (chain.head_block_num() == 0) {
            new_chain_banner(chain);
         }
      }
   }
 
   my->schedule_production_loop();
 
   ilog("producer plugin:  plugin_startup() end");
   } catch( ... ) {
      // always call plugin_shutdown, even on exception
      plugin_shutdown();
      throw;
   }
} FC_CAPTURE_AND_RETHROW() }

Here is the call graph for this function:

received_block()

void sysio::producer_plugin::received_block

(

)

Definition at line 2490 of file producer_plugin.cpp.

                                     {
   my->_received_block = true;
}

Here is the caller graph for this function:

remove_greylist_accounts()

void sysio::producer_plugin::remove_greylist_accounts

(

const greylist_params &

params

)

Definition at line 1338 of file producer_plugin.cpp.

                                                                            {
   SYS_ASSERT(params.accounts.size() > 0, chain::invalid_http_request, "At least one account is required");
 
   chain::controller& chain = my->chain_plug->chain();
   for (auto &acc : params.accounts) {
      chain.remove_resource_greylist(acc);
   }
}

Here is the call graph for this function:

resume()

void sysio::producer_plugin::resume

(

)

Definition at line 1253 of file producer_plugin.cpp.

                             {
   my->_pause_production = false;
   // it is possible that we are only speculating because of this policy which we have now changed
   // re-evaluate that now
   //
   if (my->_pending_block_mode == pending_block_mode::speculating) {
      my->abort_block();
      fc_ilog(_log, "Producer resumed. Scheduling production.");
      my->schedule_production_loop();
   } else {
      fc_ilog(_log, "Producer resumed.");
   }
}

schedule_protocol_feature_activations()

void sysio::producer_plugin::schedule_protocol_feature_activations

(

const scheduled_protocol_feature_activations &

schedule

)

Definition at line 1496 of file producer_plugin.cpp.

                                                                                                                    {
   const chain::controller& chain = my->chain_plug->chain();
   std::set<digest_type> set_of_features_to_activate( schedule.protocol_features_to_activate.begin(),
                                                      schedule.protocol_features_to_activate.end() );
   SYS_ASSERT( set_of_features_to_activate.size() == schedule.protocol_features_to_activate.size(),
               invalid_protocol_features_to_activate, "duplicate digests" );
   chain.validate_protocol_features( schedule.protocol_features_to_activate );
   const auto& pfs = chain.get_protocol_feature_manager().get_protocol_feature_set();
   for (auto &feature_digest : set_of_features_to_activate) {
      const auto& pf = pfs.get_protocol_feature(feature_digest);
      SYS_ASSERT( !pf.preactivation_required, protocol_feature_exception,
                  "protocol feature requires preactivation: ${digest}",
                  ("digest", feature_digest));
   }
   my->_protocol_features_to_activate = schedule.protocol_features_to_activate;
   my->_protocol_features_signaled = false;
}

Here is the call graph for this function:

set_program_options()

void sysio::producer_plugin::set_program_options ( boost::program_options::options_description & command_line_options, boost::program_options::options_description & config_file_options )

overridevirtual

Definition at line 831 of file producer_plugin.cpp.

{
   auto default_priv_key = private_key_type::regenerate<fc::ecc::private_key_shim>(fc::sha256::hash(std::string("nathan")));
   auto private_key_default = std::make_pair(default_priv_key.get_public_key(), default_priv_key );
 
   boost::program_options::options_description producer_options;
 
   producer_options.add_options()
         ("enable-stale-production,e", boost::program_options::bool_switch()->notifier([this](bool e){my->_production_enabled = e;}), "Enable block production, even if the chain is stale.")
         ("pause-on-startup,x", boost::program_options::bool_switch()->notifier([this](bool p){my->_pause_production = p;}), "Start this node in a state where production is paused")
         ("max-transaction-time", bpo::value<int32_t>()->default_value(30),
          "Limits the maximum time (in milliseconds) that is allowed a pushed transaction's code to execute before being considered invalid")
         ("max-irreversible-block-age", bpo::value<int32_t>()->default_value( -1 ),
          "Limits the maximum age (in seconds) of the DPOS Irreversible Block for a chain this node will produce blocks on (use negative value to indicate unlimited)")
         ("producer-name,p", boost::program_options::value<vector<string>>()->composing()->multitoken(),
          "ID of producer controlled by this node (e.g. inita; may specify multiple times)")
         ("private-key", boost::program_options::value<vector<string>>()->composing()->multitoken(),
          "(DEPRECATED - Use signature-provider instead) Tuple of [public key, WIF private key] (may specify multiple times)")
         ("signature-provider", boost::program_options::value<vector<string>>()->composing()->multitoken()->default_value(
               {default_priv_key.get_public_key().to_string() + "=KEY:" + default_priv_key.to_string()},
                default_priv_key.get_public_key().to_string() + "=KEY:" + default_priv_key.to_string()),
          "Key=Value pairs in the form <public-key>=<provider-spec>\n"
          "Where:\n"
          "   <public-key>    \tis a string form of a vaild SYSIO public key\n\n"
          "   <provider-spec> \tis a string in the form <provider-type>:<data>\n\n"
          "   <provider-type> \tis KEY, or KSYSD\n\n"
          "   KEY:<data>      \tis a string form of a valid SYSIO private key which maps to the provided public key\n\n"
          "   KSYSD:<data>    \tis the URL where kiod is available and the approptiate wallet(s) are unlocked")
         ("kiod-provider-timeout", boost::program_options::value<int32_t>()->default_value(5),
          "Limits the maximum time (in milliseconds) that is allowed for sending blocks to a kiod provider for signing")
         ("greylist-account", boost::program_options::value<vector<string>>()->composing()->multitoken(),
          "account that can not access to extended CPU/NET virtual resources")
         ("greylist-limit", boost::program_options::value<uint32_t>()->default_value(1000),
          "Limit (between 1 and 1000) on the multiple that CPU/NET virtual resources can extend during low usage (only enforced subjectively; use 1000 to not enforce any limit)")
         ("produce-time-offset-us", boost::program_options::value<int32_t>()->default_value(0),
          "Offset of non last block producing time in microseconds. Valid range 0 .. -block_time_interval.")
         ("last-block-time-offset-us", boost::program_options::value<int32_t>()->default_value(-200000),
          "Offset of last block producing time in microseconds. Valid range 0 .. -block_time_interval.")
         ("cpu-effort-percent", bpo::value<uint32_t>()->default_value(config::default_block_cpu_effort_pct / config::percent_1),
          "Percentage of cpu block production time used to produce block. Whole number percentages, e.g. 80 for 80%")
         ("last-block-cpu-effort-percent", bpo::value<uint32_t>()->default_value(config::default_block_cpu_effort_pct / config::percent_1),
          "Percentage of cpu block production time used to produce last block. Whole number percentages, e.g. 80 for 80%")
         ("max-block-cpu-usage-threshold-us", bpo::value<uint32_t>()->default_value( 5000 ),
          "Threshold of CPU block production to consider block full; when within threshold of max-block-cpu-usage block can be produced immediately")
         ("max-block-net-usage-threshold-bytes", bpo::value<uint32_t>()->default_value( 1024 ),
          "Threshold of NET block production to consider block full; when within threshold of max-block-net-usage block can be produced immediately")
         ("max-scheduled-transaction-time-per-block-ms", boost::program_options::value<int32_t>()->default_value(100),
          "Maximum wall-clock time, in milliseconds, spent retiring scheduled transactions in any block before returning to normal transaction processing.")
         ("subjective-cpu-leeway-us", boost::program_options::value<int32_t>()->default_value( config::default_subjective_cpu_leeway_us ),
          "Time in microseconds allowed for a transaction that starts with insufficient CPU quota to complete and cover its CPU usage.")
         ("subjective-account-max-failures", boost::program_options::value<uint32_t>()->default_value(3),
          "Sets the maximum amount of failures that are allowed for a given account per block.")
         ("subjective-account-decay-time-minutes", bpo::value<uint32_t>()->default_value( config::account_cpu_usage_average_window_ms / 1000 / 60 ),
          "Sets the time to return full subjective cpu for accounts")
         ("incoming-defer-ratio", bpo::value<double>()->default_value(1.0),
          "ratio between incoming transactions and deferred transactions when both are queued for execution")
         ("incoming-transaction-queue-size-mb", bpo::value<uint16_t>()->default_value( 1024 ),
          "Maximum size (in MiB) of the incoming transaction queue. Exceeding this value will subjectively drop transaction with resource exhaustion.")
         ("disable-api-persisted-trx", bpo::bool_switch()->default_value(false),
          "Disable the re-apply of API transactions.")
         ("disable-subjective-billing", bpo::value<bool>()->default_value(true),
          "Disable subjective CPU billing for API/P2P transactions")
         ("disable-subjective-account-billing", boost::program_options::value<vector<string>>()->composing()->multitoken(),
          "Account which is excluded from subjective CPU billing")
         ("disable-subjective-p2p-billing", bpo::value<bool>()->default_value(true),
          "Disable subjective CPU billing for P2P transactions")
         ("disable-subjective-api-billing", bpo::value<bool>()->default_value(true),
          "Disable subjective CPU billing for API transactions")
         ("producer-threads", bpo::value<uint16_t>()->default_value(config::default_controller_thread_pool_size),
          "Number of worker threads in producer thread pool")
         ("snapshots-dir", bpo::value<bfs::path>()->default_value("snapshots"),
          "the location of the snapshots directory (absolute path or relative to application data dir)")
         ;
   config_file_options.add(producer_options);
}

Here is the call graph for this function:

set_whitelist_blacklist()

void sysio::producer_plugin::set_whitelist_blacklist

(

const whitelist_blacklist &

params

)

Definition at line 1370 of file producer_plugin.cpp.

                                                                                              {
   SYS_ASSERT(params.actor_whitelist || params.actor_blacklist || params.contract_whitelist || params.contract_blacklist || params.action_blacklist || params.key_blacklist,
              chain::invalid_http_request,
              "At least one of actor_whitelist, actor_blacklist, contract_whitelist, contract_blacklist, action_blacklist, and key_blacklist is required"
             );
 
   chain::controller& chain = my->chain_plug->chain();
   if(params.actor_whitelist) chain.set_actor_whitelist(*params.actor_whitelist);
   if(params.actor_blacklist) chain.set_actor_blacklist(*params.actor_blacklist);
   if(params.contract_whitelist) chain.set_contract_whitelist(*params.contract_whitelist);
   if(params.contract_blacklist) chain.set_contract_blacklist(*params.contract_blacklist);
   if(params.action_blacklist) chain.set_action_blacklist(*params.action_blacklist);
   if(params.key_blacklist) chain.set_key_blacklist(*params.key_blacklist);
}

Here is the call graph for this function:

sign_compact()

chain::signature_type sysio::producer_plugin::sign_compact	(	const chain::public_key_type &	key,
		const fc::sha256 &	digest ) const

Definition at line 922 of file producer_plugin.cpp.

{
  if(key != chain::public_key_type()) {
    auto private_key_itr = my->_signature_providers.find(key);
    SYS_ASSERT(private_key_itr != my->_signature_providers.end(), producer_priv_key_not_found, "Local producer has no private key in config.ini corresponding to public key ${key}", ("key", key));
 
    return private_key_itr->second(digest);
  }
  else {
    return chain::signature_type();
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

update_runtime_options()

void sysio::producer_plugin::update_runtime_options

(

const runtime_options &

options

)

Definition at line 1271 of file producer_plugin.cpp.

                                                                           {
   chain::controller& chain = my->chain_plug->chain();
   bool check_speculating = false;
 
   if (options.max_transaction_time) {
      my->_max_transaction_time_ms = *options.max_transaction_time;
   }
 
   if (options.max_irreversible_block_age) {
      my->_max_irreversible_block_age_us =  fc::seconds(*options.max_irreversible_block_age);
      check_speculating = true;
   }
 
   if (options.produce_time_offset_us) {
      my->_produce_time_offset_us = *options.produce_time_offset_us;
   }
 
   if (options.last_block_time_offset_us) {
      my->_last_block_time_offset_us = *options.last_block_time_offset_us;
   }
 
   if (options.max_scheduled_transaction_time_per_block_ms) {
      my->_max_scheduled_transaction_time_per_block_ms = *options.max_scheduled_transaction_time_per_block_ms;
   }
 
   if (options.incoming_defer_ratio) {
      my->_incoming_defer_ratio = *options.incoming_defer_ratio;
   }
 
   if (check_speculating && my->_pending_block_mode == pending_block_mode::speculating) {
      my->abort_block();
      my->schedule_production_loop();
   }
 
   if (options.subjective_cpu_leeway_us) {
      chain.set_subjective_cpu_leeway(fc::microseconds(*options.subjective_cpu_leeway_us));
   }
 
   if (options.greylist_limit) {
      chain.set_greylist_limit(*options.greylist_limit);
   }
}

Here is the call graph for this function:

---

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

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