sysio::net_plugin_impl Class Reference

Inheritance diagram for sysio::net_plugin_impl:

Collaboration diagram for sysio::net_plugin_impl:

Public Member Functions
void	update_chain_info ()
std::tuple< uint32_t, uint32_t, uint32_t, block_id_type, block_id_type, block_id_type >	get_chain_info () const
void	start_listen_loop ()
void	on_accepted_block (const block_state_ptr &bs)
void	on_pre_accepted_block (const signed_block_ptr &bs)
void	transaction_ack (const std::pair< fc::exception_ptr, packed_transaction_ptr > &)
void	on_irreversible_block (const block_state_ptr &blk)
void	start_conn_timer (boost::asio::steady_timer::duration du, std::weak_ptr< connection > from_connection)
void	start_expire_timer ()
void	start_monitors ()
void	expire ()
void	connection_monitor (std::weak_ptr< connection > from_connection, bool reschedule)
bool	authenticate_peer (const handshake_message &msg) const
	Determine if a peer is allowed to connect.
chain::public_key_type	get_authentication_key () const
	Retrieve public key used to authenticate with peers.
chain::signature_type	sign_compact (const chain::public_key_type &signer, const fc::sha256 &digest) const
	Returns a signature of the digest using the corresponding private key of the signer.
connection_ptr	find_connection (const string &host) const
string	connect (const string &host)
Peer Timestamps
Time message handling
void	ticker ()
	Peer heartbeat ticker.

Static Public Member Functions
static constexpr uint16_t	to_protocol_version (uint16_t v)

Public Attributes
unique_ptr< tcp::acceptor >	acceptor
std::atomic< uint32_t >	current_connection_id {0}
unique_ptr< sync_manager >	sync_master
unique_ptr< dispatch_manager >	dispatcher
std::shared_mutex	connections_mtx
std::set< connection_ptr >	connections
std::mutex	connector_check_timer_mtx
unique_ptr< boost::asio::steady_timer >	connector_check_timer
int	connector_checks_in_flight {0}
std::mutex	expire_timer_mtx
unique_ptr< boost::asio::steady_timer >	expire_timer
std::mutex	keepalive_timer_mtx
unique_ptr< boost::asio::steady_timer >	keepalive_timer
std::atomic< bool >	in_shutdown {false}
compat::channels::transaction_ack::channel_type::handle	incoming_transaction_ack_subscription
uint16_t	thread_pool_size = 2
std::optional< sysio::chain::named_thread_pool >	thread_pool
enum	possible_connections : char { None = 0 , Producers = 1 << 0 , Specified = 1 << 1 , Any = 1 << 2 }
string	p2p_address
string	p2p_server_address
vector< string >	supplied_peers
vector< chain::public_key_type >	allowed_peers
	peer keys allowed to connect
std::map< chain::public_key_type, chain::private_key_type >	private_keys
	overlapping with producer keys, also authenticating non-producing nodes
possible_connections	allowed_connections {None}
boost::asio::steady_timer::duration	connector_period {0}
boost::asio::steady_timer::duration	txn_exp_period {0}
boost::asio::steady_timer::duration	resp_expected_period {0}
std::chrono::milliseconds	keepalive_interval {std::chrono::milliseconds{def_keepalive_interval}}
std::chrono::milliseconds	heartbeat_timeout {keepalive_interval * 2}
int	max_cleanup_time_ms = 0
uint32_t	max_client_count = 0
uint32_t	max_nodes_per_host = 1
bool	p2p_accept_transactions = true
fc::microseconds	p2p_dedup_cache_expire_time_us {}
const std::chrono::system_clock::duration	peer_authentication_interval {std::chrono::seconds{1}}
	Peer clock may be no more than 1 second skewed from our clock, including network latency.
chain_id_type	chain_id
fc::sha256	node_id
string	user_agent_name
chain_plugin *	chain_plug = nullptr
producer_plugin *	producer_plug = nullptr
bool	use_socket_read_watermark = false

Detailed Description

Definition at line 218 of file net_plugin.cpp.

Member Enumeration Documentation

possible_connections

enum sysio::net_plugin_impl::possible_connections : char

Enumerator
None
Producers
Specified
Any

Definition at line 237 of file net_plugin.cpp.

                                : char {
         None = 0,
            Producers = 1 << 0,
            Specified = 1 << 1,
            Any = 1 << 2
            };

Member Function Documentation

authenticate_peer()

bool sysio::net_plugin_impl::authenticate_peer

(

const handshake_message &

msg

)

const

Checks current connection mode and key authentication.

Returns

False if the peer should not connect, true otherwise.

Definition at line 3438 of file net_plugin.cpp.

                                                                             {
      if(allowed_connections == None)
         return false;
 
      if(allowed_connections == Any)
         return true;
 
      if(allowed_connections & (Producers | Specified)) {
         auto allowed_it = std::find(allowed_peers.begin(), allowed_peers.end(), msg.key);
         auto private_it = private_keys.find(msg.key);
         bool found_producer_key = false;
         if(producer_plug != nullptr)
            found_producer_key = producer_plug->is_producer_key(msg.key);
         if( allowed_it == allowed_peers.end() && private_it == private_keys.end() && !found_producer_key) {
            fc_elog( logger, "Peer ${peer} sent a handshake with an unauthorized key: ${key}.",
                     ("peer", msg.p2p_address)("key", msg.key) );
            return false;
         }
      }
 
      if(msg.sig != chain::signature_type() && msg.token != sha256()) {
         sha256 hash = fc::sha256::hash(msg.time);
         if(hash != msg.token) {
            fc_elog( logger, "Peer ${peer} sent a handshake with an invalid token.", ("peer", msg.p2p_address) );
            return false;
         }
         chain::public_key_type peer_key;
         try {
            peer_key = crypto::public_key(msg.sig, msg.token, true);
         }
         catch (const std::exception& /*e*/) {
            fc_elog( logger, "Peer ${peer} sent a handshake with an unrecoverable key.", ("peer", msg.p2p_address) );
            return false;
         }
         if((allowed_connections & (Producers | Specified)) && peer_key != msg.key) {
            fc_elog( logger, "Peer ${peer} sent a handshake with an unauthenticated key.", ("peer", msg.p2p_address) );
            return false;
         }
      }
      else if(allowed_connections & (Producers | Specified)) {
         fc_dlog( logger, "Peer sent a handshake with blank signature and token, but this node accepts only authenticated connections." );
         return false;
      }
      return true;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

connect()

string sysio::net_plugin_impl::connect

(

const string &

host

)

Definition at line 3856 of file net_plugin.cpp.

                                                       {
      std::lock_guard<std::shared_mutex> g( connections_mtx );
      if( find_connection( host ) )
         return "already connected";
 
      connection_ptr c = std::make_shared<connection>( host );
      fc_dlog( logger, "calling active connector: ${h}", ("h", host) );
      if( c->resolve_and_connect() ) {
         fc_dlog( logger, "adding new connection to the list: ${host} ${cid}", ("host", host)("cid", c->connection_id) );
         c->set_heartbeat_timeout( heartbeat_timeout );
         connections.insert( c );
      }
      return "added connection";
   }

Here is the call graph for this function:

connection_monitor()

void sysio::net_plugin_impl::connection_monitor	(	std::weak_ptr< connection >	from_connection,
		bool	reschedule )

Definition at line 3332 of file net_plugin.cpp.

                                                                                                     {
      auto max_time = fc::time_point::now();
      max_time += fc::milliseconds(max_cleanup_time_ms);
      auto from = from_connection.lock();
      std::unique_lock<std::shared_mutex> g( connections_mtx );
      auto it = (from ? connections.find(from) : connections.begin());
      if (it == connections.end()) it = connections.begin();
      size_t num_rm = 0, num_clients = 0, num_peers = 0;
      while (it != connections.end()) {
         if (fc::time_point::now() >= max_time) {
            connection_wptr wit = *it;
            g.unlock();
            fc_dlog( logger, "Exiting connection monitor early, ran out of time: ${t}", ("t", max_time - fc::time_point::now()) );
            fc_ilog( logger, "p2p client connections: ${num}/${max}, peer connections: ${pnum}/${pmax}",
                     ("num", num_clients)("max", max_client_count)("pnum", num_peers)("pmax", supplied_peers.size()) );
            if( reschedule ) {
               start_conn_timer( std::chrono::milliseconds( 1 ), wit ); // avoid exhausting
            }
            return;
         }
         (*it)->peer_address().empty() ? ++num_clients : ++num_peers;
         if( !(*it)->socket_is_open() && !(*it)->connecting) {
            if( !(*it)->peer_address().empty() ) {
               if( !(*it)->resolve_and_connect() ) {
                  it = connections.erase(it);
                  --num_peers; ++num_rm;
                  continue;
               }
            } else {
               --num_clients; ++num_rm;
               it = connections.erase(it);
               continue;
            }
         }
         ++it;
      }
      g.unlock();
      if( num_clients > 0 || num_peers > 0 )
         fc_ilog( logger, "p2p client connections: ${num}/${max}, peer connections: ${pnum}/${pmax}",
                  ("num", num_clients)("max", max_client_count)("pnum", num_peers)("pmax", supplied_peers.size()) );
      fc_dlog( logger, "connection monitor, removed ${n} connections", ("n", num_rm) );
      if( reschedule ) {
         start_conn_timer( connector_period, std::weak_ptr<connection>());
      }
   }

Here is the call graph for this function:

expire()

void sysio::net_plugin_impl::expire

(

)

Definition at line 3320 of file net_plugin.cpp.

                                {
      auto now = time_point::now();
      uint32_t lib = 0;
      std::tie( lib, std::ignore, std::ignore, std::ignore, std::ignore, std::ignore ) = get_chain_info();
      dispatcher->expire_blocks( lib );
      dispatcher->expire_txns();
      fc_dlog( logger, "expire_txns ${n}us", ("n", time_point::now() - now) );
 
      start_expire_timer();
   }

Here is the call graph for this function:

find_connection()

connection_ptr sysio::net_plugin_impl::find_connection

(

const string &

host

)

const

Definition at line 3903 of file net_plugin.cpp.

                                                                            {
      for( const auto& c : connections )
         if( c->peer_address() == host ) return c;
      return connection_ptr();
   }

Here is the caller graph for this function:

get_authentication_key()

chain::public_key_type sysio::net_plugin_impl::get_authentication_key

(

)

const

Finds a key to use for authentication. If this node is a producer, use the front of the producer key map. If the node is not a producer but has a configured private key, use it. If the node is neither a producer nor has a private key, returns an empty key.

Note

On a node with multiple private keys configured, the key with the first numerically smaller byte will always be used.

Definition at line 3484 of file net_plugin.cpp.

                                                                      {
      if(!private_keys.empty())
         return private_keys.begin()->first;
      /*producer_plugin* pp = app().find_plugin<producer_plugin>();
      if(pp != nullptr && pp->get_state() == abstract_plugin::started)
         return pp->first_producer_public_key();*/
      return chain::public_key_type();
   }

Here is the caller graph for this function:

get_chain_info()

std::tuple< uint32_t, uint32_t, uint32_t, block_id_type, block_id_type, block_id_type > sysio::net_plugin_impl::get_chain_info

(

)

const

Definition at line 2713 of file net_plugin.cpp.

                                         {
      std::lock_guard<std::mutex> g( chain_info_mtx );
      return std::make_tuple(
            chain_lib_num, chain_head_blk_num, chain_fork_head_blk_num,
            chain_lib_id, chain_head_blk_id, chain_fork_head_blk_id );
   }

Here is the caller graph for this function:

on_accepted_block()

void sysio::net_plugin_impl::on_accepted_block

(

const block_state_ptr &

bs

)

Definition at line 3379 of file net_plugin.cpp.

                                                                    {
      update_chain_info();
      dispatcher->strand.post( [this, bs]() {
         fc_dlog( logger, "signaled accepted_block, blk num = ${num}, id = ${id}", ("num", bs->block_num)("id", bs->id) );
 
         auto blk_trace = fc_create_trace_with_id( "Block", bs->id );
         auto blk_span = fc_create_span( blk_trace, "Accepted" );
         fc_add_tag( blk_span, "block_id", bs->id );
         fc_add_tag( blk_span, "block_num", bs->block_num );
         fc_add_tag( blk_span, "block_time", bs->block->timestamp.to_time_point() );
 
         dispatcher->bcast_block( bs->block, bs->id );
      });
   }

Here is the call graph for this function:

on_irreversible_block()

void sysio::net_plugin_impl::on_irreversible_block

(

const block_state_ptr &

blk

)

Definition at line 3416 of file net_plugin.cpp.

                                                                            {
      fc_dlog( logger, "on_irreversible_block, blk num = ${num}, id = ${id}", ("num", block->block_num)("id", block->id) );
      update_chain_info();
   }

Here is the call graph for this function:

on_pre_accepted_block()

void sysio::net_plugin_impl::on_pre_accepted_block

(

const signed_block_ptr &

bs

)

Definition at line 3395 of file net_plugin.cpp.

                                                                            {
      update_chain_info();
      controller& cc = chain_plug->chain();
      if( cc.is_trusted_producer(block->producer) ) {
         dispatcher->strand.post( [this, block]() {
            auto id = block->calculate_id();
            fc_dlog( logger, "signaled pre_accepted_block, blk num = ${num}, id = ${id}", ("num", block->block_num())("id", id) );
 
            auto blk_trace = fc_create_trace_with_id("Block", id);
            auto blk_span = fc_create_span(blk_trace, "PreAccepted");
            fc_add_tag(blk_span, "block_id", id);
            fc_add_tag(blk_span, "block_num", block->block_num());
            fc_add_tag(blk_span, "block_time", block->timestamp.to_time_point());
            fc_add_tag(blk_span, "producer", block->producer.to_string());
 
            dispatcher->bcast_block( block, id );
         });
      }
   }

Here is the call graph for this function:

sign_compact()

chain::signature_type sysio::net_plugin_impl::sign_compact	(	const chain::public_key_type &	signer,
		const fc::sha256 &	digest ) const

If there are no configured private keys, returns an empty signature.

Definition at line 3493 of file net_plugin.cpp.

   {
      auto private_key_itr = private_keys.find(signer);
      if(private_key_itr != private_keys.end())
         return private_key_itr->second.sign(digest);
      if(producer_plug != nullptr && producer_plug->get_state() == abstract_plugin::started)
         return producer_plug->sign_compact(signer, digest);
      return chain::signature_type();
   }

Here is the call graph for this function:

Here is the caller graph for this function:

start_conn_timer()

void sysio::net_plugin_impl::start_conn_timer	(	boost::asio::steady_timer::duration	du,
		std::weak_ptr< connection >	from_connection )

Definition at line 3246 of file net_plugin.cpp.

                                                                                                                   {
      if( in_shutdown ) return;
      std::lock_guard<std::mutex> g( connector_check_timer_mtx );
      ++connector_checks_in_flight;
      connector_check_timer->expires_from_now( du );
      connector_check_timer->async_wait( [my = shared_from_this(), from_connection](boost::system::error_code ec) {
            std::unique_lock<std::mutex> g( my->connector_check_timer_mtx );
            int num_in_flight = --my->connector_checks_in_flight;
            g.unlock();
            if( !ec ) {
               my->connection_monitor(from_connection, num_in_flight == 0 );
            } else {
               if( num_in_flight == 0 ) {
                  if( my->in_shutdown ) return;
                  fc_elog( logger, "Error from connection check monitor: ${m}", ("m", ec.message()));
                  my->start_conn_timer( my->connector_period, std::weak_ptr<connection>() );
               }
            }
      });
   }

Here is the caller graph for this function:

start_expire_timer()

void sysio::net_plugin_impl::start_expire_timer

(

)

Definition at line 3268 of file net_plugin.cpp.

                                            {
      if( in_shutdown ) return;
      std::lock_guard<std::mutex> g( expire_timer_mtx );
      expire_timer->expires_from_now( txn_exp_period);
      expire_timer->async_wait( [my = shared_from_this()]( boost::system::error_code ec ) {
         if( !ec ) {
            my->expire();
         } else {
            if( my->in_shutdown ) return;
            fc_elog( logger, "Error from transaction check monitor: ${m}", ("m", ec.message()) );
            my->start_expire_timer();
         }
      } );
   }

Here is the caller graph for this function:

start_listen_loop()

void sysio::net_plugin_impl::start_listen_loop

(

)

Definition at line 2362 of file net_plugin.cpp.

                                           {
      connection_ptr new_connection = std::make_shared<connection>();
      new_connection->connecting = true;
      new_connection->strand.post( [this, new_connection = std::move( new_connection )](){
         acceptor->async_accept( *new_connection->socket,
            boost::asio::bind_executor( new_connection->strand, [new_connection, socket=new_connection->socket, this]( boost::system::error_code ec ) {
            if( !ec ) {
               uint32_t visitors = 0;
               uint32_t from_addr = 0;
               boost::system::error_code rec;
               const auto& paddr_add = socket->remote_endpoint( rec ).address();
               string paddr_str;
               if( rec ) {
                  fc_elog( logger, "Error getting remote endpoint: ${m}", ("m", rec.message()));
               } else {
                  paddr_str = paddr_add.to_string();
                  for_each_connection( [&visitors, &from_addr, &paddr_str]( auto& conn ) {
                     if( conn->socket_is_open()) {
                        if( conn->peer_address().empty()) {
                           ++visitors;
                           std::lock_guard<std::mutex> g_conn( conn->conn_mtx );
                           if( paddr_str == conn->remote_endpoint_ip ) {
                              ++from_addr;
                           }
                        }
                     }
                     return true;
                  } );
                  if( from_addr < max_nodes_per_host && (max_client_count == 0 || visitors < max_client_count)) {
                     fc_ilog( logger, "Accepted new connection: " + paddr_str );
                     new_connection->set_heartbeat_timeout( heartbeat_timeout );
                     if( new_connection->start_session()) {
                        std::lock_guard<std::shared_mutex> g_unique( connections_mtx );
                        connections.insert( new_connection );
                     }
 
                  } else {
                     if( from_addr >= max_nodes_per_host ) {
                        fc_dlog( logger, "Number of connections (${n}) from ${ra} exceeds limit ${l}",
                                 ("n", from_addr + 1)( "ra", paddr_str )( "l", max_nodes_per_host ));
                     } else {
                        fc_dlog( logger, "max_client_count ${m} exceeded", ("m", max_client_count));
                     }
                     // new_connection never added to connections and start_session not called, lifetime will end
                     boost::system::error_code ec;
                     socket->shutdown( tcp::socket::shutdown_both, ec );
                     socket->close( ec );
                  }
               }
            } else {
               fc_elog( logger, "Error accepting connection: ${m}", ("m", ec.message()));
               // For the listed error codes below, recall start_listen_loop()
               switch (ec.value()) {
                  case ECONNABORTED:
                  case EMFILE:
                  case ENFILE:
                  case ENOBUFS:
                  case ENOMEM:
                  case EPROTO:
                     break;
                  default:
                     return;
               }
            }
            start_listen_loop();
         }));
      } );
   }

Here is the call graph for this function:

Here is the caller graph for this function:

start_monitors()

void sysio::net_plugin_impl::start_monitors

(

)

Definition at line 3307 of file net_plugin.cpp.

                                        {
      {
         std::lock_guard<std::mutex> g( connector_check_timer_mtx );
         connector_check_timer.reset(new boost::asio::steady_timer( my_impl->thread_pool->get_executor() ));
      }
      {
         std::lock_guard<std::mutex> g( expire_timer_mtx );
         expire_timer.reset( new boost::asio::steady_timer( my_impl->thread_pool->get_executor() ) );
      }
      start_conn_timer(connector_period, std::weak_ptr<connection>());
      start_expire_timer();
   }

Here is the call graph for this function:

ticker()

void sysio::net_plugin_impl::ticker

(

)

Definition at line 3284 of file net_plugin.cpp.

                                {
      if( in_shutdown ) return;
      std::lock_guard<std::mutex> g( keepalive_timer_mtx );
      keepalive_timer->expires_from_now(keepalive_interval);
      keepalive_timer->async_wait( [my = shared_from_this()]( boost::system::error_code ec ) {
            my->ticker();
            if( ec ) {
               if( my->in_shutdown ) return;
               fc_wlog( logger, "Peer keepalive ticked sooner than expected: ${m}", ("m", ec.message()) );
            }
 
            tstamp current_time = connection::get_time();
            for_each_connection( [current_time]( auto& c ) {
               if( c->socket_is_open() ) {
                  c->strand.post([c, current_time]() {
                     c->check_heartbeat(current_time);
                  } );
               }
               return true;
            } );
         } );
   }

Here is the call graph for this function:

to_protocol_version()

uint16_t sysio::net_plugin_impl::to_protocol_version ( uint16_t v )

staticconstexpr

Definition at line 3909 of file net_plugin.cpp.

                                                                     {
      if (v >= net_version_base) {
         v -= net_version_base;
         return (v > net_version_range) ? 0 : v;
      }
      return 0;
   }

Here is the caller graph for this function:

transaction_ack()

void sysio::net_plugin_impl::transaction_ack

(

const std::pair< fc::exception_ptr, packed_transaction_ptr > &

results

)

Definition at line 3422 of file net_plugin.cpp.

                                                                                                        {
      dispatcher->strand.post( [this, results]() {
         const auto& id = results.second->id();
         if (results.first) {
            fc_dlog( logger, "signaled NACK, trx-id = ${id} : ${why}", ("id", id)( "why", results.first->to_detail_string() ) );
 
            uint32_t head_blk_num = 0;
            std::tie( std::ignore, head_blk_num, std::ignore, std::ignore, std::ignore, std::ignore ) = get_chain_info();
            dispatcher->rejected_transaction(results.second, head_blk_num);
         } else {
            fc_dlog( logger, "signaled ACK, trx-id = ${id}", ("id", id) );
            dispatcher->bcast_transaction(results.second);
         }
      });
   }

Here is the call graph for this function:

Here is the caller graph for this function:

update_chain_info()

void sysio::net_plugin_impl::update_chain_info

(

)

Definition at line 2698 of file net_plugin.cpp.

                                           {
      controller& cc = chain_plug->chain();
      std::lock_guard<std::mutex> g( chain_info_mtx );
      chain_lib_num = cc.last_irreversible_block_num();
      chain_lib_id = cc.last_irreversible_block_id();
      chain_head_blk_num = cc.head_block_num();
      chain_head_blk_id = cc.head_block_id();
      chain_fork_head_blk_num = cc.fork_db_pending_head_block_num();
      chain_fork_head_blk_id = cc.fork_db_pending_head_block_id();
      fc_dlog( logger, "updating chain info lib ${lib}, head ${head}, fork ${fork}",
               ("lib", chain_lib_num)("head", chain_head_blk_num)("fork", chain_fork_head_blk_num) );
   }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

acceptor

unique_ptr<tcp::acceptor> sysio::net_plugin_impl::acceptor

Definition at line 220 of file net_plugin.cpp.

allowed_connections

possible_connections sysio::net_plugin_impl::allowed_connections {None}

Definition at line 243 of file net_plugin.cpp.

{None};

allowed_peers

vector<chain::public_key_type> sysio::net_plugin_impl::allowed_peers

Definition at line 234 of file net_plugin.cpp.

chain_id

chain_id_type sysio::net_plugin_impl::chain_id

Definition at line 260 of file net_plugin.cpp.

chain_plug

chain_plugin* sysio::net_plugin_impl::chain_plug = nullptr

Definition at line 264 of file net_plugin.cpp.

connections

std::set< connection_ptr > sysio::net_plugin_impl::connections

Definition at line 270 of file net_plugin.cpp.

connections_mtx

std::shared_mutex sysio::net_plugin_impl::connections_mtx

mutable

Definition at line 269 of file net_plugin.cpp.

connector_check_timer

unique_ptr<boost::asio::steady_timer> sysio::net_plugin_impl::connector_check_timer

Definition at line 273 of file net_plugin.cpp.

connector_check_timer_mtx

std::mutex sysio::net_plugin_impl::connector_check_timer_mtx

Definition at line 272 of file net_plugin.cpp.

connector_checks_in_flight

int sysio::net_plugin_impl::connector_checks_in_flight {0}

Definition at line 274 of file net_plugin.cpp.

{0};

connector_period

boost::asio::steady_timer::duration sysio::net_plugin_impl::connector_period {0}

Definition at line 245 of file net_plugin.cpp.

{0};

current_connection_id

std::atomic<uint32_t> sysio::net_plugin_impl::current_connection_id {0}

Definition at line 221 of file net_plugin.cpp.

{0};

dispatcher

unique_ptr< dispatch_manager > sysio::net_plugin_impl::dispatcher

Definition at line 224 of file net_plugin.cpp.

expire_timer

unique_ptr<boost::asio::steady_timer> sysio::net_plugin_impl::expire_timer

Definition at line 277 of file net_plugin.cpp.

expire_timer_mtx

std::mutex sysio::net_plugin_impl::expire_timer_mtx

Definition at line 276 of file net_plugin.cpp.

heartbeat_timeout

std::chrono::milliseconds sysio::net_plugin_impl::heartbeat_timeout {keepalive_interval * 2}

Definition at line 249 of file net_plugin.cpp.

{keepalive_interval * 2};

in_shutdown

std::atomic<bool> sysio::net_plugin_impl::in_shutdown {false}

Definition at line 282 of file net_plugin.cpp.

{false};

incoming_transaction_ack_subscription

compat::channels::transaction_ack::channel_type::handle sysio::net_plugin_impl::incoming_transaction_ack_subscription

Definition at line 284 of file net_plugin.cpp.

keepalive_interval

std::chrono::milliseconds sysio::net_plugin_impl::keepalive_interval {std::chrono::milliseconds{def_keepalive_interval}}

Definition at line 248 of file net_plugin.cpp.

{std::chrono::milliseconds{def_keepalive_interval}};

keepalive_timer

unique_ptr<boost::asio::steady_timer> sysio::net_plugin_impl::keepalive_timer

Definition at line 280 of file net_plugin.cpp.

keepalive_timer_mtx

std::mutex sysio::net_plugin_impl::keepalive_timer_mtx

Definition at line 279 of file net_plugin.cpp.

max_cleanup_time_ms

int sysio::net_plugin_impl::max_cleanup_time_ms = 0

Definition at line 251 of file net_plugin.cpp.

max_client_count

uint32_t sysio::net_plugin_impl::max_client_count = 0

Definition at line 252 of file net_plugin.cpp.

max_nodes_per_host

uint32_t sysio::net_plugin_impl::max_nodes_per_host = 1

Definition at line 253 of file net_plugin.cpp.

node_id

fc::sha256 sysio::net_plugin_impl::node_id

Definition at line 261 of file net_plugin.cpp.

p2p_accept_transactions

bool sysio::net_plugin_impl::p2p_accept_transactions = true

Definition at line 254 of file net_plugin.cpp.

p2p_address

string sysio::net_plugin_impl::p2p_address

Thread safe, only updated in plugin initialize

Definition at line 230 of file net_plugin.cpp.

p2p_dedup_cache_expire_time_us

fc::microseconds sysio::net_plugin_impl::p2p_dedup_cache_expire_time_us {}

Definition at line 255 of file net_plugin.cpp.

{};

p2p_server_address

string sysio::net_plugin_impl::p2p_server_address

Definition at line 231 of file net_plugin.cpp.

peer_authentication_interval

const std::chrono::system_clock::duration sysio::net_plugin_impl::peer_authentication_interval {std::chrono::seconds{1}}

Definition at line 258 of file net_plugin.cpp.

{std::chrono::seconds{1}};

private_keys

std::map<chain::public_key_type, chain::private_key_type> sysio::net_plugin_impl::private_keys

Definition at line 236 of file net_plugin.cpp.

producer_plug

producer_plugin* sysio::net_plugin_impl::producer_plug = nullptr

Definition at line 265 of file net_plugin.cpp.

resp_expected_period

boost::asio::steady_timer::duration sysio::net_plugin_impl::resp_expected_period {0}

Definition at line 247 of file net_plugin.cpp.

{0};

supplied_peers

vector<string> sysio::net_plugin_impl::supplied_peers

Definition at line 233 of file net_plugin.cpp.

sync_master

unique_ptr< sync_manager > sysio::net_plugin_impl::sync_master

Definition at line 223 of file net_plugin.cpp.

thread_pool

std::optional<sysio::chain::named_thread_pool> sysio::net_plugin_impl::thread_pool

Definition at line 287 of file net_plugin.cpp.

thread_pool_size

uint16_t sysio::net_plugin_impl::thread_pool_size = 2

Definition at line 286 of file net_plugin.cpp.

txn_exp_period

boost::asio::steady_timer::duration sysio::net_plugin_impl::txn_exp_period {0}

Definition at line 246 of file net_plugin.cpp.

{0};

use_socket_read_watermark

bool sysio::net_plugin_impl::use_socket_read_watermark = false

Definition at line 266 of file net_plugin.cpp.

user_agent_name

string sysio::net_plugin_impl::user_agent_name

Definition at line 262 of file net_plugin.cpp.

---

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

• plugins/net_plugin/net_plugin.cpp