sysio::state_history_log Class Reference

#include <log.hpp>

Public Member Functions
	state_history_log (const char *const name, std::string log_filename, std::string index_filename, std::optional< state_history_log_prune_config > prune_conf=std::optional< state_history_log_prune_config >())
	~state_history_log ()
uint32_t	begin_block () const
uint32_t	end_block () const
void	read_header (state_history_log_header &header, bool assert_version=true)
void	write_header (const state_history_log_header &header)
template<typename F >
void	write_entry (state_history_log_header header, const chain::block_id_type &prev_id, F write_payload)
fc::cfile &	get_entry (uint32_t block_num, state_history_log_header &header)
chain::block_id_type	get_block_id (uint32_t block_num)

Detailed Description

Definition at line 68 of file log.hpp.

Constructor & Destructor Documentation

state_history_log()

sysio::state_history_log::state_history_log ( const char *const name, std::string log_filename, std::string index_filename, std::optional< state_history_log_prune_config > prune_conf = std::optional<state_history_log_prune_config>() )

inline

Definition at line 82 of file log.hpp.

       : name(name)
       , log_filename(std::move(log_filename))
       , index_filename(std::move(index_filename))
       , prune_config(prune_conf) {
      open_log();
      open_index();
 
      if(prune_config) {
         SYS_ASSERT(prune_config->prune_blocks, chain::plugin_exception, "state history log prune configuration requires at least one block");
         SYS_ASSERT(__builtin_popcount(prune_config->prune_threshold) == 1, chain::plugin_exception, "state history prune threshold must be power of 2");
         //switch this over to the mask that will be used
         prune_config->prune_threshold = ~(prune_config->prune_threshold-1);
      }
 
      //check for conversions to/from pruned log, as long as log contains something
      if(_begin_block != _end_block) {
         state_history_log_header first_header;
         log.seek(0);
         read_header(first_header);
 
         if((is_ship_log_pruned(first_header.magic) == false) && prune_config) {
            //need to convert non-pruned to pruned; first prune any ranges we can (might be none)
            prune(fc::log_level::info);
 
            //update first header to indicate prune feature is enabled
            log.seek(0);
            first_header.magic = ship_magic(get_ship_version(first_header.magic), ship_feature_pruned_log);
            write_header(first_header);
 
            //write trailer on log with num blocks
            log.seek_end(0);
            const uint32_t num_blocks_in_log = _end_block - _begin_block;
            fc::raw::pack(log, num_blocks_in_log);
         }
         else if(is_ship_log_pruned(first_header.magic) && !prune_config) {
            vacuum();
         }
      }
   }

Here is the call graph for this function:

~state_history_log()

sysio::state_history_log::~state_history_log ( )

inline

Definition at line 124 of file log.hpp.

                        {
      //nothing to do if log is empty or we aren't pruning
      if(_begin_block == _end_block)
         return;
      if(!prune_config || !prune_config->vacuum_on_close)
         return;
 
      const size_t first_data_pos = get_pos(_begin_block);
      const size_t last_data_pos = fc::file_size(log.get_file_path());
      if(last_data_pos - first_data_pos < *prune_config->vacuum_on_close)
         vacuum();
   }

Here is the call graph for this function:

Member Function Documentation

begin_block()

uint32_t sysio::state_history_log::begin_block ( ) const

inline

Definition at line 137 of file log.hpp.

{ return _begin_block; }

end_block()

uint32_t sysio::state_history_log::end_block ( ) const

inline

Definition at line 138 of file log.hpp.

{ return _end_block; }

get_block_id()

chain::block_id_type sysio::state_history_log::get_block_id ( uint32_t block_num )

inline

Definition at line 219 of file log.hpp.

                                                       {
      state_history_log_header header;
      get_entry(block_num, header);
      return header.block_id;
   }

Here is the call graph for this function:

get_entry()

fc::cfile & sysio::state_history_log::get_entry ( uint32_t block_num, state_history_log_header & header )

inline

Definition at line 211 of file log.hpp.

                                                                            {
      SYS_ASSERT(block_num >= _begin_block && block_num < _end_block, chain::plugin_exception,
                 "read non-existing block in ${name}.log", ("name", name));
      log.seek(get_pos(block_num));
      read_header(header);
      return log;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

read_header()

void sysio::state_history_log::read_header ( state_history_log_header & header, bool assert_version = true )

inline

Definition at line 140 of file log.hpp.

                                                                                  {
      char bytes[state_history_log_header_serial_size];
      log.read(bytes, sizeof(bytes));
      fc::datastream<const char*> ds(bytes, sizeof(bytes));
      fc::raw::unpack(ds, header);
      SYS_ASSERT(!ds.remaining(), chain::plugin_exception, "state_history_log_header_serial_size mismatch");
      if (assert_version)
         SYS_ASSERT(is_ship(header.magic) && is_ship_supported_version(header.magic), chain::plugin_exception,
                    "corrupt ${name}.log (0)", ("name", name));
   }

Here is the call graph for this function:

Here is the caller graph for this function:

write_entry()

template<typename F >

void sysio::state_history_log::write_entry ( state_history_log_header header, const chain::block_id_type & prev_id, F write_payload )

inline

Definition at line 160 of file log.hpp.

                                                                                                         {
      auto block_num = chain::block_header::num_from_id(header.block_id);
      SYS_ASSERT(_begin_block == _end_block || block_num <= _end_block, chain::plugin_exception,
                 "missed a block in ${name}.log", ("name", name));
 
      if (_begin_block != _end_block && block_num > _begin_block) {
         if (block_num == _end_block) {
            SYS_ASSERT(prev_id == last_block_id, chain::plugin_exception, "missed a fork change in ${name}.log",
                       ("name", name));
         } else {
            state_history_log_header prev;
            get_entry(block_num - 1, prev);
            SYS_ASSERT(prev_id == prev.block_id, chain::plugin_exception, "missed a fork change in ${name}.log",
                       ("name", name));
         }
      }
 
      if (block_num < _end_block)
         truncate(block_num); //truncate is expected to always leave file pointer at the end
      else if (!prune_config)
         log.seek_end(0);
      else if (prune_config && _begin_block != _end_block)
         log.seek_end(-sizeof(uint32_t));  //overwrite the trailing block count marker on this write
 
      //if we're operating on a pruned block log and this is the first entry in the log, make note of the feature in the header
      if(prune_config && _begin_block == _end_block)
         header.magic = ship_magic(get_ship_version(header.magic), ship_feature_pruned_log);
 
      uint64_t pos = log.tellp();
      write_header(header);
      write_payload(log);
      SYS_ASSERT(log.tellp() == pos + state_history_log_header_serial_size + header.payload_size, chain::plugin_exception,
                 "wrote payload with incorrect size to ${name}.log", ("name", name));
      fc::raw::pack(log, pos);
 
      fc::raw::pack(index, pos);
      if (_begin_block == _end_block)
         _index_begin_block = _begin_block = block_num;
      _end_block    = block_num + 1;
      last_block_id = header.block_id;
 
      if(prune_config) {
         if((pos&prune_config->prune_threshold) != (log.tellp()&prune_config->prune_threshold))
            prune(fc::log_level::debug);
 
         const uint32_t num_blocks_in_log = _end_block - _begin_block;
         fc::raw::pack(log, num_blocks_in_log);
      }
   }

Here is the call graph for this function:

write_header()

void sysio::state_history_log::write_header ( const state_history_log_header & header )

inline

Definition at line 151 of file log.hpp.

                                                             {
      char                  bytes[state_history_log_header_serial_size];
      fc::datastream<char*> ds(bytes, sizeof(bytes));
      fc::raw::pack(ds, header);
      SYS_ASSERT(!ds.remaining(), chain::plugin_exception, "state_history_log_header_serial_size mismatch");
      log.write(bytes, sizeof(bytes));
   }

Here is the call graph for this function:

Here is the caller graph for this function:

---

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

• libraries/state_history/include/sysio/state_history/log.hpp