sysio::state_history Namespace Reference

Classes
struct	augmented_transaction_trace
struct	big_vector_wrapper
struct	block_position
struct	get_blocks_ack_request_v0
struct	get_blocks_request_v0
struct	get_blocks_result_v0
struct	get_status_request_v0
struct	get_status_result_v0
struct	partial_transaction
struct	table_delta
struct	trace_converter

Typedefs
using	state_request = std::variant<get_status_request_v0, get_blocks_request_v0, get_blocks_ack_request_v0>
using	state_result = std::variant<get_status_result_v0, get_blocks_result_v0>

Functions
bytes	zlib_compress_bytes (const bytes &in)
bytes	zlib_decompress (const bytes &in)
template<typename T >
bool	include_delta (const T &old, const T &curr)
bool	include_delta (const chain::table_id_object &old, const chain::table_id_object &curr)
bool	include_delta (const chain::resource_limits::resource_limits_object &old, const chain::resource_limits::resource_limits_object &curr)
bool	include_delta (const chain::resource_limits::resource_limits_state_object &old, const chain::resource_limits::resource_limits_state_object &curr)
bool	include_delta (const chain::account_metadata_object &old, const chain::account_metadata_object &curr)
bool	include_delta (const chain::code_object &old, const chain::code_object &curr)
bool	include_delta (const chain::protocol_state_object &old, const chain::protocol_state_object &curr)
std::vector< table_delta >	create_deltas (const chainbase::database &db, bool full_snapshot)

Typedef Documentation

state_request

using sysio::state_history::state_request = std::variant<get_status_request_v0, get_blocks_request_v0, get_blocks_ack_request_v0>

Definition at line 114 of file types.hpp.

state_result

using sysio::state_history::state_result = std::variant<get_status_result_v0, get_blocks_result_v0>

Definition at line 115 of file types.hpp.

Function Documentation

create_deltas()

std::vector< table_delta > sysio::state_history::create_deltas	(	const chainbase::database &	db,
		bool	full_snapshot )

Definition at line 58 of file create_deltas.cpp.

                                                                                      {
   std::vector<table_delta>                          deltas;
   const auto&                                       table_id_index = db.get_index<chain::table_id_multi_index>();
   std::map<uint64_t, const chain::table_id_object*> removed_table_id;
   for (auto& rem : table_id_index.last_undo_session().removed_values)
      removed_table_id[rem.id._id] = &rem;
 
   auto get_table_id = [&](uint64_t tid) -> const chain::table_id_object& {
      auto obj = table_id_index.find(tid);
      if (obj)
         return *obj;
      auto it = removed_table_id.find(tid);
      SYS_ASSERT(it != removed_table_id.end(), chain::plugin_exception, "can not found table id ${tid}", ("tid", tid));
      return *it->second;
   };
 
   auto pack_row          = [&](auto& row) { return fc::raw::pack(make_history_serial_wrapper(db, row)); };
   auto pack_contract_row = [&](auto& row) {
      return fc::raw::pack(make_history_context_wrapper(db, get_table_id(row.t_id._id), row));
   };
 
   auto process_table = [&](auto* name, auto& index, auto& pack_row) {
      if (full_snapshot) {
         if (index.indices().empty())
            return;
         deltas.push_back({});
         auto& delta = deltas.back();
         delta.name  = name;
         for (auto& row : index.indices())
            delta.rows.obj.emplace_back(true, pack_row(row));
      } else {
         auto undo = index.last_undo_session();
         if (undo.old_values.empty() && undo.new_values.empty() && undo.removed_values.empty())
            return;
         deltas.push_back({});
         auto& delta = deltas.back();
         delta.name  = name;
         for (auto& old : undo.old_values) {
            auto& row = index.get(old.id);
            if (include_delta(old, row))
               delta.rows.obj.emplace_back(true, pack_row(row));
         }
         for (auto& old : undo.removed_values)
            delta.rows.obj.emplace_back(false, pack_row(old));
         for (auto& row : undo.new_values) {
            delta.rows.obj.emplace_back(true, pack_row(row));
         }
      }
   };
 
   process_table("account", db.get_index<chain::account_index>(), pack_row);
   process_table("account_metadata", db.get_index<chain::account_metadata_index>(), pack_row);
   process_table("code", db.get_index<chain::code_index>(), pack_row);
 
   process_table("contract_table", db.get_index<chain::table_id_multi_index>(), pack_row);
   process_table("contract_row", db.get_index<chain::key_value_index>(), pack_contract_row);
   process_table("contract_index64", db.get_index<chain::index64_index>(), pack_contract_row);
   process_table("contract_index128", db.get_index<chain::index128_index>(), pack_contract_row);
   process_table("contract_index256", db.get_index<chain::index256_index>(), pack_contract_row);
   process_table("contract_index_double", db.get_index<chain::index_double_index>(), pack_contract_row);
   process_table("contract_index_long_double", db.get_index<chain::index_long_double_index>(), pack_contract_row);
 
   process_table("global_property", db.get_index<chain::global_property_multi_index>(), pack_row);
   process_table("generated_transaction", db.get_index<chain::generated_transaction_multi_index>(), pack_row);
   process_table("protocol_state", db.get_index<chain::protocol_state_multi_index>(), pack_row);
 
   process_table("permission", db.get_index<chain::permission_index>(), pack_row);
   process_table("permission_link", db.get_index<chain::permission_link_index>(), pack_row);
 
   process_table("resource_limits", db.get_index<chain::resource_limits::resource_limits_index>(), pack_row);
   process_table("resource_usage", db.get_index<chain::resource_limits::resource_usage_index>(), pack_row);
   process_table("resource_limits_state", db.get_index<chain::resource_limits::resource_limits_state_index>(),
                 pack_row);
   process_table("resource_limits_config", db.get_index<chain::resource_limits::resource_limits_config_index>(),
                 pack_row);
 
   return deltas;
}

Here is the call graph for this function:

Here is the caller graph for this function:

include_delta() [1/7]

bool sysio::state_history::include_delta	(	const chain::account_metadata_object &	old,
		const chain::account_metadata_object &	curr )

Definition at line 40 of file create_deltas.cpp.

                                                                                                      {
   return                                               //
       old.name != curr.name ||                         //
       old.is_privileged() != curr.is_privileged() ||   //
       old.last_code_update != curr.last_code_update || //
       old.vm_type != curr.vm_type ||                   //
       old.vm_version != curr.vm_version ||             //
       old.code_hash != curr.code_hash;
}

include_delta() [2/7]

bool sysio::state_history::include_delta	(	const chain::code_object &	old,
		const chain::code_object &	curr )

Definition at line 50 of file create_deltas.cpp.

                                                                              { //
   return false;
}

include_delta() [3/7]

bool sysio::state_history::include_delta	(	const chain::protocol_state_object &	old,
		const chain::protocol_state_object &	curr )

Definition at line 54 of file create_deltas.cpp.

                                                                                                  {
   return old.activated_protocol_features != curr.activated_protocol_features;
}

include_delta() [4/7]

bool sysio::state_history::include_delta	(	const chain::resource_limits::resource_limits_object &	old,
		const chain::resource_limits::resource_limits_object &	curr )

Definition at line 16 of file create_deltas.cpp.

                                                                           {
   return                                   //
       old.net_weight != curr.net_weight || //
       old.cpu_weight != curr.cpu_weight || //
       old.ram_bytes != curr.ram_bytes;
}

include_delta() [5/7]

bool sysio::state_history::include_delta	(	const chain::resource_limits::resource_limits_state_object &	old,
		const chain::resource_limits::resource_limits_state_object &	curr )

Definition at line 24 of file create_deltas.cpp.

                                                                                 {
   return                                                                                       //
       old.average_block_net_usage.last_ordinal != curr.average_block_net_usage.last_ordinal || //
       old.average_block_net_usage.value_ex != curr.average_block_net_usage.value_ex ||         //
       old.average_block_net_usage.consumed != curr.average_block_net_usage.consumed ||         //
       old.average_block_cpu_usage.last_ordinal != curr.average_block_cpu_usage.last_ordinal || //
       old.average_block_cpu_usage.value_ex != curr.average_block_cpu_usage.value_ex ||         //
       old.average_block_cpu_usage.consumed != curr.average_block_cpu_usage.consumed ||         //
       old.total_net_weight != curr.total_net_weight ||                                         //
       old.total_cpu_weight != curr.total_cpu_weight ||                                         //
       old.total_ram_bytes != curr.total_ram_bytes ||                                           //
       old.virtual_net_limit != curr.virtual_net_limit ||                                       //
       old.virtual_cpu_limit != curr.virtual_cpu_limit;
}

include_delta() [6/7]

bool sysio::state_history::include_delta	(	const chain::table_id_object &	old,
		const chain::table_id_object &	curr )

Definition at line 12 of file create_deltas.cpp.

                                                                                      {
   return old.payer != curr.payer;
}

include_delta() [7/7]

template<typename T >

bool sysio::state_history::include_delta	(	const T &	old,
		const T &	curr )

Definition at line 8 of file create_deltas.cpp.

                                                {
   return true;
}

Here is the caller graph for this function:

zlib_compress_bytes()

bytes sysio::state_history::zlib_compress_bytes

(

const bytes &

in

)

Definition at line 11 of file compression.cpp.

                                           {
   bytes                  out;
   bio::filtering_ostream comp;
   comp.push(bio::zlib_compressor(bio::zlib::default_compression));
   comp.push(bio::back_inserter(out));
   bio::write(comp, in.data(), in.size());
   bio::close(comp);
   return out;
}

Here is the caller graph for this function:

zlib_decompress()

bytes sysio::state_history::zlib_decompress

(

const bytes &

in

)

Definition at line 21 of file compression.cpp.

                                       {
   bytes                  out;
   bio::filtering_ostream decomp;
   decomp.push(bio::zlib_decompressor());
   decomp.push(bio::back_inserter(out));
   bio::write(decomp, in.data(), in.size());
   bio::close(decomp);
   return out;
}

Here is the caller graph for this function: