#include <block_log.hpp>

Collaboration diagram for sysio::chain::trim_data:

[legend]

Public Member Functions
	trim_data (fc::path block_dir)

	~trim_data ()

uint64_t	block_index (uint32_t n) const

uint64_t	block_pos (uint32_t n)

Public Attributes
fc::path	block_file_name

fc::path	index_file_name

uint32_t	version = 0

uint32_t	first_block = 0

uint32_t	last_block = 0

FILE *	blk_in = nullptr

FILE *	ind_in = nullptr

uint64_t	first_block_pos = 0

chain_id_type	chain_id

Static Public Attributes
static constexpr int	blknum_offset {14}

Detailed Description

Definition at line 109 of file block_log.hpp.

Constructor & Destructor Documentation

◆ trim_data()

sysio::chain::trim_data::trim_data ( fc::path block_dir )

Definition at line 1308 of file block_log.cpp.

                                        {
 
      // code should follow logic in block_log::repair_log
 
      using namespace std;
      block_file_name = block_dir / "blocks.log";
      index_file_name = block_dir / "blocks.index";
      blk_in = FC_FOPEN(block_file_name.generic_string().c_str(), "rb");
      SYS_ASSERT( blk_in != nullptr, block_log_not_found, "cannot read file ${file}", ("file",block_file_name.string()) );
      ind_in = FC_FOPEN(index_file_name.generic_string().c_str(), "rb");
      SYS_ASSERT( ind_in != nullptr, block_log_not_found, "cannot read file ${file}", ("file",index_file_name.string()) );
      auto size = fread((void*)&version,sizeof(version), 1, blk_in);
      SYS_ASSERT( size == 1, block_log_unsupported_version, "invalid format for file ${file}", ("file",block_file_name.string()));
      ilog("block log version= ${version}",("version",version));
      bool is_pruned = detail::is_pruned_log_and_mask_version(version);
      SYS_ASSERT( !is_pruned, block_log_unsupported_version, "Block log is currently in pruned format, it must be vacuumed before doing this operation");
      SYS_ASSERT( block_log::is_supported_version(version), block_log_unsupported_version, "block log version ${v} is not supported", ("v",version));
 
      detail::fileptr_datastream ds(blk_in, block_file_name.string());
      if (version == 1) {
         first_block = 1;
         genesis_state gs;
         fc::raw::unpack(ds, gs);
         chain_id = gs.compute_chain_id();
      }
      else {
         size = fread((void *) &first_block, sizeof(first_block), 1, blk_in);
         SYS_ASSERT(size == 1, block_log_exception, "invalid format for file ${file}",
                    ("file", block_file_name.string()));
         if (block_log::contains_genesis_state(version, first_block)) {
            genesis_state gs;
            fc::raw::unpack(ds, gs);
            chain_id = gs.compute_chain_id();
         }
         else if (block_log::contains_chain_id(version, first_block)) {
            ds >> chain_id;
         }
         else {
            SYS_THROW( block_log_exception,
                       "Block log ${file} is not supported. version: ${ver} and first_block: ${first_block} does not contain "
                       "a genesis_state nor a chain_id.",
                       ("file", block_file_name.string())("ver", version)("first_block", first_block));
         }
 
         const auto expected_totem = block_log::npos;
         std::decay_t<decltype(block_log::npos)> actual_totem;
         size = fread ( (char*)&actual_totem, sizeof(actual_totem), 1, blk_in);
 
         SYS_ASSERT(size == 1, block_log_exception,
                    "Expected to read ${size} bytes, but did not read any bytes", ("size", 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) )));
      }
 
      const uint64_t start_of_blocks = ftell(blk_in);
 
      const auto status = fseek(ind_in, 0, SEEK_END);                //get length of blocks.index (gives number of blocks)
      SYS_ASSERT( status == 0, block_log_exception, "cannot seek to ${file} end", ("file", index_file_name.string()) );
      const uint64_t file_end = ftell(ind_in);                //get length of blocks.index (gives number of blocks)
      last_block = first_block + file_end/sizeof(uint64_t) - 1;
 
      first_block_pos = block_pos(first_block);
      SYS_ASSERT(start_of_blocks == first_block_pos, block_log_exception,
                 "Block log ${file} was determined to have its first block at ${determined}, but the block index "
                 "indicates the first block is at ${index}",
                 ("file", block_file_name.string())("determined", start_of_blocks)("index",first_block_pos));
      ilog("first block= ${first}",("first",first_block));
      ilog("last block= ${last}",("last",last_block));
   }

Here is the call graph for this function:

◆ ~trim_data()

sysio::chain::trim_data::~trim_data ( )

Definition at line 1379 of file block_log.cpp.

                         {
      if (blk_in != nullptr)
         fclose(blk_in);
      if (ind_in != nullptr)
         fclose(ind_in);
   }

Member Function Documentation

◆ block_index()

uint64_t sysio::chain::trim_data::block_index ( uint32_t n ) const

Definition at line 1386 of file block_log.cpp.

                                                   {
      using namespace std;
      SYS_ASSERT( first_block <= n, block_log_exception,
                  "cannot seek in ${file} to block number ${b}, block number ${first} is the first block",
                  ("file", index_file_name.string())("b",n)("first",first_block) );
      SYS_ASSERT( n <= last_block, block_log_exception,
                  "cannot seek in ${file} to block number ${b}, block number ${last} is the last block",
                  ("file", index_file_name.string())("b",n)("last",last_block) );
      return sizeof(uint64_t) * (n - first_block);
   }

Here is the caller graph for this function:

◆ block_pos()

uint64_t sysio::chain::trim_data::block_pos ( uint32_t n )

Definition at line 1397 of file block_log.cpp.

                                           {
      using namespace std;
      // can indicate the location of the block after the last block
      if (n == last_block + 1) {
         return ftell(blk_in);
      }
      const uint64_t index_pos = block_index(n);
      auto status = fseek(ind_in, index_pos, SEEK_SET);
      SYS_ASSERT( status == 0, block_log_exception, "cannot seek to ${file} ${pos} from beginning of file for block ${b}", ("file", index_file_name.string())("pos", index_pos)("b",n) );
      const uint64_t pos = ftell(ind_in);
      SYS_ASSERT( pos == index_pos, block_log_exception, "cannot seek to ${file} entry for block ${b}", ("file", index_file_name.string())("b",n) );
      uint64_t block_n_pos;
      auto size = fread((void*)&block_n_pos, sizeof(block_n_pos), 1, ind_in);                   //filepos of block n
      SYS_ASSERT( size == 1, block_log_exception, "cannot read ${file} entry for block ${b}", ("file", index_file_name.string())("b",n) );
 
      //read blocks.log and verify block number n is found at the determined file position
      const auto calc_blknum_pos = block_n_pos + blknum_offset;
      status = fseek(blk_in, calc_blknum_pos, SEEK_SET);
      SYS_ASSERT( status == 0, block_log_exception, "cannot seek to ${file} ${pos} from beginning of file", ("file", block_file_name.string())("pos", calc_blknum_pos) );
      const uint64_t block_offset_pos = ftell(blk_in);
      SYS_ASSERT( block_offset_pos == calc_blknum_pos, block_log_exception, "cannot seek to ${file} ${pos} from beginning of file", ("file", block_file_name.string())("pos", calc_blknum_pos) );
      uint32_t prior_blknum;
      size = fread((void*)&prior_blknum, sizeof(prior_blknum), 1, blk_in);     //read bigendian block number of prior block
      SYS_ASSERT( size == 1, block_log_exception, "cannot read prior block");
      const uint32_t bnum = fc::endian_reverse_u32(prior_blknum) + 1;          //convert to little endian, add 1 since prior block
      SYS_ASSERT( bnum == n, block_log_exception,
                  "At position ${pos} in ${file} expected to find ${exp_bnum} but found ${act_bnum}",
                  ("pos",block_offset_pos)("file", block_file_name.string())("exp_bnum",n)("act_bnum",bnum) );
 
      return block_n_pos;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ blk_in

FILE* sysio::chain::trim_data::blk_in = nullptr

Definition at line 118 of file block_log.hpp.

◆ blknum_offset

int sysio::chain::trim_data::blknum_offset {14}

staticconstexpr

Definition at line 124 of file block_log.hpp.

124{14}; //offset from start of block to 4 byte block number, valid for the only allowed versions

◆ block_file_name

fc::path sysio::chain::trim_data::block_file_name

Definition at line 114 of file block_log.hpp.

◆ chain_id

chain_id_type sysio::chain::trim_data::chain_id

Definition at line 122 of file block_log.hpp.

◆ first_block

uint32_t sysio::chain::trim_data::first_block = 0

Definition at line 116 of file block_log.hpp.

◆ first_block_pos

uint64_t sysio::chain::trim_data::first_block_pos = 0

Definition at line 121 of file block_log.hpp.

◆ ind_in

FILE* sysio::chain::trim_data::ind_in = nullptr

Definition at line 119 of file block_log.hpp.

◆ index_file_name

fc::path sysio::chain::trim_data::index_file_name

Definition at line 114 of file block_log.hpp.

◆ last_block

uint32_t sysio::chain::trim_data::last_block = 0

Definition at line 117 of file block_log.hpp.

◆ version

uint32_t sysio::chain::trim_data::version = 0

Definition at line 115 of file block_log.hpp.

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

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

Public Member Functions

Public Attributes

Static Public Attributes