sysio::producer_plugin_impl Class Reference

Inheritance diagram for sysio::producer_plugin_impl:

Collaboration diagram for sysio::producer_plugin_impl:

Public Types
enum class	start_block_result {   succeeded , failed , waiting_for_block , waiting_for_production ,   exhausted }
using	signature_provider_type = std::function<chain::signature_type(chain::digest_type)>
using	producer_watermark = std::pair<uint32_t, block_timestamp_type>

Public Member Functions
	producer_plugin_impl (boost::asio::io_service &io)
std::optional< fc::time_point >	calculate_next_block_time (const account_name &producer_name, const block_timestamp_type &current_block_time) const
void	schedule_production_loop ()
void	schedule_maybe_produce_block (bool exhausted)
void	produce_block ()
bool	maybe_produce_block ()
bool	block_is_exhausted () const
bool	remove_expired_trxs (const fc::time_point &deadline)
bool	remove_expired_blacklisted_trxs (const fc::time_point &deadline)
bool	process_unapplied_trxs (const fc::time_point &deadline)
void	process_scheduled_and_incoming_trxs (const fc::time_point &deadline, size_t &pending_incoming_process_limit)
bool	process_incoming_trxs (const fc::time_point &deadline, size_t &pending_incoming_process_limit)
void	consider_new_watermark (account_name producer, uint32_t block_num, block_timestamp_type timestamp)
std::optional< producer_watermark >	get_watermark (account_name producer) const
void	on_block (const block_state_ptr &bsp)
void	on_block_header (const block_state_ptr &bsp)
void	on_irreversible_block (const signed_block_ptr &lib)
void	abort_block ()
bool	on_incoming_block (const signed_block_ptr &block, const std::optional< block_id_type > &block_id, const block_state_ptr &bsp)
void	restart_speculative_block ()
void	on_incoming_transaction_async (const packed_transaction_ptr &trx, bool persist_until_expired, bool read_only, bool return_failure_traces, next_function< transaction_trace_ptr > next)
bool	process_incoming_transaction_async (const transaction_metadata_ptr &trx, bool persist_until_expired, bool return_failure_traces, next_function< transaction_trace_ptr > next)
fc::microseconds	get_irreversible_block_age ()
account_name	get_pending_block_producer ()
bool	production_disabled_by_policy ()
bool	should_interrupt_start_block (const fc::time_point &deadline) const
start_block_result	start_block ()
fc::time_point	calculate_pending_block_time () const
fc::time_point	calculate_block_deadline (const fc::time_point &) const
void	schedule_delayed_production_loop (const std::weak_ptr< producer_plugin_impl > &weak_this, std::optional< fc::time_point > wake_up_time)
std::optional< fc::time_point >	calculate_producer_wake_up_time (const block_timestamp_type &ref_block_time) const

Public Attributes
boost::program_options::variables_map	_options
bool	_production_enabled = false
bool	_pause_production = false
std::map< chain::public_key_type, signature_provider_type >	_signature_providers
std::set< chain::account_name >	_producers
boost::asio::deadline_timer	_timer
std::map< chain::account_name, producer_watermark >	_producer_watermarks
pending_block_mode	_pending_block_mode = pending_block_mode::speculating
unapplied_transaction_queue	_unapplied_transactions
std::optional< named_thread_pool >	_thread_pool
std::atomic< int32_t >	_max_transaction_time_ms
std::atomic< bool >	_received_block {false}
fc::microseconds	_max_irreversible_block_age_us
int32_t	_produce_time_offset_us = 0
int32_t	_last_block_time_offset_us = 0
uint32_t	_max_block_cpu_usage_threshold_us = 0
uint32_t	_max_block_net_usage_threshold_bytes = 0
int32_t	_max_scheduled_transaction_time_per_block_ms = 0
bool	_disable_persist_until_expired = false
bool	_disable_subjective_p2p_billing = true
bool	_disable_subjective_api_billing = true
fc::time_point	_irreversible_block_time
fc::microseconds	_kiod_provider_timeout_us
std::vector< chain::digest_type >	_protocol_features_to_activate
bool	_protocol_features_signaled = false
chain_plugin *	chain_plug = nullptr
compat::channels::transaction_ack::channel_type &	_transaction_ack_channel
incoming::methods::block_sync::method_type::handle	_incoming_block_sync_provider
incoming::methods::transaction_async::method_type::handle	_incoming_transaction_async_provider
transaction_id_with_expiry_index	_blacklisted_transactions
pending_snapshot_index	_pending_snapshot_index
subjective_billing	_subjective_billing
account_failures	_account_fails {_subjective_billing}
std::optional< scoped_connection >	_accepted_block_connection
std::optional< scoped_connection >	_accepted_block_header_connection
std::optional< scoped_connection >	_irreversible_block_connection
uint32_t	_timer_corelation_id = 0
double	_incoming_defer_ratio = 1.0
bfs::path	_snapshots_dir

Detailed Description

Definition at line 292 of file producer_plugin.cpp.

Member Typedef Documentation

producer_watermark

using sysio::producer_plugin_impl::producer_watermark = std::pair<uint32_t, block_timestamp_type>

Definition at line 320 of file producer_plugin.cpp.

signature_provider_type

using sysio::producer_plugin_impl::signature_provider_type = std::function<chain::signature_type(chain::digest_type)>

Definition at line 316 of file producer_plugin.cpp.

Member Enumeration Documentation

start_block_result

enum class sysio::producer_plugin_impl::start_block_result

strong

Enumerator
succeeded
failed
waiting_for_block
waiting_for_production
exhausted

Definition at line 785 of file producer_plugin.cpp.

                                    {
         succeeded,
         failed,
         waiting_for_block,
         waiting_for_production,
         exhausted
      };

Constructor & Destructor Documentation

producer_plugin_impl()

sysio::producer_plugin_impl::producer_plugin_impl ( boost::asio::io_service & io )

inline

Definition at line 294 of file producer_plugin.cpp.

      :_timer(io)
      ,_transaction_ack_channel(app().get_channel<compat::channels::transaction_ack>())
      {
      }

Member Function Documentation

abort_block()

void sysio::producer_plugin_impl::abort_block ( )

inline

Definition at line 427 of file producer_plugin.cpp.

                         {
         auto& chain = chain_plug->chain();
 
         _unapplied_transactions.add_aborted( chain.abort_block() );
         _subjective_billing.abort_block();
      }

Here is the call graph for this function:

Here is the caller graph for this function:

block_is_exhausted()

bool sysio::producer_plugin_impl::block_is_exhausted

(

)

const

Definition at line 2238 of file producer_plugin.cpp.

                                                    {
   const chain::controller& chain = chain_plug->chain();
   const auto& rl = chain.get_resource_limits_manager();
 
   const uint64_t cpu_limit = rl.get_block_cpu_limit();
   if( cpu_limit < _max_block_cpu_usage_threshold_us ) return true;
   const uint64_t net_limit = rl.get_block_net_limit();
   if( net_limit < _max_block_net_usage_threshold_bytes ) return true;
   return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

calculate_block_deadline()

fc::time_point sysio::producer_plugin_impl::calculate_block_deadline

(

const fc::time_point &

block_time

)

const

Definition at line 1665 of file producer_plugin.cpp.

                                                                                                  {
   if( _pending_block_mode == pending_block_mode::producing ) {
      bool last_block = ((block_timestamp_type( block_time ).slot % config::producer_repetitions) == config::producer_repetitions - 1);
      return block_time + fc::microseconds(last_block ? _last_block_time_offset_us : _produce_time_offset_us);
   } else {
      return block_time + fc::microseconds(_produce_time_offset_us);
   }
}

Here is the caller graph for this function:

calculate_next_block_time()

std::optional< fc::time_point > sysio::producer_plugin_impl::calculate_next_block_time	(	const account_name &	producer_name,
		const block_timestamp_type &	current_block_time ) const

Definition at line 1596 of file producer_plugin.cpp.

                                                                                                                                                                 {
   chain::controller& chain = chain_plug->chain();
   const auto& hbs = chain.head_block_state();
   const auto& active_schedule = hbs->active_schedule.producers;
 
   // determine if this producer is in the active schedule and if so, where
   auto itr = std::find_if(active_schedule.begin(), active_schedule.end(), [&](const auto& asp){ return asp.producer_name == producer_name; });
   if (itr == active_schedule.end()) {
      // this producer is not in the active producer set
      return std::optional<fc::time_point>();
   }
 
   size_t producer_index = itr - active_schedule.begin();
   uint32_t minimum_offset = 1; // must at least be the "next" block
 
   // account for a watermark in the future which is disqualifying this producer for now
   // this is conservative assuming no blocks are dropped.  If blocks are dropped the watermark will
   // disqualify this producer for longer but it is assumed they will wake up, determine that they
   // are disqualified for longer due to skipped blocks and re-caculate their next block with better
   // information then
   auto current_watermark = get_watermark(producer_name);
   if (current_watermark) {
      const auto watermark = *current_watermark;
      auto block_num = chain.head_block_state()->block_num;
      if (chain.is_building_block()) {
         ++block_num;
      }
      if (watermark.first > block_num) {
         // if I have a watermark block number then I need to wait until after that watermark
         minimum_offset = watermark.first - block_num + 1;
      }
      if (watermark.second > current_block_time) {
          // if I have a watermark block timestamp then I need to wait until after that watermark timestamp
          minimum_offset = std::max(minimum_offset, watermark.second.slot - current_block_time.slot + 1);
      }
   }
 
   // this producers next opportuity to produce is the next time its slot arrives after or at the calculated minimum
   uint32_t minimum_slot = current_block_time.slot + minimum_offset;
   size_t minimum_slot_producer_index = (minimum_slot % (active_schedule.size() * config::producer_repetitions)) / config::producer_repetitions;
   if ( producer_index == minimum_slot_producer_index ) {
      // this is the producer for the minimum slot, go with that
      return block_timestamp_type(minimum_slot).to_time_point();
   } else {
      // calculate how many rounds are between the minimum producer and the producer in question
      size_t producer_distance = producer_index - minimum_slot_producer_index;
      // check for unsigned underflow
      if (producer_distance > producer_index) {
         producer_distance += active_schedule.size();
      }
 
      // align the minimum slot to the first of its set of reps
      uint32_t first_minimum_producer_slot = minimum_slot - (minimum_slot % config::producer_repetitions);
 
      // offset the aligned minimum to the *earliest* next set of slots for this producer
      uint32_t next_block_slot = first_minimum_producer_slot  + (producer_distance * config::producer_repetitions);
      return block_timestamp_type(next_block_slot).to_time_point();
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

calculate_pending_block_time()

fc::time_point sysio::producer_plugin_impl::calculate_pending_block_time

(

)

const

Definition at line 1656 of file producer_plugin.cpp.

                                                                      {
   const chain::controller& chain = chain_plug->chain();
   const fc::time_point now = fc::time_point::now();
   const fc::time_point base = std::max<fc::time_point>(now, chain.head_block_time());
   const int64_t min_time_to_next_block = (config::block_interval_us) - (base.time_since_epoch().count() % (config::block_interval_us) );
   fc::time_point block_time = base + fc::microseconds(min_time_to_next_block);
   return block_time;
}

Here is the call graph for this function:

Here is the caller graph for this function:

calculate_producer_wake_up_time()

std::optional< fc::time_point > sysio::producer_plugin_impl::calculate_producer_wake_up_time

(

const block_timestamp_type &

ref_block_time

)

const

Definition at line 2332 of file producer_plugin.cpp.

                                                                                                                                  {
   // if we have any producers then we should at least set a timer for our next available slot
   std::optional<fc::time_point> wake_up_time;
   for (const auto& p : _producers) {
      auto next_producer_block_time = calculate_next_block_time(p, ref_block_time);
      if (next_producer_block_time) {
         auto producer_wake_up_time = *next_producer_block_time - fc::microseconds(config::block_interval_us);
         if (wake_up_time) {
            // wake up with a full block interval to the deadline
            if( producer_wake_up_time < *wake_up_time ) {
               wake_up_time = producer_wake_up_time;
            }
         } else {
            wake_up_time = producer_wake_up_time;
         }
      }
   }
   if( !wake_up_time ) {
      fc_dlog(_log, "Not Scheduling Speculative/Production, no local producers had valid wake up times");
   }
 
   return wake_up_time;
}

Here is the call graph for this function:

Here is the caller graph for this function:

consider_new_watermark()

void sysio::producer_plugin_impl::consider_new_watermark ( account_name producer, uint32_t block_num, block_timestamp_type timestamp )

inline

Definition at line 377 of file producer_plugin.cpp.

                                                                                                              {
         auto itr = _producer_watermarks.find( producer );
         if( itr != _producer_watermarks.end() ) {
            itr->second.first = std::max( itr->second.first, block_num );
            itr->second.second = std::max( itr->second.second, timestamp );
         } else if( _producers.count( producer ) > 0 ) {
            _producer_watermarks.emplace( producer, std::make_pair(block_num, timestamp) );
         }
      }

Here is the caller graph for this function:

get_irreversible_block_age()

fc::microseconds sysio::producer_plugin_impl::get_irreversible_block_age ( )

inline

Definition at line 763 of file producer_plugin.cpp.

                                                  {
         auto now = fc::time_point::now();
         if (now < _irreversible_block_time) {
            return fc::microseconds(0);
         } else {
            return now - _irreversible_block_time;
         }
      }

Here is the call graph for this function:

Here is the caller graph for this function:

get_pending_block_producer()

account_name sysio::producer_plugin_impl::get_pending_block_producer ( )

inline

Definition at line 772 of file producer_plugin.cpp.

                                                {
         auto& chain = chain_plug->chain();
         if (chain.is_building_block()) {
            return chain.pending_block_producer();
         } else {
            return {};
         }
      }

get_watermark()

std::optional< producer_watermark > sysio::producer_plugin_impl::get_watermark ( account_name producer ) const

inline

Definition at line 387 of file producer_plugin.cpp.

                                                                                   {
         auto itr = _producer_watermarks.find( producer );
 
         if( itr == _producer_watermarks.end() ) return {};
 
         return itr->second;
      }

Here is the caller graph for this function:

maybe_produce_block()

bool sysio::producer_plugin_impl::maybe_produce_block

(

)

Definition at line 2372 of file producer_plugin.cpp.

                                               {
   auto reschedule = fc::make_scoped_exit([this]{
      schedule_production_loop();
   });
 
   try {
      produce_block();
      return true;
   } LOG_AND_DROP();
 
   fc_dlog(_log, "Aborting block due to produce_block error");
   abort_block();
   return false;
}

Here is the call graph for this function:

on_block()

void sysio::producer_plugin_impl::on_block ( const block_state_ptr & bsp )

inline

Definition at line 395 of file producer_plugin.cpp.

                                                  {
         auto before = _unapplied_transactions.size();
         _unapplied_transactions.clear_applied( bsp );
         _subjective_billing.on_block( _log, bsp, fc::time_point::now() );
         fc_dlog( _log, "Removed applied transactions before: ${before}, after: ${after}",
                  ("before", before)("after", _unapplied_transactions.size()) );
      }

Here is the call graph for this function:

on_block_header()

void sysio::producer_plugin_impl::on_block_header ( const block_state_ptr & bsp )

inline

Definition at line 403 of file producer_plugin.cpp.

                                                         {
         consider_new_watermark( bsp->header.producer, bsp->block_num, bsp->block->timestamp );
      }

Here is the call graph for this function:

on_incoming_block()

bool sysio::producer_plugin_impl::on_incoming_block ( const signed_block_ptr & block, const std::optional< block_id_type > & block_id, const block_state_ptr & bsp )

inline

Definition at line 434 of file producer_plugin.cpp.

                                                                                                                                    {
         auto& chain = chain_plug->chain();
         if ( _pending_block_mode == pending_block_mode::producing ) {
            fc_wlog( _log, "dropped incoming block #${num} id: ${id}",
                     ("num", block->block_num())("id", block_id ? (*block_id).str() : "UNKNOWN") );
            return false;
         }
 
         // start a new speculative block, speculative start_block may have been interrupted
         auto ensure = fc::make_scoped_exit([this](){
            schedule_production_loop();
         });
 
         const auto& id = block_id ? *block_id : block->calculate_id();
         auto blk_num = block->block_num();
 
         fc_dlog(_log, "received incoming block ${n} ${id}", ("n", blk_num)("id", id));
 
         SYS_ASSERT( block->timestamp < (fc::time_point::now() + fc::seconds( 7 )), block_from_the_future,
                     "received a block from the future, ignoring it: ${id}", ("id", id) );
 
         /* de-dupe here... no point in aborting block if we already know the block */
         auto existing = chain.fetch_block_by_id( id );
         if( existing ) { return false; }
 
         // start processing of block
         std::future<block_state_ptr> bsf;
         if( !bsp ) {
            bsf = chain.create_block_state_future( id, block );
         }
 
         // abort the pending block
         abort_block();
 
         // push the new block
         auto handle_error = [&](const auto& e)
         {
            elog((e.to_detail_string()));
            app().get_channel<channels::rejected_block>().publish( priority::medium, block );
            throw;
         };
 
         try {
            const block_state_ptr& bspr = bsp ? bsp : bsf.get();
            chain.push_block( bspr, [this]( const branch_type& forked_branch ) {
               _unapplied_transactions.add_forked( forked_branch );
            }, [this]( const transaction_id_type& id ) {
               return _unapplied_transactions.get_trx( id );
            } );
         } catch ( const guard_exception& e ) {
            chain_plugin::handle_guard_exception(e);
            return false;
         } catch ( const std::bad_alloc& ) {
            chain_plugin::handle_bad_alloc();
         } catch ( boost::interprocess::bad_alloc& ) {
            chain_plugin::handle_db_exhaustion();
         } catch ( const fork_database_exception& e ) {
            elog("Cannot recover from ${e}. Shutting down.", ("e", e.to_detail_string()));
            appbase::app().quit();
         } catch( const fc::exception& e ) {
            handle_error(e);
         } catch (const std::exception& e) {
            handle_error(fc::std_exception_wrapper::from_current_exception(e));
         }
 
         const auto& hbs = chain.head_block_state();
         if( hbs->header.timestamp.next().to_time_point() >= fc::time_point::now() ) {
            _production_enabled = true;
         }
 
         if( fc::time_point::now() - block->timestamp < fc::minutes(5) || (blk_num % 1000 == 0) ) {
            ilog("Received block ${id}... #${n} @ ${t} signed by ${p} [trxs: ${count}, lib: ${lib}, conf: ${confs}, latency: ${latency} ms]",
                 ("p",block->producer)("id",id.str().substr(8,16))("n",blk_num)("t",block->timestamp)
                 ("count",block->transactions.size())("lib",chain.last_irreversible_block_num())
                 ("confs", block->confirmed)("latency", (fc::time_point::now() - block->timestamp).count()/1000 ) );
            if( chain.get_read_mode() != db_read_mode::IRREVERSIBLE && hbs->id != id && hbs->block != nullptr ) { // not applied to head
               ilog("Block not applied to head ${id}... #${n} @ ${t} signed by ${p} [trxs: ${count}, dpos: ${dpos}, conf: ${confs}, latency: ${latency} ms]",
                    ("p",hbs->block->producer)("id",hbs->id.str().substr(8,16))("n",hbs->block_num)("t",hbs->block->timestamp)
                    ("count",hbs->block->transactions.size())("dpos", hbs->dpos_irreversible_blocknum)
                    ("confs", hbs->block->confirmed)("latency", (fc::time_point::now() - hbs->block->timestamp).count()/1000 ) );
            }
         }
 
         return true;
      }

Here is the call graph for this function:

on_incoming_transaction_async()

void sysio::producer_plugin_impl::on_incoming_transaction_async ( const packed_transaction_ptr & trx, bool persist_until_expired, bool read_only, bool return_failure_traces, next_function< transaction_trace_ptr > next )

inline

Definition at line 528 of file producer_plugin.cpp.

                                                                                    {
         chain::controller& chain = chain_plug->chain();
         const auto max_trx_time_ms = _max_transaction_time_ms.load();
         fc::microseconds max_trx_cpu_usage = max_trx_time_ms < 0 ? fc::microseconds::maximum() : fc::milliseconds( max_trx_time_ms );
 
         auto future = transaction_metadata::start_recover_keys( trx, _thread_pool->get_executor(),
                                                                 chain.get_chain_id(), fc::microseconds( max_trx_cpu_usage ),
                                                                 read_only ? transaction_metadata::trx_type::read_only : transaction_metadata::trx_type::input,
                                                                 chain.configured_subjective_signature_length_limit() );
 
         boost::asio::post(_thread_pool->get_executor(), [self = this, future{std::move(future)}, persist_until_expired, return_failure_traces,
                                                          next{std::move(next)}, trx]() mutable {
            if( future.valid() ) {
               future.wait();
               app().post( priority::low, [self, future{std::move(future)}, persist_until_expired, next{std::move( next )}, trx{std::move(trx)}, return_failure_traces]() mutable {
                  auto exception_handler = [self, &next, trx{std::move(trx)}](fc::exception_ptr ex) {
                     fc_dlog(_trx_failed_trace_log, "[TRX_TRACE] Speculative execution is REJECTING tx: ${txid}, auth: ${a} : ${why} ",
                             ("txid", trx->id())("a",trx->get_transaction().first_authorizer())("why",ex->what()));
                     next(ex);
 
                     fc_dlog(_trx_trace_failure_log, "[TRX_TRACE] Speculative execution is REJECTING tx: ${entire_trx}",
                             ("entire_trx", self->chain_plug->get_log_trx(trx->get_transaction())));
                     fc_dlog(_trx_log, "[TRX_TRACE] Speculative execution is REJECTING tx: ${trx}",
                             ("trx", self->chain_plug->get_log_trx(trx->get_transaction())));
                  };
                  try {
                     auto result = future.get();
                     if( !self->process_incoming_transaction_async( result, persist_until_expired, return_failure_traces, next) ) {
                        if( self->_pending_block_mode == pending_block_mode::producing ) {
                           self->schedule_maybe_produce_block( true );
                        } else {
                           self->restart_speculative_block();
                        }
                     }
                  } CATCH_AND_CALL(exception_handler);
               } );
            }
         });
      }

Here is the call graph for this function:

on_irreversible_block()

void sysio::producer_plugin_impl::on_irreversible_block ( const signed_block_ptr & lib )

inline

Definition at line 407 of file producer_plugin.cpp.

                                                                {
         _irreversible_block_time = lib->timestamp.to_time_point();
         const chain::controller& chain = chain_plug->chain();
 
         // promote any pending snapshots
         auto& snapshots_by_height = _pending_snapshot_index.get<by_height>();
         uint32_t lib_height = lib->block_num();
 
         while (!snapshots_by_height.empty() && snapshots_by_height.begin()->get_height() <= lib_height) {
            const auto& pending = snapshots_by_height.begin();
            auto next = pending->next;
 
            try {
               next(pending->finalize(chain));
            } CATCH_AND_CALL(next);
 
            snapshots_by_height.erase(snapshots_by_height.begin());
         }
      }

Here is the call graph for this function:

process_incoming_transaction_async()

bool sysio::producer_plugin_impl::process_incoming_transaction_async ( const transaction_metadata_ptr & trx, bool persist_until_expired, bool return_failure_traces, next_function< transaction_trace_ptr > next )

inline

Definition at line 572 of file producer_plugin.cpp.

                                                                                         {
         bool exhausted = false;
         chain::controller& chain = chain_plug->chain();
 
         auto send_response = [this, &trx, &chain, &next](const std::variant<fc::exception_ptr, transaction_trace_ptr>& response) {
            next(response);
 
            auto get_trace = [&](const std::variant<fc::exception_ptr, transaction_trace_ptr>& response) -> fc::variant {
               if (std::holds_alternative<fc::exception_ptr>(response)) {
                  return fc::variant{std::get<fc::exception_ptr>(response)};
               } else {
                  return chain_plug->get_log_trx_trace( std::get<transaction_trace_ptr>(response) );
               }
 
            };
 
            fc::exception_ptr except_ptr; // rejected
            if (std::holds_alternative<fc::exception_ptr>(response)) {
               except_ptr = std::get<fc::exception_ptr>(response);
            } else if (std::get<transaction_trace_ptr>(response)->except) {
               except_ptr = std::get<transaction_trace_ptr>(response)->except->dynamic_copy_exception();
            }
 
            if (!trx->read_only) {
               _transaction_ack_channel.publish(priority::low, std::pair<fc::exception_ptr, packed_transaction_ptr>(except_ptr, trx->packed_trx()));
            }
 
            if (except_ptr) {
               if (_pending_block_mode == pending_block_mode::producing) {
                  fc_dlog(_trx_failed_trace_log, "[TRX_TRACE] Block ${block_num} for producer ${prod} is REJECTING tx: ${txid}, auth: ${a} : ${why} ",
                        ("block_num", chain.head_block_num() + 1)
                        ("prod", get_pending_block_producer())
                        ("txid", trx->id())
                        ("a", trx->packed_trx()->get_transaction().first_authorizer())
                        ("why", except_ptr->what()));
                  fc_dlog(_trx_log, "[TRX_TRACE] Block ${block_num} for producer ${prod} is REJECTING tx: ${trx}",
                          ("block_num", chain.head_block_num() + 1)("prod", get_pending_block_producer())
                                ("trx", chain_plug->get_log_trx(trx->packed_trx()->get_transaction())));
                  fc_dlog(_trx_trace_failure_log, "[TRX_TRACE] Block ${block_num} for producer ${prod} is REJECTING tx: ${entire_trace}",
                          ("block_num", chain.head_block_num() + 1)("prod", get_pending_block_producer())
                                ("entire_trace", get_trace(response)));
               } else {
                  fc_dlog(_trx_failed_trace_log, "[TRX_TRACE] Speculative execution is REJECTING tx: ${txid}, auth: ${a} : ${why} ",
                          ("txid", trx->id())
                          ("a", trx->packed_trx()->get_transaction().first_authorizer())
                          ("why", except_ptr->what()));
                  fc_dlog(_trx_log, "[TRX_TRACE] Speculative execution is REJECTING tx: ${trx} ",
                          ("trx", chain_plug->get_log_trx(trx->packed_trx()->get_transaction())));
                  fc_dlog(_trx_trace_failure_log, "[TRX_TRACE] Speculative execution is REJECTING tx: ${entire_trace} ",
                          ("entire_trace", get_trace(response)));
               }
            } else {
               if (_pending_block_mode == pending_block_mode::producing) {
                  fc_dlog(_trx_successful_trace_log, "[TRX_TRACE] Block ${block_num} for producer ${prod} is ACCEPTING tx: ${txid}, auth: ${a}, cpu: ${cpu}",
                          ("block_num", chain.head_block_num() + 1)
                          ("prod", get_pending_block_producer())
                          ("txid", trx->id())
                          ("a", trx->packed_trx()->get_transaction().first_authorizer())
                          ("cpu", trx->billed_cpu_time_us));
                  fc_dlog(_trx_log, "[TRX_TRACE] Block ${block_num} for producer ${prod} is ACCEPTING tx: ${trx}",
                          ("block_num", chain.head_block_num() + 1)("prod", get_pending_block_producer())
                                ("trx", chain_plug->get_log_trx(trx->packed_trx()->get_transaction())));
                   fc_dlog(_trx_trace_success_log, "[TRX_TRACE] Block ${block_num} for producer ${prod} is ACCEPTING tx: ${entire_trace}",
                           ("block_num", chain.head_block_num() + 1)("prod", get_pending_block_producer())
                                   ("entire_trace", get_trace(response)));
               } else {
                  fc_dlog(_trx_successful_trace_log, "[TRX_TRACE] Speculative execution is ACCEPTING tx: ${txid}, auth: ${a}, cpu: ${cpu}",
                          ("txid", trx->id())
                          ("a", trx->packed_trx()->get_transaction().first_authorizer())
                          ("cpu", trx->billed_cpu_time_us));
                   fc_dlog(_trx_trace_success_log, "[TRX_TRACE] Speculative execution is ACCEPTING tx: ${entire_trace}",
                           ("entire_trace", get_trace(response)));
                  fc_dlog(_trx_log, "[TRX_TRACE] Speculative execution is ACCEPTING tx: ${trx}",
                          ("trx", chain_plug->get_log_trx(trx->packed_trx()->get_transaction())));
               }
            }
         };
 
         try {
            const auto& id = trx->id();
 
            fc::time_point bt = chain.is_building_block() ? chain.pending_block_time() : chain.head_block_time();
            const fc::time_point expire = trx->packed_trx()->expiration();
            if( expire < bt ) {
               send_response( std::static_pointer_cast<fc::exception>(
                     std::make_shared<expired_tx_exception>(
                           FC_LOG_MESSAGE( error, "expired transaction ${id}, expiration ${e}, block time ${bt}",
                                           ("id", id)("e", expire)( "bt", bt )))));
               return true;
            }
 
            if( chain.is_known_unexpired_transaction( id )) {
               send_response( std::static_pointer_cast<fc::exception>( std::make_shared<tx_duplicate>(
                     FC_LOG_MESSAGE( error, "duplicate transaction ${id}", ("id", id)))) );
               return true;
            }
 
            if( !chain.is_building_block()) {
               _unapplied_transactions.add_incoming( trx, persist_until_expired, return_failure_traces, next );
               return true;
            }
 
            auto first_auth = trx->packed_trx()->get_transaction().first_authorizer();
            if( _account_fails.failure_limit( first_auth ) ) {
               send_response( std::static_pointer_cast<fc::exception>( std::make_shared<tx_cpu_usage_exceeded>(
                     FC_LOG_MESSAGE( error, "transaction ${id} exceeded failure limit for account ${a}",
                                     ("id", trx->id())("a", first_auth) ) ) ) );
               return true;
            }
 
            auto start = fc::time_point::now();
            fc::microseconds max_trx_time = fc::milliseconds( _max_transaction_time_ms.load() );
            if( max_trx_time.count() < 0 ) max_trx_time = fc::microseconds::maximum();
            const auto block_deadline = calculate_block_deadline( chain.pending_block_time() );
 
            bool disable_subjective_billing = ( _pending_block_mode == pending_block_mode::producing )
                                              || ( persist_until_expired && _disable_subjective_api_billing )
                                              || ( !persist_until_expired && _disable_subjective_p2p_billing )
                                              || trx->read_only;
 
            int64_t sub_bill = 0;
            if( !disable_subjective_billing )
               sub_bill = _subjective_billing.get_subjective_bill( first_auth, fc::time_point::now() );
 
            auto prev_billed_cpu_time_us = trx->billed_cpu_time_us;
            auto trace = chain.push_transaction( trx, block_deadline, max_trx_time, prev_billed_cpu_time_us, false, sub_bill );
            fc_dlog( _trx_failed_trace_log, "Subjective bill for ${a}: ${b} elapsed ${t}us", ("a",first_auth)("b",sub_bill)("t",trace->elapsed));
            if( trace->except ) {
               if( exception_is_exhausted( *trace->except ) ) {
                  _unapplied_transactions.add_incoming( trx, persist_until_expired, return_failure_traces, next );
                  if( _pending_block_mode == pending_block_mode::producing ) {
                     fc_dlog(_trx_failed_trace_log, "[TRX_TRACE] Block ${block_num} for producer ${prod} COULD NOT FIT, tx: ${txid} RETRYING ",
                              ("block_num", chain.head_block_num() + 1)
                              ("prod", get_pending_block_producer())
                              ("txid", trx->id()));
                  } else {
                     fc_dlog(_trx_failed_trace_log, "[TRX_TRACE] Speculative execution COULD NOT FIT tx: ${txid} RETRYING",
                              ("txid", trx->id()));
                  }
                  exhausted = block_is_exhausted();
               } else {
                   if (!disable_subjective_billing)
                      _subjective_billing.subjective_bill_failure( first_auth, trace->elapsed, fc::time_point::now() );
 
                  if( _pending_block_mode == pending_block_mode::producing ) {
                     auto failure_code = trace->except->code();
                     if( failure_code != tx_duplicate::code_value ) {
                        // this failed our configured maximum transaction time, we don't want to replay it
                        fc_dlog( _log, "Failed ${c} trx, prev billed: ${p}us, ran: ${r}us, id: ${id}",
                                 ("c", trace->except->code())( "p", prev_billed_cpu_time_us )
                                 ( "r", fc::time_point::now() - start )( "id", trx->id() ) );
                        _account_fails.add( first_auth, failure_code );
                     }
                  }
                  if( return_failure_traces ) {
                     send_response( trace );
                  } else {
                     auto e_ptr = trace->except->dynamic_copy_exception();
                     send_response( e_ptr );
                  }
               }
            } else {
               if( persist_until_expired && !_disable_persist_until_expired ) {
                  // if this trx didnt fail/soft-fail and the persist flag is set, store its ID so that we can
                  // ensure its applied to all future speculative blocks as well.
                  // No need to subjective bill since it will be re-applied
                  _unapplied_transactions.add_persisted( trx );
               } else {
                  // if db_read_mode SPECULATIVE then trx is in the pending block and not immediately reverted
                  if (!disable_subjective_billing)
                     _subjective_billing.subjective_bill( trx->id(), expire, first_auth, trace->elapsed,
                                                       chain.get_read_mode() == chain::db_read_mode::SPECULATIVE );
               }
               send_response( trace );
            }
 
         } catch ( const guard_exception& e ) {
            chain_plugin::handle_guard_exception(e);
         } catch ( boost::interprocess::bad_alloc& ) {
            chain_plugin::handle_db_exhaustion();
         } catch ( std::bad_alloc& ) {
            chain_plugin::handle_bad_alloc();
         } CATCH_AND_CALL(send_response);
 
         return !exhausted;
      }

Here is the call graph for this function:

Here is the caller graph for this function:

process_incoming_trxs()

bool sysio::producer_plugin_impl::process_incoming_trxs	(	const fc::time_point &	deadline,
		size_t &	pending_incoming_process_limit )

Definition at line 2207 of file producer_plugin.cpp.

{
   bool exhausted = false;
   if( pending_incoming_process_limit ) {
      size_t processed = 0;
      fc_dlog( _log, "Processing ${n} pending transactions", ("n", pending_incoming_process_limit) );
      auto itr = _unapplied_transactions.incoming_begin();
      auto end = _unapplied_transactions.incoming_end();
      while( pending_incoming_process_limit && itr != end ) {
         if ( should_interrupt_start_block( deadline ) ) {
            exhausted = true;
            break;
         }
         --pending_incoming_process_limit;
 
         auto trx_meta = itr->trx_meta;
         auto next = itr->next;
         bool persist_until_expired = itr->trx_type == trx_enum_type::incoming_persisted;
         bool return_failure_trace = itr->return_failure_trace;
         itr = _unapplied_transactions.erase( itr );
         if( !process_incoming_transaction_async( trx_meta, persist_until_expired, return_failure_trace, next ) ) {
            exhausted = true;
            break;
         }
         ++processed;
      }
      fc_dlog( _log, "Processed ${n} pending transactions, ${p} left", ("n", processed)("p", _unapplied_transactions.incoming_size()) );
   }
   return !exhausted;
}

Here is the call graph for this function:

Here is the caller graph for this function:

process_scheduled_and_incoming_trxs()

void sysio::producer_plugin_impl::process_scheduled_and_incoming_trxs	(	const fc::time_point &	deadline,
		size_t &	pending_incoming_process_limit )

Definition at line 2104 of file producer_plugin.cpp.

{
   // scheduled transactions
   int num_applied = 0;
   int num_failed = 0;
   int num_processed = 0;
   bool exhausted = false;
   double incoming_trx_weight = 0.0;
 
   auto& blacklist_by_id = _blacklisted_transactions.get<by_id>();
   chain::controller& chain = chain_plug->chain();
   time_point pending_block_time = chain.pending_block_time();
   auto itr = _unapplied_transactions.incoming_begin();
   auto end = _unapplied_transactions.incoming_end();
   const auto& sch_idx = chain.db().get_index<generated_transaction_multi_index,by_delay>();
   const auto scheduled_trxs_size = sch_idx.size();
   auto sch_itr = sch_idx.begin();
   while( sch_itr != sch_idx.end() ) {
      if( sch_itr->delay_until > pending_block_time) break;    // not scheduled yet
      if( exhausted || deadline <= fc::time_point::now() ) {
         exhausted = true;
         break;
      }
      if( sch_itr->published >= pending_block_time ) {
         ++sch_itr;
         continue; // do not allow schedule and execute in same block
      }
 
      if (blacklist_by_id.find(sch_itr->trx_id) != blacklist_by_id.end()) {
         ++sch_itr;
         continue;
      }
 
      const transaction_id_type trx_id = sch_itr->trx_id; // make copy since reference could be invalidated
      const auto sch_expiration = sch_itr->expiration;
      auto sch_itr_next = sch_itr; // save off next since sch_itr may be invalidated by loop
      ++sch_itr_next;
      const auto next_delay_until = sch_itr_next != sch_idx.end() ? sch_itr_next->delay_until : sch_itr->delay_until;
      const auto next_id = sch_itr_next != sch_idx.end() ? sch_itr_next->id : sch_itr->id;
 
      num_processed++;
 
      // configurable ratio of incoming txns vs deferred txns
      while (incoming_trx_weight >= 1.0 && pending_incoming_process_limit && itr != end ) {
         if (deadline <= fc::time_point::now()) {
            exhausted = true;
            break;
         }
 
         --pending_incoming_process_limit;
         incoming_trx_weight -= 1.0;
 
         auto trx_meta = itr->trx_meta;
         auto next = itr->next;
         bool persist_until_expired = itr->trx_type == trx_enum_type::incoming_persisted;
         bool return_failure_trace = itr->return_failure_trace;
         itr = _unapplied_transactions.erase( itr );
         if( !process_incoming_transaction_async( trx_meta, persist_until_expired, return_failure_trace, next ) ) {
            exhausted = true;
            break;
         }
      }
 
      if (exhausted || deadline <= fc::time_point::now()) {
         exhausted = true;
         break;
      }
 
      try {
         fc::microseconds max_trx_time = fc::milliseconds( _max_transaction_time_ms.load() );
         if( max_trx_time.count() < 0 ) max_trx_time = fc::microseconds::maximum();
 
         auto trace = chain.push_scheduled_transaction(trx_id, deadline, max_trx_time, 0, false);
         if (trace->except) {
            if (exception_is_exhausted(*trace->except)) {
               if( block_is_exhausted() ) {
                  exhausted = true;
                  break;
               }
            } else {
               // this failed our configured maximum transaction time, we don't want to replay it add it to a blacklist
               _blacklisted_transactions.insert(transaction_id_with_expiry{trx_id, sch_expiration});
               num_failed++;
            }
         } else {
            num_applied++;
         }
      } LOG_AND_DROP();
 
      incoming_trx_weight += _incoming_defer_ratio;
      if (!pending_incoming_process_limit) incoming_trx_weight = 0.0;
 
      if( sch_itr_next == sch_idx.end() ) break;
      sch_itr = sch_idx.lower_bound( boost::make_tuple( next_delay_until, next_id ) );
   }
 
   if( scheduled_trxs_size > 0 ) {
      fc_dlog( _log,
               "Processed ${m} of ${n} scheduled transactions, Applied ${applied}, Failed/Dropped ${failed}",
               ( "m", num_processed )( "n", scheduled_trxs_size )( "applied", num_applied )( "failed", num_failed ) );
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

process_unapplied_trxs()

bool sysio::producer_plugin_impl::process_unapplied_trxs

(

const fc::time_point &

deadline

)

Definition at line 2001 of file producer_plugin.cpp.

{
   bool exhausted = false;
   if( !_unapplied_transactions.empty() ) {
      chain::controller& chain = chain_plug->chain();
      const auto& rl = chain.get_resource_limits_manager();
      int num_applied = 0, num_failed = 0, num_processed = 0;
      auto unapplied_trxs_size = _unapplied_transactions.size();
      // unapplied and persisted do not have a next method to call
      auto itr     = (_pending_block_mode == pending_block_mode::producing) ?
                     _unapplied_transactions.unapplied_begin() : _unapplied_transactions.persisted_begin();
      auto end_itr = (_pending_block_mode == pending_block_mode::producing) ?
                     _unapplied_transactions.unapplied_end()   : _unapplied_transactions.persisted_end();
      while( itr != end_itr ) {
         if( should_interrupt_start_block( deadline ) ) {
            exhausted = true;
            break;
         }
 
         const transaction_metadata_ptr trx = itr->trx_meta;
         ++num_processed;
         try {
            auto start = fc::time_point::now();
 
            auto first_auth = trx->packed_trx()->get_transaction().first_authorizer();
            if( _account_fails.failure_limit( first_auth ) ) {
               ++num_failed;
               if( itr->next ) {
                  itr->next( std::make_shared<tx_cpu_usage_exceeded>(
                        FC_LOG_MESSAGE( error, "transaction ${id} exceeded failure limit for account ${a}",
                                        ("id", trx->id())("a", first_auth) ) ) );
               }
               itr = _unapplied_transactions.erase( itr );
               continue;
            }
 
            fc::microseconds max_trx_time = fc::milliseconds( _max_transaction_time_ms.load() );
            if( max_trx_time.count() < 0 ) max_trx_time = fc::microseconds::maximum();
 
            auto prev_billed_cpu_time_us = trx->billed_cpu_time_us;
            if( prev_billed_cpu_time_us > 0 && !_subjective_billing.is_account_disabled( first_auth ) && !rl.is_unlimited_cpu( first_auth )) {
               uint64_t prev_billed_plus100_us = prev_billed_cpu_time_us + SYS_PERCENT( prev_billed_cpu_time_us, 100 * config::percent_1 );
               if( prev_billed_plus100_us < max_trx_time.count() ) max_trx_time = fc::microseconds( prev_billed_plus100_us );
            }
 
            // no subjective billing since we are producing or processing persisted trxs
            const int64_t sub_bill = 0;
            bool disable_subjective_billing = ( _pending_block_mode == pending_block_mode::producing )
               || ( (itr->trx_type == trx_enum_type::persisted) && _disable_subjective_api_billing )
               || ( !(itr->trx_type == trx_enum_type::persisted) && _disable_subjective_p2p_billing )
               || trx->read_only;
 
            auto trace = chain.push_transaction( trx, deadline, max_trx_time, prev_billed_cpu_time_us, false, sub_bill );
            fc_dlog( _trx_failed_trace_log, "Subjective unapplied bill for ${a}: ${b} prev ${t}us", ("a",first_auth)("b",prev_billed_cpu_time_us)("t",trace->elapsed));
            if( trace->except ) {
               if( exception_is_exhausted( *trace->except ) ) {
                  if( block_is_exhausted() ) {
                     exhausted = true;
                     // don't erase, subjective failure so try again next time
                     break;
                  }
               } else {
                  fc_dlog( _trx_failed_trace_log, "Subjective unapplied bill for failed ${a}: ${b} prev ${t}us", ("a",first_auth)("b",prev_billed_cpu_time_us)("t",trace->elapsed));
                  auto failure_code = trace->except->code();
                  if( failure_code != tx_duplicate::code_value ) {
                     // this failed our configured maximum transaction time, we don't want to replay it
                     fc_dlog( _log, "Failed ${c} trx, prev billed: ${p}us, ran: ${r}us, id: ${id}",
                              ("c", trace->except->code())("p", prev_billed_cpu_time_us)
                              ("r", fc::time_point::now() - start)("id", trx->id()) );
                     _account_fails.add( first_auth, failure_code );
                     if (!disable_subjective_billing)
                        _subjective_billing.subjective_bill_failure( first_auth, trace->elapsed, fc::time_point::now() );
                  }
                  ++num_failed;
                  if( itr->next ) {
                     itr->next( trace->except->dynamic_copy_exception() );
                  }
                  itr = _unapplied_transactions.erase( itr );
                  continue;
               }
            } else {
               fc_dlog( _trx_successful_trace_log, "Subjective unapplied bill for success ${a}: ${b} prev ${t}us", ("a",first_auth)("b",prev_billed_cpu_time_us)("t",trace->elapsed));
               // if db_read_mode SPECULATIVE then trx is in the pending block and not immediately reverted
               if (!disable_subjective_billing)
                  _subjective_billing.subjective_bill( trx->id(), trx->packed_trx()->expiration(), first_auth, trace->elapsed,
                                                    chain.get_read_mode() == chain::db_read_mode::SPECULATIVE );
               ++num_applied;
               if( itr->trx_type != trx_enum_type::persisted ) {
                  if( itr->next ) itr->next( trace );
                  itr = _unapplied_transactions.erase( itr );
                  continue;
               }
            }
         } LOG_AND_DROP();
         ++itr;
      }
 
      fc_dlog( _log, "Processed ${m} of ${n} previously applied transactions, Applied ${applied}, Failed/Dropped ${failed}",
               ("m", num_processed)( "n", unapplied_trxs_size )("applied", num_applied)("failed", num_failed) );
   }
   return !exhausted;
}

Here is the call graph for this function:

Here is the caller graph for this function:

produce_block()

void sysio::producer_plugin_impl::produce_block

(

)

S-ROOT HEADER EXTENSION

Definition at line 2402 of file producer_plugin.cpp.

                                         {
   //ilog("produce_block ${t}", ("t", fc::time_point::now())); // for testing _produce_time_offset_us
   SYS_ASSERT(_pending_block_mode == pending_block_mode::producing, producer_exception, "called produce_block while not actually producing");
   chain::controller& chain = chain_plug->chain();
   SYS_ASSERT(chain.is_building_block(), missing_pending_block_state, "pending_block_state does not exist but it should, another plugin may have corrupted it");
 
   const auto& auth = chain.pending_block_signing_authority();
   std::vector<std::reference_wrapper<const signature_provider_type>> relevant_providers;
 
   relevant_providers.reserve(_signature_providers.size());
 
   producer_authority::for_each_key(auth, [&](const public_key_type& key){
      const auto& iter = _signature_providers.find(key);
      if (iter != _signature_providers.end()) {
         relevant_providers.emplace_back(iter->second);
      }
   });
 
   SYS_ASSERT(relevant_providers.size() > 0, producer_priv_key_not_found, "Attempting to produce a block for which we don't have any relevant private keys");
 
   if (_protocol_features_signaled) {
      _protocol_features_to_activate.clear(); // clear _protocol_features_to_activate as it is already set in pending_block
      _protocol_features_signaled = false;
   }
 
   auto& sub_chain_plug = app().get_plugin<sub_chain_plugin>();
   // TODO: verify sub chain is enabled, otherwise skip? or require?
   // Step 1: Scans transactions to find relevant transactions by comparing to a list of known contracts.
   auto relevant_s_transactions = sub_chain_plug.find_relevant_transactions(chain);
   // Only calculate if there are relevant s-transactions   
   if (!relevant_s_transactions.empty()) {
      ilog("Relevant S-Transactions found: ${count}", ("count", relevant_s_transactions.size()));
      // Step 2: Builds array of leaves in the same order as they appear in the transaction list.
      // Step 3: Computes a Merkle root hash: the S-Root.
      checksum256_type s_root = sub_chain_plug.calculate_s_root(relevant_s_transactions);
      ilog("s_root calculated: ${root}", ("root", s_root.str()));
      // Step 4: S-Root is hashed with the previous S-ID using SHA-256
      // Step 5: Takes the 32 least-significant bits from the previous S-ID to get the previous S-Block number, and increment to get the new S-Block number
      // Step 6: Hashes the S-Root with the previous S-ID with SHA-256, then replace the 32 least significant bits with the new S-Block number to produce the new S-ID
      checksum256_type curr_s_id = sub_chain_plug.compute_curr_s_id(s_root);
      ilog("curr_s_id calculated: ${curr_s_id}", ("curr_s_id", curr_s_id.str()));
      // Prepare the s_header for the current block to be added to the header extension
      s_header s_header {
         sub_chain_plug.get_contract_name(),
         sub_chain_plug.get_prev_s_id(),
         curr_s_id,
         s_root
      };
      ilog("S-Header prepared: ${s_header}", ("s_header", s_header.to_string()));
 
      // Set the s_root in the chain controller for the building block state
      // to be referenced and passed to make_block_header on finalize_block below
      chain.set_s_header( s_header );
 
      // Update the plugin's stored prev_s_id with the newly calculated S-ID
      sub_chain_plug.update_prev_s_id(curr_s_id);
   }
 
   //idump( (fc::time_point::now() - chain.pending_block_time()) );
   chain.finalize_block( [&]( const digest_type& d ) {
      auto debug_logger = maybe_make_debug_time_logger();
      vector<signature_type> sigs;
      sigs.reserve(relevant_providers.size());
 
      // sign with all relevant public keys
      for (const auto& p : relevant_providers) {
         sigs.emplace_back(p.get()(d));
      }
      return sigs;
   } );
 
   chain.commit_block();
 
   block_state_ptr new_bs = chain.head_block_state();
 
   _account_fails.report();
   _account_fails.clear();
 
   ilog("Produced block ${id}... #${n} @ ${t} signed by ${p} [trxs: ${count}, lib: ${lib}, confirmed: ${confs}]",
        ("p",new_bs->header.producer)("id",new_bs->id.str().substr(8,16))
        ("n",new_bs->block_num)("t",new_bs->header.timestamp)
        ("count",new_bs->block->transactions.size())("lib",chain.last_irreversible_block_num())("confs", new_bs->header.confirmed));
 
}

Here is the call graph for this function:

Here is the caller graph for this function:

production_disabled_by_policy()

bool sysio::producer_plugin_impl::production_disabled_by_policy ( )

inline

Definition at line 781 of file producer_plugin.cpp.

                                           {
         return !_production_enabled || _pause_production || (_max_irreversible_block_age_us.count() >= 0 && get_irreversible_block_age() >= _max_irreversible_block_age_us);
      }

Here is the caller graph for this function:

remove_expired_blacklisted_trxs()

bool sysio::producer_plugin_impl::remove_expired_blacklisted_trxs

(

const fc::time_point &

deadline

)

Definition at line 1975 of file producer_plugin.cpp.

{
   bool exhausted = false;
   auto& blacklist_by_expiry = _blacklisted_transactions.get<by_expiry>();
   if(!blacklist_by_expiry.empty()) {
      const chain::controller& chain = chain_plug->chain();
      const auto lib_time = chain.last_irreversible_block_time();
 
      int num_expired = 0;
      int orig_count = _blacklisted_transactions.size();
 
      while (!blacklist_by_expiry.empty() && blacklist_by_expiry.begin()->expiry <= lib_time) {
         if ( should_interrupt_start_block( deadline ) ) {
            exhausted = true;
            break;
         }
         blacklist_by_expiry.erase(blacklist_by_expiry.begin());
         num_expired++;
      }
 
      fc_dlog(_log, "Processed ${n} blacklisted transactions, Expired ${expired}",
              ("n", orig_count)("expired", num_expired));
   }
   return !exhausted;
}

Here is the call graph for this function:

Here is the caller graph for this function:

remove_expired_trxs()

bool sysio::producer_plugin_impl::remove_expired_trxs

(

const fc::time_point &

deadline

)

Definition at line 1910 of file producer_plugin.cpp.

{
   chain::controller& chain = chain_plug->chain();
   auto pending_block_time = chain.pending_block_time();
 
   // remove all expired transactions
   size_t num_expired_persistent = 0;
   size_t num_expired_other = 0;
   size_t orig_count = _unapplied_transactions.size();
   bool exhausted = !_unapplied_transactions.clear_expired( pending_block_time, [&](){ return should_interrupt_start_block( deadline ); },
                  [chain_plug = chain_plug, &num_expired_persistent, &num_expired_other, pbm = _pending_block_mode,
                   &chain, has_producers = !_producers.empty()]( const packed_transaction_ptr& packed_trx_ptr, trx_enum_type trx_type ) {
            if( trx_type == trx_enum_type::persisted ) {
               if( pbm == pending_block_mode::producing ) {
                  fc_dlog(_trx_failed_trace_log,
                           "[TRX_TRACE] Block ${block_num} for producer ${prod} is EXPIRING PERSISTED tx: ${txid}",
                           ("block_num", chain.head_block_num() + 1)("txid", packed_trx_ptr->id())
                           ("prod", chain.is_building_block() ? chain.pending_block_producer() : name()) );
                  fc_dlog(_trx_log, "[TRX_TRACE] Block ${block_num} for producer ${prod} is EXPIRING PERSISTED tx: ${trx}",
                          ("block_num", chain.head_block_num() + 1)
                                ("prod", chain.is_building_block() ? chain.pending_block_producer() : name())
                                ("trx", chain_plug->get_log_trx(packed_trx_ptr->get_transaction())));
                  fc_dlog(_trx_trace_failure_log, "[TRX_TRACE] Block ${block_num} for producer ${prod} is EXPIRING PERSISTED tx: ${entire_trx}",
                          ("block_num", chain.head_block_num() + 1)
                                ("prod", chain.is_building_block() ? chain.pending_block_producer() : name())
                                ("entire_trx", chain_plug->get_log_trx(packed_trx_ptr->get_transaction())));
 
               } else {
                  fc_dlog(_trx_failed_trace_log, "[TRX_TRACE] Speculative execution is EXPIRING PERSISTED tx: ${txid}", ("txid", packed_trx_ptr->id()));
 
                  fc_dlog(_trx_log, "[TRX_TRACE] Speculative execution is EXPIRING PERSISTED tx: ${trx}",
                          ("trx", chain_plug->get_log_trx(packed_trx_ptr->get_transaction())));
                  fc_dlog(_trx_trace_failure_log, "[TRX_TRACE] Speculative execution is EXPIRING PERSISTED tx: ${entire_trx}",
                          ("entire_trx", chain_plug->get_log_trx(packed_trx_ptr->get_transaction())));
               }
               ++num_expired_persistent;
            } else {
               if (has_producers) {
                  fc_dlog(_trx_failed_trace_log,
                        "[TRX_TRACE] Node with producers configured is dropping an EXPIRED transaction that was PREVIOUSLY ACCEPTED : ${txid}",
                        ("txid", packed_trx_ptr->id()));
 
                  fc_dlog(_trx_log, "[TRX_TRACE] Node with producers configured is dropping an EXPIRED transaction that was PREVIOUSLY ACCEPTED: ${trx}",
                          ("trx", chain_plug->get_log_trx(packed_trx_ptr->get_transaction())));
                  fc_dlog(_trx_trace_failure_log, "[TRX_TRACE] Node with producers configured is dropping an EXPIRED transaction that was PREVIOUSLY ACCEPTED: ${entire_trx}",
                          ("entire_trx", chain_plug->get_log_trx(packed_trx_ptr->get_transaction())));
               }
               ++num_expired_other;
            }
   });
 
   if( exhausted && _pending_block_mode == pending_block_mode::producing ) {
      fc_wlog( _log, "Unable to process all expired transactions in unapplied queue before deadline, "
                     "Persistent expired ${persistent_expired}, Other expired ${other_expired}",
               ("persistent_expired", num_expired_persistent)("other_expired", num_expired_other) );
   } else {
      fc_dlog( _log, "Processed ${m} expired transactions of the ${n} transactions in the unapplied queue, "
                     "Persistent expired ${persistent_expired}, Other expired ${other_expired}",
               ("m", num_expired_persistent+num_expired_other)("n", orig_count)
               ("persistent_expired", num_expired_persistent)("other_expired", num_expired_other) );
   }
 
   return !exhausted;
}

Here is the call graph for this function:

Here is the caller graph for this function:

restart_speculative_block()

void sysio::producer_plugin_impl::restart_speculative_block ( )

inline

Definition at line 520 of file producer_plugin.cpp.

                                       {
         chain::controller& chain = chain_plug->chain();
         // abort the pending block
         _unapplied_transactions.add_aborted( chain.abort_block() );
 
         schedule_production_loop();
      }

Here is the call graph for this function:

schedule_delayed_production_loop()

void sysio::producer_plugin_impl::schedule_delayed_production_loop	(	const std::weak_ptr< producer_plugin_impl > &	weak_this,
		std::optional< fc::time_point >	wake_up_time )

Definition at line 2356 of file producer_plugin.cpp.

                                                                                                                                                      {
   if (wake_up_time) {
      fc_dlog(_log, "Scheduling Speculative/Production Change at ${time}", ("time", wake_up_time));
      static const boost::posix_time::ptime epoch(boost::gregorian::date(1970, 1, 1));
      _timer.expires_at(epoch + boost::posix_time::microseconds(wake_up_time->time_since_epoch().count()));
      _timer.async_wait( app().get_priority_queue().wrap( priority::high,
         [weak_this,cid=++_timer_corelation_id](const boost::system::error_code& ec) {
            auto self = weak_this.lock();
            if( self && ec != boost::asio::error::operation_aborted && cid == self->_timer_corelation_id ) {
               self->schedule_production_loop();
            }
         } ) );
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

schedule_maybe_produce_block()

void sysio::producer_plugin_impl::schedule_maybe_produce_block

(

bool

exhausted

)

Definition at line 2298 of file producer_plugin.cpp.

                                                                        {
   chain::controller& chain = chain_plug->chain();
 
   // we succeeded but block may be exhausted
   static const boost::posix_time::ptime epoch( boost::gregorian::date( 1970, 1, 1 ) );
   auto deadline = calculate_block_deadline( chain.pending_block_time() );
 
   if( !exhausted && deadline > fc::time_point::now() ) {
      // ship this block off no later than its deadline
      SYS_ASSERT( chain.is_building_block(), missing_pending_block_state,
                  "producing without pending_block_state, start_block succeeded" );
      _timer.expires_at( epoch + boost::posix_time::microseconds( deadline.time_since_epoch().count() ) );
      fc_dlog( _log, "Scheduling Block Production on Normal Block #${num} for ${time}",
               ("num", chain.head_block_num() + 1)( "time", deadline ) );
   } else {
      SYS_ASSERT( chain.is_building_block(), missing_pending_block_state, "producing without pending_block_state" );
      _timer.expires_from_now( boost::posix_time::microseconds( 0 ) );
      fc_dlog( _log, "Scheduling Block Production on ${desc} Block #${num} immediately",
               ("num", chain.head_block_num() + 1)("desc", block_is_exhausted() ? "Exhausted" : "Deadline exceeded") );
   }
 
   _timer.async_wait( app().get_priority_queue().wrap( priority::high,
         [&chain, weak_this = weak_from_this(), cid=++_timer_corelation_id](const boost::system::error_code& ec) {
            auto self = weak_this.lock();
            if( self && ec != boost::asio::error::operation_aborted && cid == self->_timer_corelation_id ) {
               // pending_block_state expected, but can't assert inside async_wait
               auto block_num = chain.is_building_block() ? chain.head_block_num() + 1 : 0;
               fc_dlog( _log, "Produce block timer for ${num} running at ${time}", ("num", block_num)("time", fc::time_point::now()) );
               auto res = self->maybe_produce_block();
               fc_dlog( _log, "Producing Block #${num} returned: ${res}", ("num", block_num)( "res", res ) );
            }
         } ) );
}

Here is the call graph for this function:

Here is the caller graph for this function:

schedule_production_loop()

void sysio::producer_plugin_impl::schedule_production_loop

(

)

Definition at line 2255 of file producer_plugin.cpp.

                                                    {
   _received_block = false;
   _timer.cancel();
 
   auto result = start_block();
 
   if (result == start_block_result::failed) {
      elog("Failed to start a pending block, will try again later");
      _timer.expires_from_now( boost::posix_time::microseconds( config::block_interval_us  / 10 ));
 
      // we failed to start a block, so try again later?
      _timer.async_wait( app().get_priority_queue().wrap( priority::high,
          [weak_this = weak_from_this(), cid = ++_timer_corelation_id]( const boost::system::error_code& ec ) {
             auto self = weak_this.lock();
             if( self && ec != boost::asio::error::operation_aborted && cid == self->_timer_corelation_id ) {
                self->schedule_production_loop();
             }
          } ) );
   } else if (result == start_block_result::waiting_for_block){
      if (!_producers.empty() && !production_disabled_by_policy()) {
         fc_dlog(_log, "Waiting till another block is received and scheduling Speculative/Production Change");
         schedule_delayed_production_loop(weak_from_this(), calculate_producer_wake_up_time(calculate_pending_block_time()));
      } else {
         fc_dlog(_log, "Waiting till another block is received");
         // nothing to do until more blocks arrive
      }
 
   } else if (result == start_block_result::waiting_for_production) {
      // scheduled in start_block()
 
   } else if (_pending_block_mode == pending_block_mode::producing) {
      schedule_maybe_produce_block( result == start_block_result::exhausted );
 
   } else if (_pending_block_mode == pending_block_mode::speculating && !_producers.empty() && !production_disabled_by_policy()){
      chain::controller& chain = chain_plug->chain();
      fc_dlog(_log, "Speculative Block Created; Scheduling Speculative/Production Change");
      SYS_ASSERT( chain.is_building_block(), missing_pending_block_state, "speculating without pending_block_state" );
      schedule_delayed_production_loop(weak_from_this(), calculate_producer_wake_up_time(chain.pending_block_time()));
   } else {
      fc_dlog(_log, "Speculative Block Created");
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

should_interrupt_start_block()

bool sysio::producer_plugin_impl::should_interrupt_start_block ( const fc::time_point & deadline ) const

inline

Definition at line 1674 of file producer_plugin.cpp.

                                                                                            {
   if( _pending_block_mode == pending_block_mode::producing ) {
      return deadline <= fc::time_point::now();
   }
   // if we can produce then honor deadline so production starts on time
   return (!_producers.empty() && deadline <= fc::time_point::now()) || _received_block;
}

Here is the call graph for this function:

Here is the caller graph for this function:

start_block()

producer_plugin_impl::start_block_result sysio::producer_plugin_impl::start_block

(

)

Definition at line 1682 of file producer_plugin.cpp.

                                                                         {
   chain::controller& chain = chain_plug->chain();
 
   if( !chain_plug->accept_transactions() )
      return start_block_result::waiting_for_block;
 
   const auto& hbs = chain.head_block_state();
 
   if( chain.get_terminate_at_block() > 0 && chain.get_terminate_at_block() < chain.head_block_num() ) {
      ilog("Reached configured maximum block ${num}; terminating", ("num", chain.get_terminate_at_block()));
      app().quit();
      return start_block_result::failed;
   }
 
   const fc::time_point now = fc::time_point::now();
   const fc::time_point block_time = calculate_pending_block_time();
   const fc::time_point preprocess_deadline = calculate_block_deadline(block_time);
 
   const pending_block_mode previous_pending_mode = _pending_block_mode;
   _pending_block_mode = pending_block_mode::producing;
 
   // Not our turn
   const auto& scheduled_producer = hbs->get_scheduled_producer(block_time);
 
   const auto current_watermark = get_watermark(scheduled_producer.producer_name);
 
   size_t num_relevant_signatures = 0;
   scheduled_producer.for_each_key([&](const public_key_type& key){
      const auto& iter = _signature_providers.find(key);
      if(iter != _signature_providers.end()) {
         num_relevant_signatures++;
      }
   });
 
   auto irreversible_block_age = get_irreversible_block_age();
 
   // If the next block production opportunity is in the present or future, we're synced.
   if( !_production_enabled ) {
      _pending_block_mode = pending_block_mode::speculating;
   } else if( _producers.find(scheduled_producer.producer_name) == _producers.end()) {
      _pending_block_mode = pending_block_mode::speculating;
   } else if (num_relevant_signatures == 0) {
      elog("Not producing block because I don't have any private keys relevant to authority: ${authority}", ("authority", scheduled_producer.authority));
      _pending_block_mode = pending_block_mode::speculating;
   } else if ( _pause_production ) {
      elog("Not producing block because production is explicitly paused");
      _pending_block_mode = pending_block_mode::speculating;
   } else if ( _max_irreversible_block_age_us.count() >= 0 && irreversible_block_age >= _max_irreversible_block_age_us ) {
      elog("Not producing block because the irreversible block is too old [age:${age}s, max:${max}s]", ("age", irreversible_block_age.count() / 1'000'000)( "max", _max_irreversible_block_age_us.count() / 1'000'000 ));
      _pending_block_mode = pending_block_mode::speculating;
   }
 
   if (_pending_block_mode == pending_block_mode::producing) {
      // determine if our watermark excludes us from producing at this point
      if (current_watermark) {
         const block_timestamp_type block_timestamp{block_time};
         if (current_watermark->first > hbs->block_num) {
            elog("Not producing block because \"${producer}\" signed a block at a higher block number (${watermark}) than the current fork's head (${head_block_num})",
                 ("producer", scheduled_producer.producer_name)
                 ("watermark", current_watermark->first)
                 ("head_block_num", hbs->block_num));
            _pending_block_mode = pending_block_mode::speculating;
         } else if (current_watermark->second >= block_timestamp) {
            elog("Not producing block because \"${producer}\" signed a block at the next block time or later (${watermark}) than the pending block time (${block_timestamp})",
                 ("producer", scheduled_producer.producer_name)
                 ("watermark", current_watermark->second)
                 ("block_timestamp", block_timestamp));
            _pending_block_mode = pending_block_mode::speculating;
         }
      }
   }
 
   if (_pending_block_mode == pending_block_mode::speculating) {
      auto head_block_age = now - chain.head_block_time();
      if (head_block_age > fc::seconds(5))
         return start_block_result::waiting_for_block;
   }
 
   if (_pending_block_mode == pending_block_mode::producing) {
      const auto start_block_time = block_time - fc::microseconds( config::block_interval_us );
      if( now < start_block_time ) {
         fc_dlog(_log, "Not producing block waiting for production window ${n} ${bt}", ("n", hbs->block_num + 1)("bt", block_time) );
         // start_block_time instead of block_time because schedule_delayed_production_loop calculates next block time from given time
         schedule_delayed_production_loop(weak_from_this(), calculate_producer_wake_up_time(start_block_time));
         return start_block_result::waiting_for_production;
      }
   } else if (previous_pending_mode == pending_block_mode::producing) {
      // just produced our last block of our round
      const auto start_block_time = block_time - fc::microseconds( config::block_interval_us );
      fc_dlog(_log, "Not starting speculative block until ${bt}", ("bt", start_block_time) );
      schedule_delayed_production_loop( weak_from_this(), start_block_time);
      return start_block_result::waiting_for_production;
   }
 
   fc_dlog(_log, "Starting block #${n} at ${time} producer ${p}",
           ("n", hbs->block_num + 1)("time", now)("p", scheduled_producer.producer_name));
 
   try {
      uint16_t blocks_to_confirm = 0;
 
      if (_pending_block_mode == pending_block_mode::producing) {
         // determine how many blocks this producer can confirm
         // 1) if it is not a producer from this node, assume no confirmations (we will discard this block anyway)
         // 2) if it is a producer on this node that has never produced, the conservative approach is to assume no
         //    confirmations to make sure we don't double sign after a crash TODO: make these watermarks durable?
         // 3) if it is a producer on this node where this node knows the last block it produced, safely set it -UNLESS-
         // 4) the producer on this node's last watermark is higher (meaning on a different fork)
         if (current_watermark) {
            auto watermark_bn = current_watermark->first;
            if (watermark_bn < hbs->block_num) {
               blocks_to_confirm = (uint16_t)(std::min<uint32_t>(std::numeric_limits<uint16_t>::max(), (uint32_t)(hbs->block_num - watermark_bn)));
            }
         }
 
         // can not confirm irreversible blocks
         blocks_to_confirm = (uint16_t)(std::min<uint32_t>(blocks_to_confirm, (uint32_t)(hbs->block_num - hbs->dpos_irreversible_blocknum)));
      }
 
      abort_block();
 
      auto features_to_activate = chain.get_preactivated_protocol_features();
      if( _pending_block_mode == pending_block_mode::producing && _protocol_features_to_activate.size() > 0 ) {
         bool drop_features_to_activate = false;
         try {
            chain.validate_protocol_features( _protocol_features_to_activate );
         } 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 ) {
            wlog( "protocol features to activate are no longer all valid: ${details}",
                  ("details",e.to_detail_string()) );
            drop_features_to_activate = true;
         } catch( const std::exception& e ) {
            wlog( "protocol features to activate are no longer all valid: ${details}",
                  ("details",fc::std_exception_wrapper::from_current_exception(e).to_detail_string()) );
            drop_features_to_activate = true;
         }
 
         if( drop_features_to_activate ) {
            _protocol_features_to_activate.clear();
         } else {
            auto protocol_features_to_activate = _protocol_features_to_activate; // do a copy as pending_block might be aborted
            if( features_to_activate.size() > 0 ) {
               protocol_features_to_activate.reserve( protocol_features_to_activate.size()
                                                         + features_to_activate.size() );
               std::set<digest_type> set_of_features_to_activate( protocol_features_to_activate.begin(),
                                                                  protocol_features_to_activate.end() );
               for( const auto& f : features_to_activate ) {
                  auto res = set_of_features_to_activate.insert( f );
                  if( res.second ) {
                     protocol_features_to_activate.push_back( f );
                  }
               }
               features_to_activate.clear();
            }
            std::swap( features_to_activate, protocol_features_to_activate );
            _protocol_features_signaled = true;
            ilog( "signaling activation of the following protocol features in block ${num}: ${features_to_activate}",
                  ("num", hbs->block_num + 1)("features_to_activate", features_to_activate) );
         }
      }
 
      chain.start_block( block_time, blocks_to_confirm, features_to_activate, preprocess_deadline );
   } LOG_AND_DROP();
 
   if( chain.is_building_block() ) {
      const auto& pending_block_signing_authority = chain.pending_block_signing_authority();
 
      if (_pending_block_mode == pending_block_mode::producing && pending_block_signing_authority != scheduled_producer.authority) {
         elog("Unexpected block signing authority, reverting to speculative mode! [expected: \"${expected}\", actual: \"${actual\"", ("expected", scheduled_producer.authority)("actual", pending_block_signing_authority));
         _pending_block_mode = pending_block_mode::speculating;
      }
 
      try {
         _account_fails.clear();
 
         if( !remove_expired_trxs( preprocess_deadline ) )
            return start_block_result::exhausted;
         if( !remove_expired_blacklisted_trxs( preprocess_deadline ) )
            return start_block_result::exhausted;
         if( !_subjective_billing.remove_expired( _log, chain.pending_block_time(), fc::time_point::now(),
                                                  [&](){ return should_interrupt_start_block( preprocess_deadline ); } ) ) {
            return start_block_result::exhausted;
         }
 
         // limit execution of pending incoming to once per block
         size_t pending_incoming_process_limit = _unapplied_transactions.incoming_size();
 
         if( !process_unapplied_trxs( preprocess_deadline ) )
            return start_block_result::exhausted;
 
         if (_pending_block_mode == pending_block_mode::producing) {
            auto scheduled_trx_deadline = preprocess_deadline;
            if (_max_scheduled_transaction_time_per_block_ms >= 0) {
               scheduled_trx_deadline = std::min<fc::time_point>(
                     scheduled_trx_deadline,
                     fc::time_point::now() + fc::milliseconds(_max_scheduled_transaction_time_per_block_ms)
               );
            }
            // may exhaust scheduled_trx_deadline but not preprocess_deadline, exhausted preprocess_deadline checked below
            process_scheduled_and_incoming_trxs( scheduled_trx_deadline, pending_incoming_process_limit );
         }
 
         if( app().is_quiting() ) // db guard exception above in LOG_AND_DROP could have called app().quit()
            return start_block_result::failed;
         if ( should_interrupt_start_block( preprocess_deadline ) || block_is_exhausted() ) {
            return start_block_result::exhausted;
         } else {
            if( !process_incoming_trxs( preprocess_deadline, pending_incoming_process_limit ) )
               return start_block_result::exhausted;
            return start_block_result::succeeded;
         }
 
      } catch ( const guard_exception& e ) {
         chain_plugin::handle_guard_exception(e);
         return start_block_result::failed;
      } catch ( std::bad_alloc& ) {
         chain_plugin::handle_bad_alloc();
      } catch ( boost::interprocess::bad_alloc& ) {
         chain_plugin::handle_db_exhaustion();
      }
 
   }
 
   return start_block_result::failed;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

_accepted_block_connection

std::optional<scoped_connection> sysio::producer_plugin_impl::_accepted_block_connection

Definition at line 355 of file producer_plugin.cpp.

_accepted_block_header_connection

std::optional<scoped_connection> sysio::producer_plugin_impl::_accepted_block_header_connection

Definition at line 356 of file producer_plugin.cpp.

_account_fails

account_failures sysio::producer_plugin_impl::_account_fails {_subjective_billing}

Definition at line 353 of file producer_plugin.cpp.

{_subjective_billing};

_blacklisted_transactions

transaction_id_with_expiry_index sysio::producer_plugin_impl::_blacklisted_transactions

Definition at line 350 of file producer_plugin.cpp.

_disable_persist_until_expired

bool sysio::producer_plugin_impl::_disable_persist_until_expired = false

Definition at line 334 of file producer_plugin.cpp.

_disable_subjective_api_billing

bool sysio::producer_plugin_impl::_disable_subjective_api_billing = true

Definition at line 336 of file producer_plugin.cpp.

_disable_subjective_p2p_billing

bool sysio::producer_plugin_impl::_disable_subjective_p2p_billing = true

Definition at line 335 of file producer_plugin.cpp.

_incoming_block_sync_provider

incoming::methods::block_sync::method_type::handle sysio::producer_plugin_impl::_incoming_block_sync_provider

Definition at line 347 of file producer_plugin.cpp.

_incoming_defer_ratio

double sysio::producer_plugin_impl::_incoming_defer_ratio = 1.0

Definition at line 372 of file producer_plugin.cpp.

_incoming_transaction_async_provider

incoming::methods::transaction_async::method_type::handle sysio::producer_plugin_impl::_incoming_transaction_async_provider

Definition at line 348 of file producer_plugin.cpp.

_irreversible_block_connection

std::optional<scoped_connection> sysio::producer_plugin_impl::_irreversible_block_connection

Definition at line 357 of file producer_plugin.cpp.

_irreversible_block_time

fc::time_point sysio::producer_plugin_impl::_irreversible_block_time

Definition at line 337 of file producer_plugin.cpp.

_kiod_provider_timeout_us

fc::microseconds sysio::producer_plugin_impl::_kiod_provider_timeout_us

Definition at line 338 of file producer_plugin.cpp.

_last_block_time_offset_us

int32_t sysio::producer_plugin_impl::_last_block_time_offset_us = 0

Definition at line 330 of file producer_plugin.cpp.

_max_block_cpu_usage_threshold_us

uint32_t sysio::producer_plugin_impl::_max_block_cpu_usage_threshold_us = 0

Definition at line 331 of file producer_plugin.cpp.

_max_block_net_usage_threshold_bytes

uint32_t sysio::producer_plugin_impl::_max_block_net_usage_threshold_bytes = 0

Definition at line 332 of file producer_plugin.cpp.

_max_irreversible_block_age_us

fc::microseconds sysio::producer_plugin_impl::_max_irreversible_block_age_us

Definition at line 328 of file producer_plugin.cpp.

_max_scheduled_transaction_time_per_block_ms

int32_t sysio::producer_plugin_impl::_max_scheduled_transaction_time_per_block_ms = 0

Definition at line 333 of file producer_plugin.cpp.

_max_transaction_time_ms

std::atomic<int32_t> sysio::producer_plugin_impl::_max_transaction_time_ms

Definition at line 326 of file producer_plugin.cpp.

_options

boost::program_options::variables_map sysio::producer_plugin_impl::_options

Definition at line 312 of file producer_plugin.cpp.

_pause_production

bool sysio::producer_plugin_impl::_pause_production = false

Definition at line 314 of file producer_plugin.cpp.

_pending_block_mode

pending_block_mode sysio::producer_plugin_impl::_pending_block_mode = pending_block_mode::speculating

Definition at line 322 of file producer_plugin.cpp.

_pending_snapshot_index

pending_snapshot_index sysio::producer_plugin_impl::_pending_snapshot_index

Definition at line 351 of file producer_plugin.cpp.

_produce_time_offset_us

int32_t sysio::producer_plugin_impl::_produce_time_offset_us = 0

Definition at line 329 of file producer_plugin.cpp.

_producer_watermarks

std::map<chain::account_name, producer_watermark> sysio::producer_plugin_impl::_producer_watermarks

Definition at line 321 of file producer_plugin.cpp.

_producers

std::set<chain::account_name> sysio::producer_plugin_impl::_producers

Definition at line 318 of file producer_plugin.cpp.

_production_enabled

bool sysio::producer_plugin_impl::_production_enabled = false

Definition at line 313 of file producer_plugin.cpp.

_protocol_features_signaled

bool sysio::producer_plugin_impl::_protocol_features_signaled = false

Definition at line 341 of file producer_plugin.cpp.

_protocol_features_to_activate

std::vector<chain::digest_type> sysio::producer_plugin_impl::_protocol_features_to_activate

Definition at line 340 of file producer_plugin.cpp.

_received_block

std::atomic<bool> sysio::producer_plugin_impl::_received_block {false}

Definition at line 327 of file producer_plugin.cpp.

{false}; // modified by net_plugin thread pool and app thread

_signature_providers

std::map<chain::public_key_type, signature_provider_type> sysio::producer_plugin_impl::_signature_providers

Definition at line 317 of file producer_plugin.cpp.

_snapshots_dir

bfs::path sysio::producer_plugin_impl::_snapshots_dir

Definition at line 375 of file producer_plugin.cpp.

_subjective_billing

subjective_billing sysio::producer_plugin_impl::_subjective_billing

Definition at line 352 of file producer_plugin.cpp.

_thread_pool

std::optional<named_thread_pool> sysio::producer_plugin_impl::_thread_pool

Definition at line 324 of file producer_plugin.cpp.

_timer

boost::asio::deadline_timer sysio::producer_plugin_impl::_timer

Definition at line 319 of file producer_plugin.cpp.

_timer_corelation_id

uint32_t sysio::producer_plugin_impl::_timer_corelation_id = 0

Definition at line 369 of file producer_plugin.cpp.

_transaction_ack_channel

compat::channels::transaction_ack::channel_type& sysio::producer_plugin_impl::_transaction_ack_channel

Definition at line 345 of file producer_plugin.cpp.

_unapplied_transactions

unapplied_transaction_queue sysio::producer_plugin_impl::_unapplied_transactions

Definition at line 323 of file producer_plugin.cpp.

chain_plug

chain_plugin* sysio::producer_plugin_impl::chain_plug = nullptr

Definition at line 343 of file producer_plugin.cpp.

---

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

• plugins/producer_plugin/producer_plugin.cpp