sysio::trace_api Namespace Reference

Namespaces
namespace	configuration_utils
namespace	detail
namespace	test_common

Classes
class	abi_data_handler
struct	action_trace_v0
struct	action_trace_v1
struct	authorization_trace_v0
class	bad_data_exception
struct	block_entry_v0
struct	block_trace_v0
struct	block_trace_v1
struct	block_trace_v2
struct	block_trxs_entry
struct	cache_trace
class	chain_extraction_impl_type
struct	command_registration
class	compressed_file
class	compressed_file_datastream
class	compressed_file_error
struct	compressed_file_impl
class	incompatible_slice_files
struct	lib_entry_v0
class	malformed_slice_file
class	old_slice_version
class	path_does_not_exist
class	request_handler
class	slice_directory
class	store_provider
struct	transaction_trace_v0
struct	transaction_trace_v1
struct	transaction_trace_v2
struct	transaction_trace_v3
class	yield_exception

Typedefs
using	yield_function = fc::optional_delegate<void()>
using	exception_with_context = std::tuple<const std::exception_ptr&, char const *, uint64_t, char const *>
using	exception_handler = fc::optional_delegate<void(const exception_with_context&)>
using	log_handler = fc::optional_delegate<void(const std::string&)>
using	get_block_t = std::optional<std::tuple<data_log_entry, bool>>
using	get_block_n = std::optional<uint32_t>
using	data_log_entry
using	metadata_log_entry
using	data_handler_function = std::function<std::tuple<fc::variant, std::optional<fc::variant>>( const std::variant<action_trace_v0, action_trace_v1> & action_trace_t, const yield_function&)>
using	command_fn = std::function<int( const bpo::variables_map&, const std::vector<std::string>&)>

Functions
template<typename ActionTrace >
ActionTrace	to_action_trace (const chain::action_trace &at)
	Used by to_transaction_trace for creation of action_trace_v0 or action_trace_v1.
template<typename TransactionTrace >
TransactionTrace	to_transaction_trace (const cache_trace &t)
block_trace_v2	create_block_trace (const chain::block_state_ptr &bsp)
bool	operator== (const authorization_trace_v0 &lhs, const authorization_trace_v0 &rhs)
bool	operator== (const action_trace_v0 &lhs, const action_trace_v0 &rhs)
bool	operator== (const transaction_trace_v0 &lhs, const transaction_trace_v0 &rhs)
bool	operator== (const transaction_trace_v2 &lhs, const transaction_trace_v2 &rhs)
bool	operator== (const block_trace_v0 &lhs, const block_trace_v0 &rhs)
bool	operator== (const block_trace_v2 &lhs, const block_trace_v2 &rhs)
std::ostream &	operator<< (std::ostream &os, const block_trace_v0 &bt)
std::ostream &	operator<< (std::ostream &os, const block_trace_v2 &bt)
bool	operator== (const block_entry_v0 &lhs, const block_entry_v0 &rhs)
bool	operator!= (const block_entry_v0 &lhs, const block_entry_v0 &rhs)
bool	operator== (const lib_entry_v0 &lhs, const lib_entry_v0 &rhs)
bool	operator!= (const lib_entry_v0 &lhs, const lib_entry_v0 &rhs)
std::ostream &	operator<< (std::ostream &os, const block_entry_v0 &be)
std::ostream &	operator<< (std::ostream &os, const lib_entry_v0 &le)

Typedef Documentation

command_fn

using sysio::trace_api::command_fn = std::function<int( const bpo::variables_map&, const std::vector<std::string>&)>

passes global opts and then the remaining command line

Definition at line 15 of file cmd_registration.hpp.

data_handler_function

using sysio::trace_api::data_handler_function = std::function<std::tuple<fc::variant, std::optional<fc::variant>>( const std::variant<action_trace_v0, action_trace_v1> & action_trace_t, const yield_function&)>

Definition at line 9 of file request_handler.hpp.

data_log_entry

using sysio::trace_api::data_log_entry

Initial value:

 std::variant<
      block_trace_v0,
      block_trace_v1,
      block_trace_v2
   >

Definition at line 9 of file data_log.hpp.

exception_handler

using sysio::trace_api::exception_handler = fc::optional_delegate<void(const exception_with_context&)>

Definition at line 41 of file common.hpp.

exception_with_context

using sysio::trace_api::exception_with_context = std::tuple<const std::exception_ptr&, char const *, uint64_t, char const *>

Definition at line 40 of file common.hpp.

get_block_n

using sysio::trace_api::get_block_n = std::optional<uint32_t>

Definition at line 51 of file common.hpp.

get_block_t

using sysio::trace_api::get_block_t = std::optional<std::tuple<data_log_entry, bool>>

Definition at line 49 of file common.hpp.

log_handler

using sysio::trace_api::log_handler = fc::optional_delegate<void(const std::string&)>

Definition at line 43 of file common.hpp.

metadata_log_entry

using sysio::trace_api::metadata_log_entry

Initial value:

 std::variant<
      block_entry_v0,
      lib_entry_v0,
      block_trxs_entry
   >

Definition at line 18 of file metadata_log.hpp.

yield_function

using sysio::trace_api::yield_function = fc::optional_delegate<void()>

A function used to separate cooperative or external concerns from long running tasks calling code should expect that this can throw yield_exception and gracefully unwind if it does

Exceptions

yield_exception

if the provided yield needs to terminate the long running process for any reason

Definition at line 13 of file common.hpp.

Function Documentation

create_block_trace()

block_trace_v2 sysio::trace_api::create_block_trace ( const chain::block_state_ptr & bsp )

inline

Definition at line 66 of file extract_util.hpp.

                                                                            {
   block_trace_v2 r;
   r.id = bsp->id;
   r.number = bsp->block_num;
   r.previous_id = bsp->block->previous;
   r.timestamp = bsp->block->timestamp;
   r.producer = bsp->block->producer;
   r.schedule_version = bsp->block->schedule_version;
   r.transaction_mroot = bsp->block->transaction_mroot;
   r.action_mroot = bsp->block->action_mroot;
   return r;
}

operator!=() [1/2]

bool sysio::trace_api::operator!=	(	const block_entry_v0 &	lhs,
		const block_entry_v0 &	rhs )

Definition at line 223 of file test_common.hpp.

                                                                         {
      return !(lhs == rhs);
   }

operator!=() [2/2]

bool sysio::trace_api::operator!=	(	const lib_entry_v0 &	lhs,
		const lib_entry_v0 &	rhs )

Definition at line 232 of file test_common.hpp.

                                                                     {
      return !(lhs == rhs);
   }

operator<<() [1/4]

std::ostream & sysio::trace_api::operator<<	(	std::ostream &	os,
		const block_entry_v0 &	be )

Definition at line 236 of file test_common.hpp.

                                                                    {
      os << fc::json::to_string(be, fc::time_point::maximum());
      return os;
   }

Here is the call graph for this function:

operator<<() [2/4]

std::ostream & sysio::trace_api::operator<<	(	std::ostream &	os,
		const block_trace_v0 &	bt )

Definition at line 206 of file test_common.hpp.

                                                                    {
      os << fc::json::to_string( bt, fc::time_point::maximum() );
      return os;
   }

Here is the call graph for this function:

operator<<() [3/4]

std::ostream & sysio::trace_api::operator<<	(	std::ostream &	os,
		const block_trace_v2 &	bt )

Definition at line 211 of file test_common.hpp.

                                                                    {
      os << fc::json::to_string( bt, fc::time_point::maximum() );
      return os;
   }

Here is the call graph for this function:

operator<<() [4/4]

std::ostream & sysio::trace_api::operator<<	(	std::ostream &	os,
		const lib_entry_v0 &	le )

Definition at line 241 of file test_common.hpp.

                                                                  {
      os << fc::json::to_string(le, fc::time_point::maximum());
      return os;
   }

Here is the call graph for this function:

operator==() [1/8]

bool sysio::trace_api::operator==	(	const action_trace_v0 &	lhs,
		const action_trace_v0 &	rhs )

Definition at line 151 of file test_common.hpp.

                                                                           {
      return
         lhs.global_sequence == rhs.global_sequence &&
         lhs.receiver == rhs.receiver &&
         lhs.account == rhs.account &&
         lhs.action == rhs.action &&
         lhs.authorization == rhs.authorization &&
         lhs.data == rhs.data;
   }

operator==() [2/8]

bool sysio::trace_api::operator==	(	const authorization_trace_v0 &	lhs,
		const authorization_trace_v0 &	rhs )

Definition at line 145 of file test_common.hpp.

                                                                                         {
      return
         lhs.account == rhs.account &&
         lhs.permission == rhs.permission;
   }

operator==() [3/8]

bool sysio::trace_api::operator==	(	const block_entry_v0 &	lhs,
		const block_entry_v0 &	rhs )

Definition at line 216 of file test_common.hpp.

                                                                         {
      return
         lhs.id == rhs.id &&
         lhs.number == rhs.number &&
         lhs.offset == rhs.offset;
   }

operator==() [4/8]

bool sysio::trace_api::operator==	(	const block_trace_v0 &	lhs,
		const block_trace_v0 &	rhs )

Definition at line 183 of file test_common.hpp.

                                                                         {
      return
         lhs.id == rhs.id &&
         lhs.number == rhs.number &&
         lhs.previous_id == rhs.previous_id &&
         lhs.timestamp == rhs.timestamp &&
         lhs.producer == rhs.producer &&
         lhs.transactions == rhs.transactions;
   }

operator==() [5/8]

bool sysio::trace_api::operator==	(	const block_trace_v2 &	lhs,
		const block_trace_v2 &	rhs )

Definition at line 193 of file test_common.hpp.

                                                                         {
      return
         lhs.id == rhs.id &&
         lhs.number == rhs.number &&
         lhs.previous_id == rhs.previous_id &&
         lhs.timestamp == rhs.timestamp &&
         lhs.producer == rhs.producer &&
         lhs.transaction_mroot == rhs.transaction_mroot &&
         lhs.action_mroot == rhs.action_mroot &&
         lhs.schedule_version == rhs.schedule_version &&
         lhs.transactions == rhs.transactions;
   }

operator==() [6/8]

bool sysio::trace_api::operator==	(	const lib_entry_v0 &	lhs,
		const lib_entry_v0 &	rhs )

Definition at line 227 of file test_common.hpp.

                                                                     {
      return
         lhs.lib == rhs.lib;
   }

operator==() [7/8]

bool sysio::trace_api::operator==	(	const transaction_trace_v0 &	lhs,
		const transaction_trace_v0 &	rhs )

Definition at line 161 of file test_common.hpp.

                                                                                      {
      return
         lhs.id == rhs.id &&
         lhs.actions == rhs.actions;
   }

operator==() [8/8]

bool sysio::trace_api::operator==	(	const transaction_trace_v2 &	lhs,
		const transaction_trace_v2 &	rhs )

Definition at line 167 of file test_common.hpp.

                                                                                      {
      return
         lhs.id == rhs.id &&
         lhs.actions == rhs.actions &&
         lhs.status == rhs.status &&
         lhs.cpu_usage_us == rhs.cpu_usage_us &&
         lhs.net_usage_words == rhs.net_usage_words &&
         lhs.signatures == rhs.signatures &&
         lhs.trx_header.expiration == rhs.trx_header.expiration &&
         lhs.trx_header.ref_block_num == rhs.trx_header.ref_block_num &&
         lhs.trx_header.ref_block_prefix == rhs.trx_header.ref_block_prefix &&
         lhs.trx_header.max_net_usage_words == rhs.trx_header.max_net_usage_words &&
         lhs.trx_header.max_cpu_usage_ms == rhs.trx_header.max_cpu_usage_ms &&
         lhs.trx_header.delay_sec == rhs.trx_header.delay_sec ;
   }

to_action_trace()

template<typename ActionTrace >

ActionTrace sysio::trace_api::to_action_trace ( const chain::action_trace & at )

inline

Definition at line 10 of file extract_util.hpp.

                                                                  {
   ActionTrace r;
   r.receiver = at.receiver;
   r.account = at.act.account;
   r.action = at.act.name;
   r.data = at.act.data;
   if constexpr(std::is_same_v<ActionTrace, action_trace_v1>) {
      r.return_value = at.return_value;
   }
   if( at.receipt ) {
      r.global_sequence = at.receipt->global_sequence;
   }
   r.authorization.reserve( at.act.authorization.size());
   for( const auto& auth : at.act.authorization ) {
      r.authorization.emplace_back( authorization_trace_v0{auth.actor, auth.permission} );
   }
   return r;
}

Here is the caller graph for this function:

to_transaction_trace()

template<typename TransactionTrace >

TransactionTrace sysio::trace_api::to_transaction_trace ( const cache_trace & t )

inline

Definition at line 30 of file extract_util.hpp.

                                                                     {
   TransactionTrace r;
   if( !t.trace->failed_dtrx_trace ) {
      r.id = t.trace->id;
   } else {
      r.id = t.trace->failed_dtrx_trace->id; // report the failed trx id since that is the id known to user
   }
   if constexpr(std::is_same_v<TransactionTrace, transaction_trace_v1>  ||
                std::is_same_v<TransactionTrace, transaction_trace_v2>  ||
                std::is_same_v<TransactionTrace, transaction_trace_v3>) {
      if (t.trace->receipt) {
         r.status = t.trace->receipt->status;
         r.cpu_usage_us = t.trace->receipt->cpu_usage_us;
         r.net_usage_words = t.trace->receipt->net_usage_words;
      }
      r.signatures = t.trx->get_signatures();
      r.trx_header = static_cast<const chain::transaction_header&>( t.trx->get_transaction() );
 
      r.block_num = t.trace->block_num;
      r.block_time = t.trace->block_time;
      r.producer_block_id = t.trace->producer_block_id;
   }
 
   using action_trace_t = std::conditional_t<std::is_same_v<TransactionTrace, transaction_trace_v2> ||
                                             std::is_same_v<TransactionTrace, transaction_trace_v3>
                                             , action_trace_v1, action_trace_v0>;
   r.actions = std::vector<action_trace_t>();
   std::get<std::vector<action_trace_t>>(r.actions).reserve( t.trace->action_traces.size());
   for( const auto& at : t.trace->action_traces ) {
      if( !at.context_free ) { // not including CFA at this time
         std::get<std::vector<action_trace_t>>(r.actions).emplace_back( to_action_trace<action_trace_t>(at) );
      }
   }
   return r;
}

Here is the call graph for this function: