sysio Namespace Reference

Namespaces
namespace	chain
namespace	chain_apis
namespace	client
namespace	detail
namespace	finality_status
namespace	resource_monitor
namespace	state_history
namespace	test
namespace	test_control_apis
namespace	testing
namespace	trace_api
namespace	version
namespace	vm
namespace	wallet
namespace	wasm_backend

Classes
struct	async_result_visitor
struct	block_buffer_factory
class	block_status_monitor
struct	buffer_factory
class	chain_api_plugin
class	chain_api_plugin_impl
class	chain_plugin
class	chain_plugin_impl
struct	chain_size_message
class	connection
struct	connection_status
class	db_size_api_plugin
struct	db_size_index_count
struct	db_size_stats
class	dispatch_manager
struct	error_results
	Structure used to create JSON error responses. More...
struct	finality_status_object
	tracks status related to a transaction in the blockchain More...
class	fixed_bytes
class	fixed_key
struct	go_away_message
struct	handshake_message
class	http_client_plugin
class	http_plugin
struct	http_plugin_defaults
class	http_plugin_impl
class	login_plugin
class	login_plugin_impl
struct	login_request
struct	login_request_pub_key_index
struct	login_request_time_index
struct	msg_handler
class	multisig
class	net_api_plugin
class	net_plugin
class	net_plugin_impl
struct	node_transaction_state
struct	notice_message
struct	peer_block_state
struct	peer_sync_state
class	pending_snapshot
class	producer_api_plugin
class	producer_plugin
class	producer_plugin_impl
class	queued_buffer
struct	request_message
class	resource_monitor_plugin
class	resource_monitor_plugin_impl
struct	select_ids
class	state_history_log
struct	state_history_log_header
struct	state_history_log_prune_config
class	state_history_plugin
struct	state_history_plugin_impl
class	sub_chain_plugin
class	sub_chain_plugin_impl
class	subjective_billing
class	sync_manager
struct	sync_request_message
class	template_plugin
class	template_plugin_impl
class	test_control_api_plugin
class	test_control_api_plugin_impl
class	test_control_plugin
class	test_control_plugin_impl
struct	time_message
class	token
struct	trace_api_common_impl
class	trace_api_plugin
struct	trace_api_plugin_impl
class	trace_api_rpc_plugin
struct	trace_api_rpc_plugin_impl
struct	transaction_id_with_expiry
struct	trx_buffer_factory
class	txn_test_gen_plugin
struct	txn_test_gen_plugin_impl
class	wallet_api_plugin
class	wallet_plugin
class	wrap

Typedefs
typedef fixed_key< 32 >	key256
using	vm_type = wasm_interface::vm_type
using	finality_status_multi_index
using	websocket_server_type = websocketpp::server<detail::asio_with_stub_log<websocketpp::transport::asio::basic_socket::endpoint>>
using	websocket_local_server_type = websocketpp::server<detail::asio_local_with_stub_log>
using	websocket_server_tls_type = websocketpp::server<detail::asio_with_stub_log<websocketpp::transport::asio::tls_socket::endpoint>>
using	ssl_context_ptr = websocketpp::lib::shared_ptr<websocketpp::lib::asio::ssl::context>
using	http_plugin_impl_ptr = std::shared_ptr<class http_plugin_impl>
using	url_response_callback = std::function<void(int,fc::variant)>
	A callback function provided to a URL handler to allow it to specify the HTTP response code and body.
using	url_handler = std::function<void(string,string,url_response_callback)>
	Callback type for a URL handler.
using	api_description = std::map<string, url_handler>
	An API, containing URLs and handlers.
using	login_request_container
typedef std::chrono::system_clock::duration::rep	tstamp
using	ordered_txn_ids = select_ids<transaction_id_type>
using	ordered_blk_ids = select_ids<block_id_type>
using	net_message
using	connection_ptr = std::shared_ptr<connection>
using	connection_wptr = std::weak_ptr<connection>
typedef multi_index_container< node_transaction_state, indexed_by< ordered_unique< tag< by_id >, composite_key< node_transaction_state, member< node_transaction_state, transaction_id_type, &node_transaction_state::id >, member< node_transaction_state, uint32_t, &node_transaction_state::connection_id > >, composite_key_compare< sha256_less, std::less< uint32_t > > >, ordered_non_unique< tag< by_expiry >, member< node_transaction_state, fc::time_point_sec, &node_transaction_state::expires > > > >	node_transaction_index
typedef multi_index_container< sysio::peer_block_state, indexed_by< ordered_unique< tag< by_id >, composite_key< peer_block_state, member< peer_block_state, uint32_t, &sysio::peer_block_state::connection_id >, member< peer_block_state, block_id_type, &sysio::peer_block_state::id > >, composite_key_compare< std::less< uint32_t >, sha256_less > >, ordered_non_unique< tag< by_peer_block_id >, composite_key< peer_block_state, member< peer_block_state, block_id_type, &sysio::peer_block_state::id >, member< peer_block_state, bool, &sysio::peer_block_state::have_block > >, composite_key_compare< sha256_less, std::greater< bool > > >, ordered_non_unique< tag< by_block_num >, member< sysio::peer_block_state, uint32_t, &sysio::peer_block_state::block_num > > > >	peer_block_state_index
using	send_buffer_type = std::shared_ptr<std::vector<char>>
using	transaction_id_with_expiry_index
using	pending_snapshot_index
typedef shared_ptr< struct state_history_plugin_impl >	state_history_ptr
typedef std::shared_ptr< class test_control_plugin_impl >	test_control_ptr

Enumerations
enum	https_ecdh_curve_t { SECP384R1 , PRIME256V1 }
enum class	http_params_types { no_params = 0 , params_required = 1 , possible_no_params = 2 }
enum	go_away_reason {   no_reason , self , duplicate , wrong_chain ,   wrong_version , forked , unlinkable , bad_transaction ,   validation , benign_other , fatal_other , authentication }
enum	id_list_modes { none , catch_up , last_irr_catch_up , normal }
enum class	pending_block_mode { producing , speculating }

Functions
template<size_t Size>
bool	operator== (const fixed_key< Size > &c1, const fixed_key< Size > &c2)
	Compares two fixed_key variables c1 and c2.
template<size_t Size>
bool	operator!= (const fixed_key< Size > &c1, const fixed_key< Size > &c2)
	Compares two fixed_key variables c1 and c2.
template<size_t Size>
bool	operator> (const fixed_key< Size > &c1, const fixed_key< Size > &c2)
	Compares two fixed_key variables c1 and c2.
template<size_t Size>
bool	operator< (const fixed_key< Size > &c1, const fixed_key< Size > &c2)
	Compares two fixed_key variables c1 and c2.
uint64_t	ship_magic (uint16_t version, uint16_t features=0)
bool	is_ship (uint64_t magic)
uint16_t	get_ship_version (uint64_t magic)
uint16_t	get_ship_features (uint64_t magic)
bool	is_ship_supported_version (uint64_t magic)
bool	is_ship_log_pruned (uint64_t magic)
uint64_t	clear_ship_log_pruned_feature (uint64_t magic)
template<>
chain_apis::read_only::get_transaction_status_params	parse_params< chain_apis::read_only::get_transaction_status_params, http_params_types::params_required > (const std::string &body)
fc::time_point	calculate_genesis_timestamp (string tstr)
void	clear_directory_contents (const fc::path &p)
void	clear_chainbase_files (const fc::path &p)
std::optional< builtin_protocol_feature >	read_builtin_protocol_feature (const fc::path &p)
protocol_feature_set	initialize_protocol_features (const fc::path &p, bool populate_missing_builtins=true)
template<>
bool	http_plugin_impl::allow_host< detail::asio_local_with_stub_log > (const detail::asio_local_with_stub_log::request_type &req, websocketpp::server< detail::asio_local_with_stub_log >::connection_ptr con)
std::istream &	operator>> (std::istream &in, https_ecdh_curve_t &curve)
std::ostream &	operator<< (std::ostream &osm, https_ecdh_curve_t curve)
std::string_view	make_trimmed_string_view (const std::string &body)
	Used to trim whitespace from body. Returned string_view valid only for lifetime of body.
bool	is_empty_content (const std::string &body)
template<typename T , http_params_types params_type>
T	parse_params (const std::string &body)
constexpr auto	reason_str (go_away_reason rsn)
constexpr auto	modes_str (id_list_modes m)
template<typename Strand >
void	verify_strand_in_this_thread (const Strand &strand, const char *func, int line)
const fc::string	logger_name ("net_plugin_impl")
template<class enum_type , class = typename std::enable_if<std::is_enum<enum_type>::value>::type>
enum_type &	operator|= (enum_type &lhs, const enum_type &rhs)
template<typename Function >
void	for_each_connection (Function f)
template<typename Function >
void	for_each_block_connection (Function f)
size_t	calc_trx_size (const packed_transaction_ptr &trx)
template<typename T >
T	dejsonify (const string &s)
void	new_chain_banner (const sysio::chain::controller &db)
template<typename F >
auto	catch_and_log (F f)

Variables
constexpr size_t	max_p2p_address_length = 253 + 6
constexpr size_t	max_handshake_str_length = 384
constexpr auto	def_send_buffer_size_mb = 4
constexpr auto	def_send_buffer_size = 1024*1024*def_send_buffer_size_mb
constexpr auto	def_max_write_queue_size = def_send_buffer_size*10
constexpr auto	def_max_trx_in_progress_size = 100*1024*1024
constexpr auto	def_max_consecutive_immediate_connection_close = 9
constexpr auto	def_max_clients = 25
constexpr auto	def_max_nodes_per_host = 1
constexpr auto	def_conn_retry_wait = 30
constexpr auto	def_txn_expire_wait = std::chrono::seconds(3)
constexpr auto	def_resp_expected_wait = std::chrono::seconds(5)
constexpr auto	def_sync_fetch_span = 100
constexpr auto	def_keepalive_interval = 10000
constexpr auto	message_header_size = sizeof(uint32_t)
constexpr uint32_t	signed_block_which = fc::get_index<net_message, signed_block>()
constexpr uint32_t	packed_transaction_which = fc::get_index<net_message, packed_transaction>()
fc::logger	logger
std::string	peer_log_format
constexpr uint16_t	net_version_base = 0x04b5
constexpr uint16_t	net_version_range = 106
constexpr uint16_t	proto_base = 0
constexpr uint16_t	proto_explicit_sync = 1
constexpr uint16_t	proto_block_id_notify = 2
constexpr uint16_t	proto_pruned_types = 3
constexpr uint16_t	proto_heartbeat_interval = 4
constexpr uint16_t	proto_dup_goaway_resolution = 5
constexpr uint16_t	proto_dup_node_id_goaway = 6
constexpr uint16_t	proto_wire_sysio_initial = 7
constexpr uint16_t	net_version_max = proto_wire_sysio_initial

Typedef Documentation

api_description

using sysio::api_description = std::map<string, url_handler>

An API is composed of several calls, where each call has a URL and a handler. The URL is the path on the web server that triggers the call, and the handler is the function which implements the API call

Definition at line 38 of file http_plugin.hpp.

connection_ptr

using sysio::connection_ptr = std::shared_ptr<connection>

Definition at line 50 of file net_plugin.cpp.

connection_wptr

using sysio::connection_wptr = std::weak_ptr<connection>

Definition at line 51 of file net_plugin.cpp.

finality_status_multi_index

using sysio::finality_status_multi_index

Initial value:

 boost::multi_index_container<
      finality_status_object,
      indexed_by<
         bmi::hashed_unique< tag<finality_status::by_trx_id>,
                             member<finality_status_object, chain::transaction_id_type, &finality_status_object::trx_id> >,
         ordered_non_unique< tag<finality_status::by_status_expiry>, 
            composite_key< finality_status_object,
               const_mem_fun<finality_status_object, bool,           &finality_status_object::is_in_block>,
               member< finality_status_object,       fc::time_point, &finality_status_object::received >
            >
         >,
         ordered_non_unique< tag<finality_status::by_block_num>,
                             const_mem_fun<finality_status_object, uint32_t, &finality_status_object::block_num> >
      >
   >

Definition at line 44 of file finality_status_object.hpp.

http_plugin_impl_ptr

using sysio::http_plugin_impl_ptr = std::shared_ptr<class http_plugin_impl>

Definition at line 175 of file http_plugin.cpp.

key256

typedef fixed_key<32> sysio::key256

Definition at line 220 of file fixed_key.hpp.

login_request_container

using sysio::login_request_container

Initial value:

 boost::multi_index_container<
    login_request,
    indexed_by< 
        ordered_unique<tag<login_request_pub_key_index>,
                       member<login_request, chain::public_key_type, &login_request::server_ephemeral_pub_key>>,
        ordered_non_unique<tag<login_request_time_index>,
                           member<login_request, chain::time_point_sec, &login_request::expiration_time>> 
        >>

Definition at line 22 of file login_plugin.cpp.

net_message

using sysio::net_message

Initial value:

 std::variant<handshake_message,
                                    chain_size_message,
                                    go_away_message,
                                    time_message,
                                    notice_message,
                                    request_message,
                                    sync_request_message,
                                    signed_block,         
                                    packed_transaction>

Definition at line 138 of file protocol.hpp.

node_transaction_index

typedef multi_index_container< node_transaction_state, indexed_by< ordered_unique< tag<by_id>, composite_key< node_transaction_state, member<node_transaction_state, transaction_id_type, &node_transaction_state::id>, member<node_transaction_state, uint32_t, &node_transaction_state::connection_id> >, composite_key_compare< sha256_less, std::less<uint32_t> > >, ordered_non_unique< tag< by_expiry >, member< node_transaction_state, fc::time_point_sec, &node_transaction_state::expires > > > > sysio::node_transaction_index

Definition at line 85 of file net_plugin.cpp.

ordered_blk_ids

using sysio::ordered_blk_ids = select_ids<block_id_type>

Definition at line 119 of file protocol.hpp.

ordered_txn_ids

using sysio::ordered_txn_ids = select_ids<transaction_id_type>

Definition at line 118 of file protocol.hpp.

peer_block_state_index

typedef multi_index_container< sysio::peer_block_state, indexed_by< ordered_unique< tag<by_id>, composite_key< peer_block_state, member<peer_block_state, uint32_t, &sysio::peer_block_state::connection_id>, member<peer_block_state, block_id_type, &sysio::peer_block_state::id> >, composite_key_compare< std::less<uint32_t>, sha256_less > >, ordered_non_unique< tag<by_peer_block_id>, composite_key< peer_block_state, member<peer_block_state, block_id_type, &sysio::peer_block_state::id>, member<peer_block_state, bool, &sysio::peer_block_state::have_block> >, composite_key_compare< sha256_less, std::greater<bool> > >, ordered_non_unique< tag<by_block_num>, member<sysio::peer_block_state, uint32_t, &sysio::peer_block_state::block_num > > > > sysio::peer_block_state_index

Definition at line 116 of file net_plugin.cpp.

pending_snapshot_index

using sysio::pending_snapshot_index

Initial value:

 multi_index_container<
   pending_snapshot,
   indexed_by<
      hashed_unique<tag<by_id>, BOOST_MULTI_INDEX_MEMBER(pending_snapshot, block_id_type, block_id)>,
      ordered_non_unique<tag<by_height>, BOOST_MULTI_INDEX_CONST_MEM_FUN( pending_snapshot, uint32_t, get_height)>
   >
>

Definition at line 177 of file producer_plugin.cpp.

send_buffer_type

using sysio::send_buffer_type = std::shared_ptr<std::vector<char>>

Definition at line 1320 of file net_plugin.cpp.

ssl_context_ptr

using sysio::ssl_context_ptr = websocketpp::lib::shared_ptr<websocketpp::lib::asio::ssl::context>

Definition at line 174 of file http_plugin.cpp.

state_history_ptr

typedef shared_ptr<struct state_history_plugin_impl> sysio::state_history_ptr

Definition at line 15 of file state_history_plugin.hpp.

test_control_ptr

typedef std::shared_ptr<class test_control_plugin_impl> sysio::test_control_ptr

Definition at line 11 of file test_control_plugin.hpp.

transaction_id_with_expiry_index

using sysio::transaction_id_with_expiry_index

Initial value:

 multi_index_container<
   transaction_id_with_expiry,
   indexed_by<
      hashed_unique<tag<by_id>, BOOST_MULTI_INDEX_MEMBER(transaction_id_with_expiry, transaction_id_type, trx_id)>,
      ordered_non_unique<tag<by_expiry>, BOOST_MULTI_INDEX_MEMBER(transaction_id_with_expiry, fc::time_point, expiry)>
   >
>

Definition at line 112 of file producer_plugin.cpp.

tstamp

typedef std::chrono::system_clock::duration::rep sysio::tstamp

Definition at line 11 of file protocol.hpp.

url_handler

using sysio::url_handler = std::function<void(string,string,url_response_callback)>

URL handlers have this type

The handler must gaurantee that url_response_callback() is called; otherwise, the connection will hang and result in a memory leak.

Arguments: url, request_body, response_callback

Definition at line 29 of file http_plugin.hpp.

url_response_callback

using sysio::url_response_callback = std::function<void(int,fc::variant)>

Arguments: response_code, response_body

Definition at line 17 of file http_plugin.hpp.

vm_type

using sysio::vm_type = wasm_interface::vm_type

Definition at line 131 of file chain_plugin.cpp.

websocket_local_server_type

using sysio::websocket_local_server_type = websocketpp::server<detail::asio_local_with_stub_log>

Definition at line 172 of file http_plugin.cpp.

websocket_server_tls_type

using sysio::websocket_server_tls_type = websocketpp::server<detail::asio_with_stub_log<websocketpp::transport::asio::tls_socket::endpoint>>

Definition at line 173 of file http_plugin.cpp.

websocket_server_type

using sysio::websocket_server_type = websocketpp::server<detail::asio_with_stub_log<websocketpp::transport::asio::basic_socket::endpoint>>

Definition at line 171 of file http_plugin.cpp.

Enumeration Type Documentation

go_away_reason

enum sysio::go_away_reason

Enumerator
no_reason	no reason to go away
self	the connection is to itself
duplicate	the connection is redundant
wrong_chain	the peer's chain id doesn't match
wrong_version	the peer's network version doesn't match
forked	the peer's irreversible blocks are different
unlinkable	the peer sent a block we couldn't use
bad_transaction	the peer sent a transaction that failed verification
validation	the peer sent a block that failed validation
benign_other	reasons such as a timeout. not fatal but warrant resetting
fatal_other	a catch-all for errors we don't have discriminated
authentication	peer failed authenicatio

Definition at line 46 of file protocol.hpp.

                      {
    no_reason, 
    self, 
    duplicate, 
    wrong_chain, 
    wrong_version, 
    forked, 
    unlinkable, 
    bad_transaction, 
    validation, 
    benign_other, 
    fatal_other, 
    authentication 
  };

http_params_types

enum class sysio::http_params_types

strong

Enumerator
no_params
params_required
possible_no_params

Definition at line 215 of file http_plugin.hpp.

                                {
      no_params = 0,
      params_required = 1,
      possible_no_params = 2
   };

https_ecdh_curve_t

enum sysio::https_ecdh_curve_t

Enumerator
SECP384R1
PRIME256V1

Definition at line 48 of file http_plugin.cpp.

                           {
      SECP384R1,
      PRIME256V1
   };

id_list_modes

enum sysio::id_list_modes

Enumerator
none
catch_up
last_irr_catch_up
normal

Definition at line 92 of file protocol.hpp.

                     {
    none,
    catch_up,
    last_irr_catch_up,
    normal
  };

pending_block_mode

enum class sysio::pending_block_mode

strong

Enumerator
producing
speculating

Definition at line 185 of file producer_plugin.cpp.

                              {
   producing,
   speculating
};

Function Documentation

calc_trx_size()

size_t sysio::calc_trx_size

(

const packed_transaction_ptr &

trx

)

Definition at line 3106 of file net_plugin.cpp.

                                                             {
      return trx->get_estimated_size();
   }

Here is the caller graph for this function:

calculate_genesis_timestamp()

fc::time_point sysio::calculate_genesis_timestamp

(

string

tstr

)

Definition at line 386 of file chain_plugin.cpp.

                                                        {
   fc::time_point genesis_timestamp;
   if( strcasecmp (tstr.c_str(), "now") == 0 ) {
      genesis_timestamp = fc::time_point::now();
   } else {
      genesis_timestamp = time_point::from_iso_string( tstr );
   }
 
   auto epoch_us = genesis_timestamp.time_since_epoch().count();
   auto diff_us = epoch_us % config::block_interval_us;
   if (diff_us > 0) {
      auto delay_us = (config::block_interval_us - diff_us);
      genesis_timestamp += fc::microseconds(delay_us);
      dlog("pausing ${us} microseconds to the next interval",("us",delay_us));
   }
 
   ilog( "Adjusting genesis timestamp to ${timestamp}", ("timestamp", genesis_timestamp) );
   return genesis_timestamp;
}

Here is the call graph for this function:

Here is the caller graph for this function:

catch_and_log()

template<typename F >

auto sysio::catch_and_log

(

F

f

)

Definition at line 31 of file state_history_plugin.cpp.

                        {
   try {
      return f();
   } catch (const fc::exception& e) {
      elog("${e}", ("e", e.to_detail_string()));
   } catch (const std::exception& e) {
      elog("${e}", ("e", e.what()));
   } catch (...) {
      elog("unknown exception");
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

clear_chainbase_files()

void sysio::clear_chainbase_files

(

const fc::path &

p

)

Definition at line 417 of file chain_plugin.cpp.

                                              {
   if( !fc::is_directory( p ) )
      return;
 
   fc::remove( p / "shared_memory.bin" );
   fc::remove( p / "shared_memory.meta" );
}

Here is the call graph for this function:

Here is the caller graph for this function:

clear_directory_contents()

void sysio::clear_directory_contents

(

const fc::path &

p

)

Definition at line 406 of file chain_plugin.cpp.

                                                 {
   using boost::filesystem::directory_iterator;
 
   if( !fc::is_directory( p ) )
      return;
 
   for( directory_iterator enditr, itr{p}; itr != enditr; ++itr ) {
      fc::remove_all( itr->path() );
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

clear_ship_log_pruned_feature()

uint64_t sysio::clear_ship_log_pruned_feature ( uint64_t magic )

inline

Definition at line 52 of file log.hpp.

{ return ship_magic(get_ship_version(magic), get_ship_features(magic) & ~ship_feature_pruned_log); }

Here is the call graph for this function:

dejsonify()

template<typename T >

T sysio::dejsonify

(

const string &

s

)

Definition at line 3592 of file net_plugin.cpp.

                                {
      return fc::json::from_string(s).as<T>();
   }

Here is the call graph for this function:

Here is the caller graph for this function:

for_each_block_connection()

template<typename Function >

void sysio::for_each_block_connection

(

Function

f

)

Definition at line 868 of file net_plugin.cpp.

                                                {
      std::shared_lock<std::shared_mutex> g( my_impl->connections_mtx );
      for( auto& c : my_impl->connections ) {
         if( c->is_transactions_only_connection() ) continue;
         if( !f( c ) ) return;
      }
   }

Here is the caller graph for this function:

for_each_connection()

template<typename Function >

void sysio::for_each_connection

(

Function

f

)

Definition at line 860 of file net_plugin.cpp.

                                          {
      std::shared_lock<std::shared_mutex> g( my_impl->connections_mtx );
      for( auto& c : my_impl->connections ) {
         if( !f( c ) ) return;
      }
   }

Here is the caller graph for this function:

get_ship_features()

uint16_t sysio::get_ship_features ( uint64_t magic )

inline

Definition at line 47 of file log.hpp.

{ return magic>>16; }

Here is the caller graph for this function:

get_ship_version()

uint16_t sysio::get_ship_version ( uint64_t magic )

inline

Definition at line 46 of file log.hpp.

{ return magic; }

Here is the caller graph for this function:

http_plugin_impl::allow_host< detail::asio_local_with_stub_log >()

template<>

bool sysio::http_plugin_impl::allow_host< detail::asio_local_with_stub_log >	(	const detail::asio_local_with_stub_log::request_type &	req,
		websocketpp::server< detail::asio_local_with_stub_log >::connection_ptr	con )

Definition at line 628 of file http_plugin.cpp.

                                                                                                                                                                                               {
      return true;
   }

initialize_protocol_features()

protocol_feature_set sysio::initialize_protocol_features	(	const fc::path &	p,
		bool	populate_missing_builtins = true )

Definition at line 438 of file chain_plugin.cpp.

                                                                                                            {
   using boost::filesystem::directory_iterator;
 
   protocol_feature_set pfs;
 
   bool directory_exists = true;
 
   if( fc::exists( p ) ) {
      SYS_ASSERT( fc::is_directory( p ), plugin_exception,
                  "Path to protocol-features is not a directory: ${path}",
                  ("path", p.generic_string())
      );
   } else {
      if( populate_missing_builtins )
         bfs::create_directories( p );
      else
         directory_exists = false;
   }
 
   auto log_recognized_protocol_feature = []( const builtin_protocol_feature& f, const digest_type& feature_digest ) {
      if( f.subjective_restrictions.enabled ) {
         if( f.subjective_restrictions.preactivation_required ) {
            if( f.subjective_restrictions.earliest_allowed_activation_time == time_point{} ) {
               ilog( "Support for builtin protocol feature '${codename}' (with digest of '${digest}') is enabled with preactivation required",
                     ("codename", builtin_protocol_feature_codename(f.get_codename()))
                     ("digest", feature_digest)
               );
            } else {
               ilog( "Support for builtin protocol feature '${codename}' (with digest of '${digest}') is enabled with preactivation required and with an earliest allowed activation time of ${earliest_time}",
                     ("codename", builtin_protocol_feature_codename(f.get_codename()))
                     ("digest", feature_digest)
                     ("earliest_time", f.subjective_restrictions.earliest_allowed_activation_time)
               );
            }
         } else {
            if( f.subjective_restrictions.earliest_allowed_activation_time == time_point{} ) {
               ilog( "Support for builtin protocol feature '${codename}' (with digest of '${digest}') is enabled without activation restrictions",
                     ("codename", builtin_protocol_feature_codename(f.get_codename()))
                     ("digest", feature_digest)
               );
            } else {
               ilog( "Support for builtin protocol feature '${codename}' (with digest of '${digest}') is enabled without preactivation required but with an earliest allowed activation time of ${earliest_time}",
                     ("codename", builtin_protocol_feature_codename(f.get_codename()))
                     ("digest", feature_digest)
                     ("earliest_time", f.subjective_restrictions.earliest_allowed_activation_time)
               );
            }
         }
      } else {
         ilog( "Recognized builtin protocol feature '${codename}' (with digest of '${digest}') but support for it is not enabled",
               ("codename", builtin_protocol_feature_codename(f.get_codename()))
               ("digest", feature_digest)
         );
      }
   };
 
   map<builtin_protocol_feature_t, fc::path>  found_builtin_protocol_features;
   map<digest_type, std::pair<builtin_protocol_feature, bool> > builtin_protocol_features_to_add;
   // The bool in the pair is set to true if the builtin protocol feature has already been visited to add
   map< builtin_protocol_feature_t, std::optional<digest_type> > visited_builtins;
 
   // Read all builtin protocol features
   if( directory_exists ) {
      for( directory_iterator enditr, itr{p}; itr != enditr; ++itr ) {
         auto file_path = itr->path();
         if( !fc::is_regular_file( file_path ) || file_path.extension().generic_string().compare( ".json" ) != 0 )
            continue;
 
         auto f = read_builtin_protocol_feature( file_path );
 
         if( !f ) continue;
 
         auto res = found_builtin_protocol_features.emplace( f->get_codename(), file_path );
 
         SYS_ASSERT( res.second, plugin_exception,
                     "Builtin protocol feature '${codename}' was already included from a previous_file",
                     ("codename", builtin_protocol_feature_codename(f->get_codename()))
                     ("current_file", file_path.generic_string())
                     ("previous_file", res.first->second.generic_string())
         );
 
         const auto feature_digest = f->digest();
 
         builtin_protocol_features_to_add.emplace( std::piecewise_construct,
                                                   std::forward_as_tuple( feature_digest ),
                                                   std::forward_as_tuple( *f, false ) );
      }
   }
 
   // Add builtin protocol features to the protocol feature manager in the right order (to satisfy dependencies)
   using itr_type = map<digest_type, std::pair<builtin_protocol_feature, bool>>::iterator;
   std::function<void(const itr_type&)> add_protocol_feature =
   [&pfs, &builtin_protocol_features_to_add, &visited_builtins, &log_recognized_protocol_feature, &add_protocol_feature]( const itr_type& itr ) -> void {
      if( itr->second.second ) {
         return;
      } else {
         itr->second.second = true;
         visited_builtins.emplace( itr->second.first.get_codename(), itr->first );
      }
 
      for( const auto& d : itr->second.first.dependencies ) {
         auto itr2 = builtin_protocol_features_to_add.find( d );
         if( itr2 != builtin_protocol_features_to_add.end() ) {
            add_protocol_feature( itr2 );
         }
      }
 
      pfs.add_feature( itr->second.first );
 
      log_recognized_protocol_feature( itr->second.first, itr->first );
   };
 
   for( auto itr = builtin_protocol_features_to_add.begin(); itr != builtin_protocol_features_to_add.end(); ++itr ) {
      add_protocol_feature( itr );
   }
 
   auto output_protocol_feature = [&p]( const builtin_protocol_feature& f, const digest_type& feature_digest ) {
      string filename( "BUILTIN-" );
      filename += builtin_protocol_feature_codename( f.get_codename() );
      filename += ".json";
 
      auto file_path = p / filename;
 
      SYS_ASSERT( !fc::exists( file_path ), plugin_exception,
                  "Could not save builtin protocol feature with codename '${codename}' because a file at the following path already exists: ${path}",
                  ("codename", builtin_protocol_feature_codename( f.get_codename() ))
                  ("path", file_path.generic_string())
      );
 
      if( fc::json::save_to_file( f, file_path ) ) {
         ilog( "Saved default specification for builtin protocol feature '${codename}' (with digest of '${digest}') to: ${path}",
               ("codename", builtin_protocol_feature_codename(f.get_codename()))
               ("digest", feature_digest)
               ("path", file_path.generic_string())
         );
      } else {
         elog( "Error occurred while writing default specification for builtin protocol feature '${codename}' (with digest of '${digest}') to: ${path}",
               ("codename", builtin_protocol_feature_codename(f.get_codename()))
               ("digest", feature_digest)
               ("path", file_path.generic_string())
         );
      }
   };
 
   std::function<digest_type(builtin_protocol_feature_t)> add_missing_builtins =
   [&pfs, &visited_builtins, &output_protocol_feature, &log_recognized_protocol_feature, &add_missing_builtins, populate_missing_builtins]
   ( builtin_protocol_feature_t codename ) -> digest_type {
      auto res = visited_builtins.emplace( codename, std::optional<digest_type>() );
      if( !res.second ) {
         SYS_ASSERT( res.first->second, protocol_feature_exception,
                     "invariant failure: cycle found in builtin protocol feature dependencies"
         );
         return *res.first->second;
      }
 
      auto f = protocol_feature_set::make_default_builtin_protocol_feature( codename,
      [&add_missing_builtins]( builtin_protocol_feature_t d ) {
         return add_missing_builtins( d );
      } );
 
      if( !populate_missing_builtins )
         f.subjective_restrictions.enabled = false;
 
      const auto& pf = pfs.add_feature( f );
      res.first->second = pf.feature_digest;
 
      log_recognized_protocol_feature( f, pf.feature_digest );
 
      if( populate_missing_builtins )
         output_protocol_feature( f, pf.feature_digest );
 
      return pf.feature_digest;
   };
 
   for( const auto& p : builtin_protocol_feature_codenames ) {
      auto itr = found_builtin_protocol_features.find( p.first );
      if( itr != found_builtin_protocol_features.end() ) continue;
 
      add_missing_builtins( p.first );
   }
 
   return pfs;
}

Here is the call graph for this function:

Here is the caller graph for this function:

is_empty_content()

bool sysio::is_empty_content ( const std::string & body )

inline

Definition at line 195 of file http_plugin.hpp.

                                                       {
      const auto trimmed_body_view = make_trimmed_string_view(body);
      if (trimmed_body_view.empty()) {
         return true;
      }
      const size_t body_size = trimmed_body_view.size();
      if ((body_size > 1) && (trimmed_body_view.at(0) == '{') && (trimmed_body_view.at(body_size - 1) == '}')) {
         for(size_t idx=1; idx<body_size-1; ++idx)
         {
            if ((trimmed_body_view.at(idx) != ' ') && (trimmed_body_view.at(idx) != '\t'))
            {
               return false;
            }
         }
      } else {
         return false;
      }
      return true;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

is_ship()

bool sysio::is_ship ( uint64_t magic )

inline

Definition at line 42 of file log.hpp.

                                              {
   using namespace sysio::chain::literals;
   return (magic & 0xffff'ffff'0000'0000) == "ship"_n.to_uint64_t();
}

Here is the caller graph for this function:

is_ship_log_pruned()

bool sysio::is_ship_log_pruned ( uint64_t magic )

inline

Definition at line 51 of file log.hpp.

{ return get_ship_features(magic) & ship_feature_pruned_log; }

Here is the call graph for this function:

Here is the caller graph for this function:

is_ship_supported_version()

bool sysio::is_ship_supported_version ( uint64_t magic )

inline

Definition at line 48 of file log.hpp.

{ return get_ship_version(magic) == 0; }

Here is the call graph for this function:

Here is the caller graph for this function:

logger_name()

const fc::string sysio::logger_name

(

"net_plugin_impl"

)

Here is the caller graph for this function:

make_trimmed_string_view()

std::string_view sysio::make_trimmed_string_view ( const std::string & body )

inline

Definition at line 166 of file http_plugin.hpp.

                                                                         {
      if (body.empty()) {
         return {};
      }
      size_t left = 0;
      size_t right = body.size() - 1;
 
      while(left < right)
      {
         if (body[left] == ' ') {
            ++left;
         } else {
            break;
         }
      }
      while(left < right)
      {
         if (body[right] == ' ') {
            --right;
         } else {
            break;
         }
      }
      if ((left == right) && (body[left] == ' ')) {
         return {};
      }
      return std::string_view(body).substr(left, right-left+1);
   }

Here is the caller graph for this function:

modes_str()

auto sysio::modes_str ( id_list_modes m )

constexpr

Definition at line 99 of file protocol.hpp.

                                              {
    switch( m ) {
    case none : return "none";
    case catch_up : return "catch up";
    case last_irr_catch_up : return "last irreversible";
    case normal : return "normal";
    default: return "undefined mode";
    }
  }

Here is the caller graph for this function:

new_chain_banner()

void sysio::new_chain_banner

(

const sysio::chain::controller &

db

)

Definition at line 803 of file producer_plugin.cpp.

{
   std::cerr << "\n"
      "*******************************\n"
      "*                             *\n"
      "*   ------ NEW CHAIN ------   *\n"
      "*   -  Welcome to SYSIO!  -   *\n"
      "*   -----------------------   *\n"
      "*                             *\n"
      "*******************************\n"
      "\n";
 
   if( db.head_block_state()->header.timestamp.to_time_point() < (fc::time_point::now() - fc::milliseconds(200 * config::block_interval_ms)))
   {
      std::cerr << "Your genesis seems to have an old timestamp\n"
         "Please consider using the --genesis-timestamp option to give your genesis a recent timestamp\n"
         "\n"
         ;
   }
   return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

operator<<()

std::ostream & sysio::operator<<	(	std::ostream &	osm,
		https_ecdh_curve_t	curve )

Definition at line 1011 of file http_plugin.cpp.

                                                                     {
      if (curve == SECP384R1) {
         osm << "secp384r1";
      } else if (curve == PRIME256V1) {
         osm << "prime256v1";
      }
 
      return osm;
   }

operator>>()

std::istream & sysio::operator>>	(	std::istream &	in,
		https_ecdh_curve_t &	curve )

Definition at line 999 of file http_plugin.cpp.

                                                                     {
      std::string s;
      in >> s;
      if (s == "secp384r1")
         curve = SECP384R1;
      else if (s == "prime256v1")
         curve = PRIME256V1;
      else
         in.setstate(std::ios_base::failbit);
      return in;
   }

operator|=()

template<class enum_type , class = typename std::enable_if<std::is_enum<enum_type>::value>::type>

enum_type & sysio::operator|= ( enum_type & lhs, const enum_type & rhs )

inline

Definition at line 393 of file net_plugin.cpp.

   {
      using T = std::underlying_type_t <enum_type>;
      return lhs = static_cast<enum_type>(static_cast<T>(lhs) | static_cast<T>(rhs));
   }

parse_params()

template<typename T , http_params_types params_type>

T sysio::parse_params

(

const std::string &

body

)

Definition at line 222 of file http_plugin.hpp.

                                         {
      if constexpr (params_type == http_params_types::params_required) {
         if (is_empty_content(body)) {
            SYS_THROW(chain::invalid_http_request, "A Request body is required");
         }
      }
 
      try {
         try {
            if constexpr (params_type == http_params_types::no_params || params_type == http_params_types::possible_no_params) {
               if (is_empty_content(body)) {
                  if constexpr (std::is_same_v<T, std::string>) {
                     return std::string("{}");
                  }
                  return {};
               }
               if constexpr (params_type == http_params_types::no_params) {
                  SYS_THROW(chain::invalid_http_request, "no parameter should be given");
               }
            }
            return fc::json::from_string(body).as<T>();
         } catch (const chain::chain_exception& e) { // SYS_RETHROW_EXCEPTIONS does not re-type these so, re-code it
            throw fc::exception(e);
         }
      } SYS_RETHROW_EXCEPTIONS(chain::invalid_http_request, "Unable to parse valid input from POST body");
   }

Here is the call graph for this function:

parse_params< chain_apis::read_only::get_transaction_status_params, http_params_types::params_required >()

template<>

chain_apis::read_only::get_transaction_status_params sysio::parse_params< chain_apis::read_only::get_transaction_status_params, http_params_types::params_required >

(

const std::string &

body

)

Definition at line 36 of file chain_api_plugin.cpp.

                                                                                                                        {
   if (body.empty()) {
      SYS_THROW(chain::invalid_http_request, "A Request body is required");
   }
 
   try {
      auto v = fc::json::from_string( body ).as<chain_apis::read_only::get_transaction_status_params>();
      if( v.id == transaction_id_type() ) throw false;
      return v;
   } catch( ... ) {
      SYS_THROW(chain::invalid_http_request, "Invalid transaction id");
   }
}

Here is the call graph for this function:

read_builtin_protocol_feature()

std::optional< builtin_protocol_feature > sysio::read_builtin_protocol_feature

(

const fc::path &

p

)

Definition at line 425 of file chain_plugin.cpp.

                                                                                        {
   try {
      return fc::json::from_file<builtin_protocol_feature>( p );
   } catch( const fc::exception& e ) {
      wlog( "problem encountered while reading '${path}':\n${details}",
            ("path", p.generic_string())("details",e.to_detail_string()) );
   } catch( ... ) {
      dlog( "unknown problem encountered while reading '${path}'",
            ("path", p.generic_string()) );
   }
   return {};
}

Here is the call graph for this function:

Here is the caller graph for this function:

reason_str()

auto sysio::reason_str ( go_away_reason rsn )

constexpr

Definition at line 61 of file protocol.hpp.

                                                  {
    switch (rsn ) {
    case no_reason : return "no reason";
    case self : return "self connect";
    case duplicate : return "duplicate";
    case wrong_chain : return "wrong chain";
    case wrong_version : return "wrong version";
    case forked : return "chain is forked";
    case unlinkable : return "unlinkable block received";
    case bad_transaction : return "bad transaction";
    case validation : return "invalid block";
    case authentication : return "authentication failure";
    case fatal_other : return "some other failure";
    case benign_other : return "some other non-fatal condition, possibly unknown block";
    default : return "some crazy reason";
    }
  }

Here is the caller graph for this function:

ship_magic()

uint64_t sysio::ship_magic ( uint16_t version, uint16_t features = 0 )

inline

Definition at line 38 of file log.hpp.

                                                                          {
   using namespace sysio::chain::literals;
   return "ship"_n.to_uint64_t() | version | features<<16;
}

Here is the caller graph for this function:

verify_strand_in_this_thread()

template<typename Strand >

void sysio::verify_strand_in_this_thread	(	const Strand &	strand,
		const char *	func,
		int	line )

Definition at line 54 of file net_plugin.cpp.

                                                                                       {
      if( !strand.running_in_this_thread() ) {
         elog( "wrong strand: ${f} : line ${n}, exiting", ("f", func)("n", line) );
         app().quit();
      }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

def_conn_retry_wait

auto sysio::def_conn_retry_wait = 30

constexpr

Definition at line 208 of file net_plugin.cpp.

def_keepalive_interval

auto sysio::def_keepalive_interval = 10000

constexpr

Definition at line 212 of file net_plugin.cpp.

def_max_clients

auto sysio::def_max_clients = 25

constexpr

Definition at line 206 of file net_plugin.cpp.

def_max_consecutive_immediate_connection_close

auto sysio::def_max_consecutive_immediate_connection_close = 9

constexpr

Definition at line 205 of file net_plugin.cpp.

def_max_nodes_per_host

auto sysio::def_max_nodes_per_host = 1

constexpr

Definition at line 207 of file net_plugin.cpp.

def_max_trx_in_progress_size

auto sysio::def_max_trx_in_progress_size = 100*1024*1024

constexpr

Definition at line 204 of file net_plugin.cpp.

def_max_write_queue_size

auto sysio::def_max_write_queue_size = def_send_buffer_size*10

constexpr

Definition at line 203 of file net_plugin.cpp.

def_resp_expected_wait

auto sysio::def_resp_expected_wait = std::chrono::seconds(5)

constexpr

Definition at line 210 of file net_plugin.cpp.

def_send_buffer_size

auto sysio::def_send_buffer_size = 1024*1024*def_send_buffer_size_mb

constexpr

Definition at line 202 of file net_plugin.cpp.

def_send_buffer_size_mb

auto sysio::def_send_buffer_size_mb = 4

constexpr

default value initializers

Definition at line 201 of file net_plugin.cpp.

def_sync_fetch_span

auto sysio::def_sync_fetch_span = 100

constexpr

Definition at line 211 of file net_plugin.cpp.

def_txn_expire_wait

auto sysio::def_txn_expire_wait = std::chrono::seconds(3)

constexpr

Definition at line 209 of file net_plugin.cpp.

logger

fc::logger sysio::logger

Definition at line 355 of file net_plugin.cpp.

max_handshake_str_length

size_t sysio::max_handshake_str_length = 384

constexpr

Definition at line 25 of file protocol.hpp.

max_p2p_address_length

size_t sysio::max_p2p_address_length = 253 + 6

constexpr

Definition at line 24 of file protocol.hpp.

message_header_size

auto sysio::message_header_size = sizeof(uint32_t)

constexpr

Definition at line 214 of file net_plugin.cpp.

net_version_base

uint16_t sysio::net_version_base = 0x04b5

constexpr

For a while, network version was a 16 bit value equal to the second set of 16 bits of the current build's git commit id. We are now replacing that with an integer protocol identifier. Based on historical analysis of all git commit identifiers, the larges gap between ajacent commit id values is shown below. these numbers were found with the following commands on the master branch:

git log | grep "^commit" | awk '{print substr($2,5,4)}' | sort -u > sorted.txt rm -f gap.txt; prev=0; for a in $(cat sorted.txt); do echo $prev $((0x$a - 0x$prev)) $a >> gap.txt; prev=$a; done; sort -k2 -n gap.txt | tail

DO NOT EDIT net_version_base OR net_version_range!

Definition at line 413 of file net_plugin.cpp.

net_version_max

uint16_t sysio::net_version_max = proto_wire_sysio_initial

constexpr

Definition at line 431 of file net_plugin.cpp.

net_version_range

uint16_t sysio::net_version_range = 106

constexpr

Definition at line 414 of file net_plugin.cpp.

packed_transaction_which

uint32_t sysio::packed_transaction_which = fc::get_index<net_message, packed_transaction>()

constexpr

Definition at line 216 of file net_plugin.cpp.

peer_log_format

std::string sysio::peer_log_format

Definition at line 356 of file net_plugin.cpp.

proto_base

uint16_t sysio::proto_base = 0

constexpr

If there is a change to network protocol or behavior, increment net version to identify the need for compatibility hooks

Definition at line 421 of file net_plugin.cpp.

proto_block_id_notify

uint16_t sysio::proto_block_id_notify = 2

constexpr

Definition at line 423 of file net_plugin.cpp.

proto_dup_goaway_resolution

uint16_t sysio::proto_dup_goaway_resolution = 5

constexpr

Definition at line 426 of file net_plugin.cpp.

proto_dup_node_id_goaway

uint16_t sysio::proto_dup_node_id_goaway = 6

constexpr

Definition at line 427 of file net_plugin.cpp.

proto_explicit_sync

uint16_t sysio::proto_explicit_sync = 1

constexpr

Definition at line 422 of file net_plugin.cpp.

proto_heartbeat_interval

uint16_t sysio::proto_heartbeat_interval = 4

constexpr

Definition at line 425 of file net_plugin.cpp.

proto_pruned_types

uint16_t sysio::proto_pruned_types = 3

constexpr

Definition at line 424 of file net_plugin.cpp.

proto_wire_sysio_initial

uint16_t sysio::proto_wire_sysio_initial = 7

constexpr

Definition at line 428 of file net_plugin.cpp.

signed_block_which

uint32_t sysio::signed_block_which = fc::get_index<net_message, signed_block>()

constexpr

Definition at line 215 of file net_plugin.cpp.