sysio::chain::detail::reverse_iterator Class Reference

Public Member Functions
	reverse_iterator ()
uint32_t	open (const fc::path &block_file_name)
uint64_t	previous ()
uint32_t	version () const
uint32_t	first_block_num () const

Static Public Attributes
static uint32_t	_buf_len = 1U << 24

Detailed Description

Definition at line 146 of file block_log.cpp.

Constructor & Destructor Documentation

reverse_iterator()

sysio::chain::detail::reverse_iterator::reverse_iterator

(

)

Definition at line 1009 of file block_log.cpp.

   : _file(nullptr, &fclose)
   , _buffer_ptr(std::make_unique<char[]>(_buf_len)) {
   }

Member Function Documentation

first_block_num()

uint32_t sysio::chain::detail::reverse_iterator::first_block_num ( ) const

inline

Definition at line 153 of file block_log.cpp.

{ return _first_block_num; }

Here is the caller graph for this function:

open()

uint32_t sysio::chain::detail::reverse_iterator::open

(

const fc::path &

block_file_name

)

Definition at line 1016 of file block_log.cpp.

                                                                      {
      _block_file_name = block_file_name.generic_string();
      _file.reset( FC_FOPEN(_block_file_name.c_str(), "r"));
      SYS_ASSERT( _file, block_log_exception, "Could not open Block log file at '${blocks_log}'", ("blocks_log", _block_file_name) );
      _end_of_buffer_position = _unset_position;
 
      //read block log to see if version 1 or 2 and get first blocknum (implicit 1 if version 1)
      _version = 0;
      auto size = fread((char*)&_version, sizeof(_version), 1, _file.get());
      SYS_ASSERT( size == 1, block_log_exception, "Block log file at '${blocks_log}' could not be read.", ("file", _block_file_name) );
      const bool is_prune_log = is_pruned_log_and_mask_version(_version);
      SYS_ASSERT( block_log::is_supported_version(_version), block_log_unsupported_version,
                  "block log version ${v} is not supported", ("v", _version));
      if (_version == 1) {
         _first_block_num = 1;
      }
      else {
         size = fread((char*)&_first_block_num, sizeof(_first_block_num), 1, _file.get());
         SYS_ASSERT( size == 1, block_log_exception, "Block log file at '${blocks_log}' not formatted consistently with version ${v}.", ("file", _block_file_name)("v", _version) );
      }
 
      auto status = fseek(_file.get(), 0, SEEK_END);
      SYS_ASSERT( status == 0, block_log_exception, "Could not open Block log file at '${blocks_log}'. Returned status: ${status}", ("blocks_log", _block_file_name)("status", status) );
 
      auto eof_position_in_file = ftell(_file.get());
      SYS_ASSERT( eof_position_in_file > 0, block_log_exception, "Block log file at '${blocks_log}' could not be read.", ("blocks_log", _block_file_name) );
 
      if(is_prune_log) {
         fseek(_file.get(), -sizeof(uint32_t), SEEK_CUR);
         uint32_t prune_count;
         size = fread((char*)&prune_count, sizeof(prune_count), 1, _file.get());
         SYS_ASSERT( size == 1, block_log_exception, "Block log file at '${blocks_log}' not formatted consistently with pruned version ${v}.", ("file", _block_file_name)("v", _version) );
         _prune_block_limit = prune_count;
         eof_position_in_file -= sizeof(prune_count);
      }
 
      _current_position_in_file = eof_position_in_file - _position_size;
 
      update_buffer();
 
      _blocks_found = 0;
      char* buf = _buffer_ptr.get();
      const uint32_t index_of_pos = _current_position_in_file - _start_of_buffer_position;
      const uint64_t block_pos = *reinterpret_cast<uint64_t*>(buf + index_of_pos);
 
      if (block_pos == block_log::npos) {
         return 0;
      }
 
      uint32_t bnum = 0;
      if (block_pos >= _start_of_buffer_position) {
         const uint32_t index_of_block = block_pos - _start_of_buffer_position;
         bnum = *reinterpret_cast<uint32_t*>(buf + index_of_block + trim_data::blknum_offset);  //block number of previous block (is big endian)
      }
      else {
         const auto blknum_offset_pos = block_pos + trim_data::blknum_offset;
         auto status = fseek(_file.get(), blknum_offset_pos, SEEK_SET);
         SYS_ASSERT( status == 0, block_log_exception, "Could not seek in '${blocks_log}' to position: ${pos}. Returned status: ${status}", ("blocks_log", _block_file_name)("pos", blknum_offset_pos)("status", status) );
         auto size = fread((void*)&bnum, sizeof(bnum), 1, _file.get());
         SYS_ASSERT( size == 1, block_log_exception, "Could not read in '${blocks_log}' at position: ${pos}", ("blocks_log", _block_file_name)("pos", blknum_offset_pos) );
      }
      _last_block_num = fc::endian_reverse_u32(bnum) + 1;                     //convert from big endian to little endian and add 1
      _blocks_expected = _last_block_num - _first_block_num + 1;
      return _blocks_expected;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

previous()

uint64_t sysio::chain::detail::reverse_iterator::previous

(

)

Definition at line 1082 of file block_log.cpp.

                                             {
      SYS_ASSERT( _current_position_in_file != block_log::npos,
                  block_log_exception,
                  "Block log file at '${blocks_log}' first block already returned by former call to previous(), it is no longer valid to call this function.", ("blocks_log", _block_file_name) );
 
      if ((_version == 1 && _blocks_found == _blocks_expected) || (_prune_block_limit && _blocks_found == *_prune_block_limit)) {
         _current_position_in_file = block_log::npos;
         return _current_position_in_file;
      }
     
      if (_start_of_buffer_position > _current_position_in_file) {
         update_buffer();
      }
 
      char* buf = _buffer_ptr.get();
      auto offset = _current_position_in_file - _start_of_buffer_position;
      uint64_t block_location_in_file = *reinterpret_cast<uint64_t*>(buf + offset);
 
      ++_blocks_found;
      if (block_location_in_file == block_log::npos) {
         _current_position_in_file = block_location_in_file;
         SYS_ASSERT( _blocks_found != _blocks_expected,
                    block_log_exception,
                    "Block log file at '${blocks_log}' formatting indicated last block: ${last_block_num}, first block: ${first_block_num}, but found ${num} blocks",
                    ("blocks_log", _block_file_name)("last_block_num", _last_block_num)("first_block_num", _first_block_num)("num", _blocks_found) );
      }
      else {
         const uint64_t previous_position_in_file = _current_position_in_file;
         _current_position_in_file = block_location_in_file - _position_size;
         SYS_ASSERT( _current_position_in_file < previous_position_in_file,
                     block_log_exception,
                     "Block log file at '${blocks_log}' formatting is incorrect, indicates position later location in file: ${pos}, which was retrieved at: ${orig_pos}.",
                     ("blocks_log", _block_file_name)("pos", _current_position_in_file)("orig_pos", previous_position_in_file) );
      }
 
      return block_location_in_file;
   }

Here is the caller graph for this function:

version()

uint32_t sysio::chain::detail::reverse_iterator::version ( ) const

inline

Definition at line 152 of file block_log.cpp.

{ return _version; }

Here is the caller graph for this function:

Member Data Documentation

_buf_len

uint32_t sysio::chain::detail::reverse_iterator::_buf_len = 1U << 24

static

Definition at line 154 of file block_log.cpp.

---

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

• libraries/chain/block_log.cpp