sysio::trace_api::store_provider Class Reference

#include <store_provider.hpp>

Collaboration diagram for sysio::trace_api::store_provider:

Public Types
using	open_state = slice_directory::open_state

Public Member Functions
	store_provider (const boost::filesystem::path &slice_dir, uint32_t stride_width, std::optional< uint32_t > minimum_irreversible_history_blocks, std::optional< uint32_t > minimum_uncompressed_irreversible_history_blocks, size_t compression_seek_point_stride)
template<typename BlockTrace >
void	append (const BlockTrace &bt)
void	append_lib (uint32_t lib)
void	append_trx_ids (block_trxs_entry tt)
get_block_t	get_block (uint32_t block_height, const yield_function &yield={})
get_block_n	get_trx_block_number (const chain::transaction_id_type &trx_id, std::optional< uint32_t > minimum_irreversible_history_blocks, const yield_function &yield={})
void	start_maintenance_thread (log_handler log)
void	stop_maintenance_thread ()

Protected Member Functions
template<typename Fn >
uint64_t	scan_metadata_log_from (uint32_t block_height, uint64_t offset, Fn &&fn, const yield_function &yield)
std::optional< data_log_entry >	read_data_log (uint32_t block_height, uint64_t offset)
void	initialize_new_index_slice_file (fc::cfile &index)
void	validate_existing_index_slice_file (fc::cfile &index, open_state state)

Protected Attributes
slice_directory	_slice_directory

Detailed Description

Provides read and write access to block trace data.

Definition at line 264 of file store_provider.hpp.

Member Typedef Documentation

open_state

using sysio::trace_api::store_provider::open_state = slice_directory::open_state

Definition at line 266 of file store_provider.hpp.

Constructor & Destructor Documentation

store_provider()

sysio::trace_api::store_provider::store_provider	(	const boost::filesystem::path &	slice_dir,
		uint32_t	stride_width,
		std::optional< uint32_t >	minimum_irreversible_history_blocks,
		std::optional< uint32_t >	minimum_uncompressed_irreversible_history_blocks,
		size_t	compression_seek_point_stride )

Definition at line 34 of file store_provider.cpp.

   : _slice_directory(slice_dir, stride_width, minimum_irreversible_history_blocks, minimum_uncompressed_irreversible_history_blocks, compression_seek_point_stride) {
   }

Member Function Documentation

append()

template<typename BlockTrace >

template void sysio::trace_api::store_provider::append< block_trace_v2 >

(

const BlockTrace &

bt

)

Definition at line 40 of file store_provider.cpp.

                                                   {
      fc::cfile trace;
      fc::cfile index;
      const uint32_t slice_number = _slice_directory.slice_number(bt.number);
      _slice_directory.find_or_create_slice_pair(slice_number, open_state::write, trace, index);
      // storing as static_variant to allow adding other data types to the trace file in the future
      const uint64_t offset = append_store(data_log_entry { bt }, trace);
 
      auto be = metadata_log_entry { block_entry_v0 { .id = bt.id, .number = bt.number, .offset = offset }};
      append_store(be, index);
   }

Here is the call graph for this function:

append_lib()

void sysio::trace_api::store_provider::append_lib

(

uint32_t

lib

)

Definition at line 55 of file store_provider.cpp.

                                               {
      fc::cfile index, trx_id;
      const uint32_t slice_number = _slice_directory.slice_number(lib);
      _slice_directory.find_or_create_index_slice(slice_number, open_state::write, index);
      auto le = metadata_log_entry { lib_entry_v0 { .lib = lib }};
      append_store(le, index);
      _slice_directory.find_or_create_trx_id_slice(slice_number, open_state::write, trx_id);
      append_store(le, trx_id);
      _slice_directory.set_lib(lib);
   }

Here is the call graph for this function:

append_trx_ids()

void sysio::trace_api::store_provider::append_trx_ids

(

block_trxs_entry

tt

)

Definition at line 66 of file store_provider.cpp.

                                                         {
      fc::cfile trx_id_file;
      const uint32_t slice_number = _slice_directory.slice_number(tt.block_num);
      _slice_directory.find_or_create_trx_id_slice(slice_number, open_state::write, trx_id_file);
      auto entry = metadata_log_entry { std::move(tt) };
      append_store(entry, trx_id_file);
   }

Here is the call graph for this function:

get_block()

get_block_t sysio::trace_api::store_provider::get_block	(	uint32_t	block_height,
		const yield_function &	yield = {} )

Read the trace for a given block

Parameters

block_height

: the height of the data being read

Returns

empty optional if the data cannot be read OTHERWISE optional containing a 2-tuple of the block_trace and a flag indicating irreversibility

Definition at line 74 of file store_provider.cpp.

                                                                                           {
      std::optional<uint64_t> trace_offset;
      bool irreversible = false;
      scan_metadata_log_from(block_height, 0, [&block_height, &trace_offset, &irreversible](const metadata_log_entry& e) -> bool {
         if (std::holds_alternative<block_entry_v0>(e)) {
            const auto& block = std::get<block_entry_v0>(e);
            if (block.number == block_height) {
               trace_offset = block.offset;
            }
         } else if (std::holds_alternative<lib_entry_v0>(e)) {
            auto lib = std::get<lib_entry_v0>(e).lib;
            if (lib >= block_height) {
               irreversible = true;
               return false;
            }
         }
         return true;
      }, yield);
      if (!trace_offset) {
         return get_block_t{};
      }
      std::optional<data_log_entry> entry = read_data_log(block_height, *trace_offset);
      if (!entry) {
         return get_block_t{};
      }
      return std::make_tuple( entry.value(), irreversible );
   }

Here is the call graph for this function:

get_trx_block_number()

get_block_n sysio::trace_api::store_provider::get_trx_block_number	(	const chain::transaction_id_type &	trx_id,
		std::optional< uint32_t >	minimum_irreversible_history_blocks,
		const yield_function &	yield = {} )

Definition at line 102 of file store_provider.cpp.

                                                                                                                                                                                  {
      fc::cfile trx_id_file;
      int32_t slice_number;
      if (minimum_irreversible_history_blocks) {
         slice_number = _slice_directory.slice_number(*minimum_irreversible_history_blocks);
      } else {
         slice_number = 0;
      }
 
      uint32_t trx_block_num = 0; // number of the block that contains the target trx
      uint32_t trx_entries = 0;   // number of entries that contain the target trx
      while (true){
         const bool found = _slice_directory.find_trx_id_slice(slice_number, open_state::read, trx_id_file);
         if( !found )
            break; // traversed all slices
 
         metadata_log_entry entry;
         auto ds = trx_id_file.create_datastream();
         const uint64_t end = file_size(trx_id_file.get_file_path());
         uint64_t offset = trx_id_file.tellp();
         while (offset < end) {
            yield();
            fc::raw::unpack(ds, entry);
            if (std::holds_alternative<block_trxs_entry>(entry)) {
               const auto& trxs_entry = std::get<block_trxs_entry>(entry);
               for (auto i = 0U; i < trxs_entry.ids.size(); ++i) {
                  if (trxs_entry.ids[i] == trx_id) {
                     trx_entries++;
                     trx_block_num = trxs_entry.block_num;
                  }
               }
            } else if (std::holds_alternative<lib_entry_v0>(entry)) {
               auto lib = std::get<lib_entry_v0>(entry).lib;
               if (trx_entries > 0 && lib >= trx_block_num) {
                  return trx_block_num;
               }
            } else {
               FC_ASSERT( false, "unpacked data should be a block_trxs_entry or a lib_entry_v0" );;
            }
            offset = trx_id_file.tellp();
         }
         slice_number++;
      }
 
      // transaction's block is not irreversible
      if (trx_entries > 0)
         return trx_block_num;
 
      return get_block_n{};
   }

Here is the call graph for this function:

initialize_new_index_slice_file()

void sysio::trace_api::store_provider::initialize_new_index_slice_file ( fc::cfile & index )

protected

Initialize a new index slice with a valid header

Parameters

index

: index file to open and add header to

read_data_log()

std::optional< data_log_entry > sysio::trace_api::store_provider::read_data_log ( uint32_t block_height, uint64_t offset )

inlineprotected

Read from the data log

Parameters

block_height	: the block_height of the data being read
offset	: the offset in the datalog to read

Returns

empty optional if the data log does not exist, data otherwise

Exceptions

std::exception

: when the data is not the correct type or if the log is corrupt in some way

Definition at line 336 of file store_provider.hpp.

                                                                                          {
         const uint32_t slice_number = _slice_directory.slice_number(block_height);
 
         fc::cfile trace;
         if( !_slice_directory.find_trace_slice(slice_number, open_state::read, trace) ) {
            // attempt to read a compressed trace if one exists
            std::optional<compressed_file> ctrace = _slice_directory.find_compressed_trace_slice(slice_number);
            if (ctrace) {
               ctrace->seek(offset);
               return extract_store<data_log_entry>(*ctrace);
            }
 
            const std::string offset_str = boost::lexical_cast<std::string>(offset);
            const std::string bh_str = boost::lexical_cast<std::string>(block_height);
            throw malformed_slice_file("Requested offset: " + offset_str + " to retrieve block number: " + bh_str + " but this trace file is new, so there are no traces present.");
         }
         const uint64_t end = file_size(trace.get_file_path());
         if( offset >= end ) {
            const std::string offset_str = boost::lexical_cast<std::string>(offset);
            const std::string bh_str = boost::lexical_cast<std::string>(block_height);
            const std::string end_str = boost::lexical_cast<std::string>(end);
            throw malformed_slice_file("Requested offset: " + offset_str + " to retrieve block number: " + bh_str + " but this trace file only goes to offset: " + end_str);
         }
         trace.seek(offset);
         return extract_store<data_log_entry>(trace);
      }

Here is the call graph for this function:

Here is the caller graph for this function:

scan_metadata_log_from()

template<typename Fn >

uint64_t sysio::trace_api::store_provider::scan_metadata_log_from ( uint32_t block_height, uint64_t offset, Fn && fn, const yield_function & yield )

inlineprotected

Read the metadata log font-to-back starting at an offset passing each entry to a provided functor/lambda

Template Parameters

Fn	: type of the functor/lambda

Parameters

block_height	: height of the requested data
offset	: initial offset to read from
fn	: the functor/lambda

Returns

the highest offset read during this scan

Definition at line 304 of file store_provider.hpp.

                                                                                                                      {
         // ignoring offset
         offset = 0;
         fc::cfile index;
         const uint32_t slice_number = _slice_directory.slice_number(block_height);
         const bool found = _slice_directory.find_index_slice(slice_number, open_state::read, index);
         if( !found ) {
            return 0;
         }
         const uint64_t end = file_size(index.get_file_path());
         offset = index.tellp();
         uint64_t last_read_offset = offset;
         while (offset < end) {
            yield();
            const auto metadata = extract_store<metadata_log_entry>(index);
            if(! fn(metadata)) {
               break;
            }
            last_read_offset = offset;
            offset = index.tellp();
         }
         return last_read_offset;
      }

Here is the call graph for this function:

Here is the caller graph for this function:

start_maintenance_thread()

void sysio::trace_api::store_provider::start_maintenance_thread ( log_handler log )

inline

Definition at line 286 of file store_provider.hpp.

                                                       {
         _slice_directory.start_maintenance_thread( std::move(log) );
      }

Here is the call graph for this function:

stop_maintenance_thread()

void sysio::trace_api::store_provider::stop_maintenance_thread ( )

inline

Definition at line 289 of file store_provider.hpp.

                                     {
         _slice_directory.stop_maintenance_thread();
      }

Here is the call graph for this function:

validate_existing_index_slice_file()

void sysio::trace_api::store_provider::validate_existing_index_slice_file ( fc::cfile & index, open_state state )

protected

Ensure an existing index slice has a valid header

Parameters

index	: index file to open and read header from
state	: indicate if the file is going to be written to (appended) or read

Member Data Documentation

_slice_directory

slice_directory sysio::trace_api::store_provider::_slice_directory

protected

Definition at line 378 of file store_provider.hpp.

---

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

• plugins/trace_api_plugin/include/sysio/trace_api/store_provider.hpp
• plugins/trace_api_plugin/store_provider.cpp