sysio::chain::block_log Class Reference

#include <block_log.hpp>

Public Member Functions
	block_log (const fc::path &data_dir, std::optional< block_log_prune_config > prune_config)
	block_log (block_log &&other)
	~block_log ()
void	append (const signed_block_ptr &b)
void	flush ()
void	reset (const genesis_state &gs, const signed_block_ptr &genesis_block)
void	reset (const chain_id_type &chain_id, uint32_t first_block_num)
signed_block_ptr	read_block (uint64_t file_pos) const
void	read_block_header (block_header &bh, uint64_t file_pos) const
signed_block_ptr	read_block_by_num (uint32_t block_num) const
block_id_type	read_block_id_by_num (uint32_t block_num) const
signed_block_ptr	read_block_by_id (const block_id_type &id) const
uint64_t	get_block_pos (uint32_t block_num) const
signed_block_ptr	read_head () const
const signed_block_ptr &	head () const
const block_id_type &	head_id () const
uint32_t	first_block_num () const

Static Public Member Functions
static fc::path	repair_log (const fc::path &data_dir, uint32_t truncate_at_block=0, const char *reversible_block_dir_name="")
static std::optional< genesis_state >	extract_genesis_state (const fc::path &data_dir)
static chain_id_type	extract_chain_id (const fc::path &data_dir)
static void	construct_index (const fc::path &block_file_name, const fc::path &index_file_name)
static bool	contains_genesis_state (uint32_t version, uint32_t first_block_num)
static bool	contains_chain_id (uint32_t version, uint32_t first_block_num)
static bool	is_supported_version (uint32_t version)
static bool	is_pruned_log (const fc::path &data_dir)
static bool	trim_blocklog_front (const fc::path &block_dir, const fc::path &temp_dir, uint32_t truncate_at_block)

Static Public Attributes
static const uint64_t	npos = std::numeric_limits<uint64_t>::max()
static const uint32_t	min_supported_version = 1
static const uint32_t	max_supported_version = 3

Detailed Description

Definition at line 45 of file block_log.hpp.

Constructor & Destructor Documentation

block_log() [1/2]

sysio::chain::block_log::block_log	(	const fc::path &	data_dir,
		std::optional< block_log_prune_config >	prune_config )

Definition at line 222 of file block_log.cpp.

   :my(new detail::block_log_impl(prune_config)) {
      open(data_dir);
   }

block_log() [2/2]

sysio::chain::block_log::block_log

(

block_log &&

other

)

Definition at line 227 of file block_log.cpp.

                                         {
      my = std::move(other.my);
   }

~block_log()

sysio::chain::block_log::~block_log

(

)

Definition at line 231 of file block_log.cpp.

                         {
      if (my) {
         flush();
         my->try_exit_vacuum();
         my->close();
         my.reset();
      }
   }

Here is the call graph for this function:

Member Function Documentation

append()

void sysio::chain::block_log::append

(

const signed_block_ptr &

b

)

Definition at line 358 of file block_log.cpp.

                                                   {
      my->append(b);
   }

Here is the caller graph for this function:

construct_index()

void sysio::chain::block_log::construct_index ( const fc::path & block_file_name, const fc::path & index_file_name )

static

Definition at line 726 of file block_log.cpp.

                                                                                               {
      detail::reverse_iterator block_log_iter;
 
      ilog("Will read existing blocks.log file ${file}", ("file", block_file_name.generic_string()));
      ilog("Will write new blocks.index file ${file}", ("file", index_file_name.generic_string()));
 
      //for a pruned log, this will still return blocks in the count that have been removed. that's okay and desirable
      const uint32_t num_blocks = block_log_iter.open(block_file_name);
 
      ilog("block log version= ${version}", ("version", block_log_iter.version()));
 
      if (num_blocks == 0) {
         return;
      }
 
      ilog("first block= ${first}         last block= ${last}",
           ("first", block_log_iter.first_block_num())("last", (block_log_iter.first_block_num() + num_blocks)));
 
      detail::index_writer index(index_file_name, num_blocks);
      uint64_t position;
      while ((position = block_log_iter.previous()) != npos) {
         index.write(position);
      }
   }

Here is the call graph for this function:

contains_chain_id()

bool sysio::chain::block_log::contains_chain_id ( uint32_t version, uint32_t first_block_num )

static

Definition at line 1168 of file block_log.cpp.

                                                                               {
      return version >= 3 && first_block_num > 1;
   }

Here is the caller graph for this function:

contains_genesis_state()

bool sysio::chain::block_log::contains_genesis_state ( uint32_t version, uint32_t first_block_num )

static

Definition at line 1164 of file block_log.cpp.

                                                                                    {
      return version <= 2 || first_block_num == 1;
   }

Here is the caller graph for this function:

extract_chain_id()

chain_id_type sysio::chain::block_log::extract_chain_id ( const fc::path & data_dir )

static

Definition at line 977 of file block_log.cpp.

                                                                     {
      return *(detail::block_log_impl::extract_chain_context<chain_id_type>(data_dir, [](std::fstream& block_stream, uint32_t version, uint32_t first_block_num ) -> std::optional<chain_id_type> {
         // supported versions either contain a genesis state, or else the chain id only
         if (contains_genesis_state(version, first_block_num)) {
            genesis_state gs;
            fc::raw::unpack(block_stream, gs);
            return gs.compute_chain_id();
         }
         SYS_ASSERT( contains_chain_id(version, first_block_num), block_log_exception,
                     "Block log error! version: ${version} with first_block_num: ${num} does not contain a "
                     "chain id or genesis state, so the chain id cannot be determined.",
                     ("version", version)("num", first_block_num) );
         chain_id_type chain_id;
         fc::raw::unpack(block_stream, chain_id);
         return chain_id;
      }));
   }

Here is the call graph for this function:

Here is the caller graph for this function:

extract_genesis_state()

std::optional< genesis_state > sysio::chain::block_log::extract_genesis_state ( const fc::path & data_dir )

static

Definition at line 964 of file block_log.cpp.

                                                                                       {
      return detail::block_log_impl::extract_chain_context<genesis_state>(data_dir, [](std::fstream& block_stream, uint32_t version, uint32_t first_block_num ) -> std::optional<genesis_state> {
         if (contains_genesis_state(version, first_block_num)) {
            genesis_state gs;
            fc::raw::unpack(block_stream, gs);
            return gs;
         }
 
         // current versions only have a genesis state if they start with block number 1
         return std::optional<genesis_state>();
      });
   }

Here is the call graph for this function:

Here is the caller graph for this function:

first_block_num()

uint32_t sysio::chain::block_log::first_block_num

(

)

const

Definition at line 706 of file block_log.cpp.

                                             {
      return my->first_block_num;
   }

Here is the caller graph for this function:

flush()

void sysio::chain::block_log::flush

(

)

Definition at line 426 of file block_log.cpp.

                         {
      my->flush();
   }

Here is the caller graph for this function:

get_block_pos()

uint64_t sysio::chain::block_log::get_block_pos

(

uint32_t

block_num

)

const

Return offset of block in file, or block_log::npos if it does not exist.

Definition at line 667 of file block_log.cpp.

                                                             {
      return my->get_block_pos(block_num);
   }

head()

const signed_block_ptr & sysio::chain::block_log::head

(

)

const

Definition at line 698 of file block_log.cpp.

                                                {
      return my->head;
   }

Here is the caller graph for this function:

head_id()

const block_id_type & sysio::chain::block_log::head_id

(

)

const

Definition at line 702 of file block_log.cpp.

                                                   {
      return my->head_id;
   }

Here is the caller graph for this function:

is_pruned_log()

bool sysio::chain::block_log::is_pruned_log ( const fc::path & data_dir )

static

Definition at line 995 of file block_log.cpp.

                                                       {
      uint32_t version = 0;
      try {
         fc::cfile log_file;
         log_file.set_file_path(data_dir / "blocks.log");
         log_file.open("rb");
         fc::raw::unpack(log_file, version);
      }
      catch(...) {
         return false;
      }
      return detail::is_pruned_log_and_mask_version(version);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

is_supported_version()

bool sysio::chain::block_log::is_supported_version ( uint32_t version )

static

Definition at line 1172 of file block_log.cpp.

                                                        {
      return std::clamp(version, min_supported_version, max_supported_version) == version;
   }

Here is the caller graph for this function:

read_block()

signed_block_ptr sysio::chain::block_log::read_block

(

uint64_t

file_pos

)

const

Definition at line 612 of file block_log.cpp.

                                                           {
      my->check_open_files();
 
      my->block_file.seek(pos);
      signed_block_ptr result = std::make_shared<signed_block>();
      auto ds = my->block_file.create_datastream();
      fc::raw::unpack(ds, *result);
      return result;
   }

Here is the call graph for this function:

read_block_by_id()

signed_block_ptr sysio::chain::block_log::read_block_by_id ( const block_id_type & id ) const

inline

Definition at line 60 of file block_log.hpp.

                                                                         {
            return read_block_by_num(block_header::num_from_id(id));
         }

Here is the call graph for this function:

read_block_by_num()

signed_block_ptr sysio::chain::block_log::read_block_by_num

(

uint32_t

block_num

)

const

Definition at line 630 of file block_log.cpp.

                                                                        {
      try {
         signed_block_ptr b;
         uint64_t pos = get_block_pos(block_num);
         if (pos != npos) {
            b = read_block(pos);
            SYS_ASSERT(b->block_num() == block_num, reversible_blocks_exception,
                      "Wrong block was read from block log.", ("returned", b->block_num())("expected", block_num));
         }
         return b;
      } FC_LOG_AND_RETHROW()
   }

Here is the caller graph for this function:

read_block_header()

void sysio::chain::block_log::read_block_header	(	block_header &	bh,
		uint64_t	file_pos ) const

Definition at line 622 of file block_log.cpp.

                                                                        {
      my->check_open_files();
 
      my->block_file.seek(pos);
      auto ds = my->block_file.create_datastream();
      fc::raw::unpack(ds, bh);
   }

Here is the call graph for this function:

read_block_id_by_num()

block_id_type sysio::chain::block_log::read_block_id_by_num

(

uint32_t

block_num

)

const

Definition at line 643 of file block_log.cpp.

                                                                        {
      try {
         uint64_t pos = get_block_pos(block_num);
         if (pos != npos) {
            block_header bh;
            read_block_header(bh, pos);
            SYS_ASSERT(bh.block_num() == block_num, reversible_blocks_exception,
                       "Wrong block header was read from block log.", ("returned", bh.block_num())("expected", block_num));
            return bh.calculate_id();
         }
         return {};
      } FC_LOG_AND_RETHROW()
   }

read_head()

signed_block_ptr sysio::chain::block_log::read_head

(

)

const

Definition at line 671 of file block_log.cpp.

                                              {
      my->check_open_files();
 
      uint64_t pos;
 
      // Check that the file is not empty
      my->block_file.seek_end(0);
      if (my->block_file.tellp() <= sizeof(pos))
         return {};
 
      //figure out if this is a pruned log or not. we can't just look at the configuration since
      // read_head() is called early on, and this isn't hot enough to warrant a member bool to track it
      my->block_file.seek(0);
      uint32_t current_version;
      fc::raw::unpack(my->block_file, current_version);
      const bool is_currently_pruned = detail::is_pruned_log_and_mask_version(current_version);
 
      my->block_file.seek_end(0);
      if(is_currently_pruned)
         my->block_file.skip(-sizeof(uint32_t)); //skip the trailer containing block count
      my->block_file.skip(-sizeof(pos));
      fc::raw::unpack(my->block_file, pos);
      if (pos != npos)
         return read_block(pos);
      return {};
   }

Here is the call graph for this function:

Here is the caller graph for this function:

repair_log()

fc::path sysio::chain::block_log::repair_log ( const fc::path & data_dir, uint32_t truncate_at_block = 0, const char * reversible_block_dir_name = "" )

static

Definition at line 751 of file block_log.cpp.

                                                                                                                         {
      ilog("Recovering Block Log...");
      SYS_ASSERT( fc::is_directory(data_dir) && fc::is_regular_file(data_dir / "blocks.log"), block_log_not_found,
                 "Block log not found in '${blocks_dir}'", ("blocks_dir", data_dir)          );
 
      auto now = fc::time_point::now();
 
      auto blocks_dir = fc::canonical( data_dir );
      if( blocks_dir.filename().generic_string() == "." ) {
         blocks_dir = blocks_dir.parent_path();
      }
      auto backup_dir = blocks_dir.parent_path();
      auto blocks_dir_name = blocks_dir.filename();
      SYS_ASSERT( blocks_dir_name.generic_string() != ".", block_log_exception, "Invalid path to blocks directory" );
      backup_dir = backup_dir / blocks_dir_name.generic_string().append("-").append( now );
 
      SYS_ASSERT( !fc::exists(backup_dir), block_log_backup_dir_exist,
                 "Cannot move existing blocks directory to already existing directory '${new_blocks_dir}'",
                 ("new_blocks_dir", backup_dir) );
 
      fc::rename( blocks_dir, backup_dir );
      ilog( "Moved existing blocks directory to backup location: '${new_blocks_dir}'", ("new_blocks_dir", backup_dir) );
 
      if (strlen(reversible_block_dir_name) && fc::is_directory(blocks_dir/reversible_block_dir_name)) {
         fc::rename(blocks_dir/ reversible_block_dir_name, backup_dir/ reversible_block_dir_name);
      }
 
      fc::create_directories(blocks_dir);
      auto block_log_path = blocks_dir / "blocks.log";
 
      ilog( "Reconstructing '${new_block_log}' from backed up block log", ("new_block_log", block_log_path) );
 
      std::fstream  old_block_stream;
      std::fstream  new_block_stream;
 
      old_block_stream.open( (backup_dir / "blocks.log").generic_string().c_str(), LOG_READ );
      new_block_stream.open( block_log_path.generic_string().c_str(), LOG_WRITE );
 
      old_block_stream.seekg( 0, std::ios::end );
      uint64_t end_pos = old_block_stream.tellg();
      old_block_stream.seekg( 0 );
 
      uint32_t version = 0;
      old_block_stream.read( (char*)&version, sizeof(version) );
      SYS_ASSERT( version > 0, block_log_exception, "Block log was not setup properly" );
      SYS_ASSERT( is_supported_version(version), block_log_unsupported_version,
                 "Unsupported version of block log. Block log version is ${version} while code supports version(s) [${min},${max}]",
                 ("version", version)("min", block_log::min_supported_version)("max", block_log::max_supported_version) );
 
      new_block_stream.write( (char*)&version, sizeof(version) );
 
      uint32_t first_block_num = 1;
      if (version != 1) {
         old_block_stream.read ( (char*)&first_block_num, sizeof(first_block_num) );
 
         // this assert is only here since repair_log is only used for --hard-replay-blockchain, which removes any
         // existing state, if another API needs to use it, this can be removed and the check for the first block's
         // previous block id will need to accommodate this.
         SYS_ASSERT( first_block_num == 1, block_log_exception,
                     "Block log ${file} must contain a genesis state and start at block number 1.  This block log "
                     "starts at block number ${first_block_num}.",
                     ("file", (backup_dir / "blocks.log").generic_string())("first_block_num", first_block_num));
 
         new_block_stream.write( (char*)&first_block_num, sizeof(first_block_num) );
      }
 
      if (contains_genesis_state(version, first_block_num)) {
         genesis_state gs;
         fc::raw::unpack(old_block_stream, gs);
 
         auto data = fc::raw::pack( gs );
         new_block_stream.write( data.data(), data.size() );
      }
      else if (contains_chain_id(version, first_block_num)) {
         chain_id_type chain_id;
         old_block_stream >> chain_id;
 
         new_block_stream << chain_id;
      }
      else {
         SYS_THROW( block_log_exception,
                    "Block log ${file} is not supported. version: ${ver} and first_block_num: ${fbn} does not contain "
                    "a genesis_state nor a chain_id.",
                    ("file", (backup_dir / "blocks.log").generic_string())("ver", version)("fbn", first_block_num));
      }
 
      if (version != 1) {
         auto expected_totem = npos;
         std::decay_t<decltype(npos)> actual_totem;
         old_block_stream.read ( (char*)&actual_totem, sizeof(actual_totem) );
 
         SYS_ASSERT(actual_totem == expected_totem, block_log_exception,
                    "Expected separator between block log header and blocks was not found( expected: ${e}, actual: ${a} )",
                    ("e", fc::to_hex((char*)&expected_totem, sizeof(expected_totem) ))("a", fc::to_hex((char*)&actual_totem, sizeof(actual_totem) )));
 
         new_block_stream.write( (char*)&actual_totem, sizeof(actual_totem) );
      }
 
      std::exception_ptr          except_ptr;
      vector<char>                incomplete_block_data;
      std::optional<signed_block> bad_block;
      uint32_t                    block_num = 0;
 
      block_id_type previous;
 
      uint64_t pos = old_block_stream.tellg();
      while( pos < end_pos ) {
         signed_block tmp;
 
         try {
            fc::raw::unpack(old_block_stream, tmp);
         } catch( ... ) {
            except_ptr = std::current_exception();
            incomplete_block_data.resize( end_pos - pos );
            old_block_stream.read( incomplete_block_data.data(), incomplete_block_data.size() );
            break;
         }
 
         auto id = tmp.calculate_id();
         if( block_header::num_from_id(previous) + 1 != block_header::num_from_id(id) ) {
            elog( "Block ${num} (${id}) skips blocks. Previous block in block log is block ${prev_num} (${previous})",
                  ("num", block_header::num_from_id(id))("id", id)
                  ("prev_num", block_header::num_from_id(previous))("previous", previous) );
         }
         if( previous != tmp.previous ) {
            elog( "Block ${num} (${id}) does not link back to previous block. "
                  "Expected previous: ${expected}. Actual previous: ${actual}.",
                  ("num", block_header::num_from_id(id))("id", id)("expected", previous)("actual", tmp.previous) );
         }
         previous = id;
 
         uint64_t tmp_pos = std::numeric_limits<uint64_t>::max();
         if( (static_cast<uint64_t>(old_block_stream.tellg()) + sizeof(pos)) <= end_pos ) {
            old_block_stream.read( reinterpret_cast<char*>(&tmp_pos), sizeof(tmp_pos) );
         }
         if( pos != tmp_pos ) {
            bad_block.emplace(std::move(tmp));
            break;
         }
 
         auto data = fc::raw::pack(tmp);
         new_block_stream.write( data.data(), data.size() );
         new_block_stream.write( reinterpret_cast<char*>(&pos), sizeof(pos) );
         block_num = tmp.block_num();
         if(block_num % 1000 == 0)
            ilog( "Recovered block ${num}", ("num", block_num) );
         pos = new_block_stream.tellp();
         if( block_num == truncate_at_block )
            break;
      }
 
      if( bad_block ) {
         ilog( "Recovered only up to block number ${num}. Last block in block log was not properly committed:\n${last_block}",
               ("num", block_num)("last_block", *bad_block) );
      } else if( except_ptr ) {
         std::string error_msg;
 
         try {
            std::rethrow_exception(except_ptr);
         } catch( const fc::exception& e ) {
            error_msg = e.what();
         } catch( const std::exception& e ) {
            error_msg = e.what();
         } catch( ... ) {
            error_msg = "unrecognized exception";
         }
 
         ilog( "Recovered only up to block number ${num}. "
               "The block ${next_num} could not be deserialized from the block log due to error:\n${error_msg}",
               ("num", block_num)("next_num", block_num+1)("error_msg", error_msg) );
 
         auto tail_path = blocks_dir / std::string("blocks-bad-tail-").append( now ).append(".log");
         if( !fc::exists(tail_path) && incomplete_block_data.size() > 0 ) {
            std::fstream tail_stream;
            tail_stream.open( tail_path.generic_string().c_str(), LOG_WRITE );
            tail_stream.write( incomplete_block_data.data(), incomplete_block_data.size() );
 
            ilog( "Data at tail end of block log which should contain the (incomplete) serialization of block ${num} "
                  "has been written out to '${tail_path}'.",
                  ("num", block_num+1)("tail_path", tail_path) );
         }
      } else if( block_num == truncate_at_block && pos < end_pos ) {
         ilog( "Stopped recovery of block log early at specified block number: ${stop}.", ("stop", truncate_at_block) );
      } else {
         ilog( "Existing block log was undamaged. Recovered all irreversible blocks up to block number ${num}.", ("num", block_num) );
      }
 
      return backup_dir;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

reset() [1/2]

void sysio::chain::block_log::reset	(	const chain_id_type &	chain_id,
		uint32_t	first_block_num )

Definition at line 597 of file block_log.cpp.

                                                                                  {
      SYS_ASSERT( first_block_num > 1, block_log_exception,
                  "Block log version ${ver} needs to be created with a genesis state if starting from block number 1." );
      my->reset(chain_id, signed_block_ptr(), first_block_num);
   }

reset() [2/2]

void sysio::chain::block_log::reset	(	const genesis_state &	gs,
		const signed_block_ptr &	genesis_block )

Definition at line 593 of file block_log.cpp.

                                                                                       {
      my->reset(gs, first_block, 1);
   }

Here is the caller graph for this function:

trim_blocklog_front()

bool sysio::chain::block_log::trim_blocklog_front ( const fc::path & block_dir, const fc::path & temp_dir, uint32_t truncate_at_block )

static

Definition at line 1190 of file block_log.cpp.

                                                                                                                  {
      using namespace std;
      SYS_ASSERT( block_dir != temp_dir, block_log_exception, "block_dir and temp_dir need to be different directories" );
      ilog("In directory ${dir} will trim all blocks before block ${n} from blocks.log and blocks.index.",
           ("dir", block_dir.generic_string())("n", truncate_at_block));
      trim_data original_block_log(block_dir);
      if (truncate_at_block <= original_block_log.first_block) {
         ilog("There are no blocks before block ${n} so do nothing.", ("n", truncate_at_block));
         return false;
      }
      if (truncate_at_block > original_block_log.last_block) {
         ilog("All blocks are before block ${n} so do nothing (trim front would delete entire blocks.log).", ("n", truncate_at_block));
         return false;
      }
 
      // ****** create the new block log file and write out the header for the file
      fc::create_directories(temp_dir);
      fc::path new_block_filename = temp_dir / "blocks.log";
      if (fc::remove(new_block_filename)) {
         ilog("Removing old blocks.out file");
      }
      fc::cfile new_block_file;
      new_block_file.set_file_path(new_block_filename);
      // need to open as append since the file doesn't already exist, then reopen without append to allow writing the
      // file in any order
      new_block_file.open( LOG_WRITE_C );
      new_block_file.close();
      new_block_file.open( LOG_RW_C );
 
      static_assert( block_log::max_supported_version == 3,
                     "Code was written to support version 3 format, need to update this code for latest format." );
      uint32_t version = block_log::max_supported_version;
      new_block_file.seek(0);
      new_block_file.write((char*)&version, sizeof(version));
      new_block_file.write((char*)&truncate_at_block, sizeof(truncate_at_block));
 
      new_block_file << original_block_log.chain_id;
 
      // append a totem to indicate the division between blocks and header
      auto totem = block_log::npos;
      new_block_file.write((char*)&totem, sizeof(totem));
 
      const auto new_block_file_first_block_pos = new_block_file.tellp();
      // ****** end of new block log header
 
      // copy over remainder of block log to new block log
      auto buffer =  make_unique<char[]>(detail::reverse_iterator::_buf_len);
      char* buf =  buffer.get();
 
      // offset bytes to shift from old blocklog position to new blocklog position
      const uint64_t original_file_block_pos = original_block_log.block_pos(truncate_at_block);
      const uint64_t pos_delta = original_file_block_pos - new_block_file_first_block_pos;
      auto status = fseek(original_block_log.blk_in, 0, SEEK_END);
      SYS_ASSERT( status == 0, block_log_exception, "blocks.log seek failed" );
 
      // all blocks to copy to the new blocklog
      const uint64_t to_write = ftell(original_block_log.blk_in) - original_file_block_pos;
      const auto pos_size = sizeof(uint64_t);
 
      // start with the last block's position stored at the end of the block
      uint64_t original_pos = ftell(original_block_log.blk_in) - pos_size;
 
      const auto num_blocks = original_block_log.last_block - truncate_at_block + 1;
 
      fc::path new_index_filename = temp_dir / "blocks.index";
      detail::index_writer index(new_index_filename, num_blocks);
 
      uint64_t read_size = 0;
      uint64_t write_size = 0;
      for(uint64_t to_write_remaining = to_write; to_write_remaining > 0; to_write_remaining -= write_size) {
         read_size = to_write_remaining;
         if (read_size > detail::reverse_iterator::_buf_len) {
            read_size = detail::reverse_iterator::_buf_len;
         }
 
         // read in the previous contiguous memory into the read buffer
         const auto start_of_blk_buffer_pos = original_file_block_pos + to_write_remaining - read_size;
         status = fseek(original_block_log.blk_in, start_of_blk_buffer_pos, SEEK_SET);
         const auto num_read = fread(buf, read_size, 1, original_block_log.blk_in);
         SYS_ASSERT( num_read == 1, block_log_exception, "blocks.log read failed" );
 
         // walk this memory section to adjust block position to match the adjusted location
         // of the block start and store in the new index file
         write_size = read_size;
         while(original_pos >= start_of_blk_buffer_pos) {
            const auto buffer_index = original_pos - start_of_blk_buffer_pos;
            uint64_t pos_content = read_buffer<uint64_t>(buf + buffer_index);
 
            if ( (pos_content - start_of_blk_buffer_pos) > 0 && (pos_content - start_of_blk_buffer_pos) < pos_size ) {
               // avoid the whole 8 bytes that contains a blk pos being split by the buffer
               write_size = read_size - (pos_content - start_of_blk_buffer_pos);
            }
            const auto start_of_this_block = pos_content;
            pos_content = start_of_this_block - pos_delta;
            write_buffer<uint64_t>(buf + buffer_index, &pos_content);
            index.write(pos_content);
            original_pos = start_of_this_block - pos_size;
         }
         new_block_file.seek(new_block_file_first_block_pos + to_write_remaining - write_size);
         uint64_t offset = read_size - write_size;
         new_block_file.write(buf+offset, write_size);
      }
 
      fclose(original_block_log.blk_in);
      original_block_log.blk_in = nullptr;
      new_block_file.flush();
      new_block_file.close();
 
      fc::path old_log = temp_dir / "old.log";
      rename(original_block_log.block_file_name, old_log);
      rename(new_block_filename, original_block_log.block_file_name);
      fc::path old_ind = temp_dir / "old.index";
      rename(original_block_log.index_file_name, old_ind);
      rename(new_index_filename, original_block_log.index_file_name);
 
      return true;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

max_supported_version

const uint32_t sysio::chain::block_log::max_supported_version = 3

static

History: Version 1: complete block log from genesis Version 2: adds optional partial block log, cannot be used for replay without snapshot this is in the form of an first_block_num that is written immediately after the version Version 3: improvement on version 2 to not require the genesis state be provided when not starting from block 1

Definition at line 76 of file block_log.hpp.

min_supported_version

const uint32_t sysio::chain::block_log::min_supported_version = 1

static

Definition at line 75 of file block_log.hpp.

npos

const uint64_t sysio::chain::block_log::npos = std::numeric_limits<uint64_t>::max()

static

Definition at line 73 of file block_log.hpp.

---

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

• libraries/chain/include/sysio/chain/block_log.hpp
• libraries/chain/block_log.cpp