blocklog Struct Reference

Public Member Functions
	blocklog ()
void	read_log ()
void	set_program_options (options_description &cli)
void	initialize (const variables_map &options)
void	do_vacuum ()

Public Attributes
bfs::path	blocks_dir
bfs::path	output_file
uint32_t	first_block = 0
uint32_t	last_block = std::numeric_limits<uint32_t>::max()
bool	no_pretty_print = false
bool	as_json_array = false
bool	make_index = false
bool	trim_log = false
bool	smoke_test = false
bool	vacuum = false
bool	help = false
std::optional< block_log_prune_config >	blog_keep_prune_conf

Detailed Description

Definition at line 33 of file main.cpp.

Constructor & Destructor Documentation

blocklog()

blocklog::blocklog ( )

inline

Definition at line 34 of file main.cpp.

   {}

Member Function Documentation

do_vacuum()

void blocklog::do_vacuum

(

)

Definition at line 72 of file main.cpp.

                         {
   SYS_ASSERT( blog_keep_prune_conf, block_log_exception, "blocks.log is not a pruned log; nothing to vacuum" );
   block_log blocks(blocks_dir, std::optional<block_log_prune_config>()); //passing an unset block_log_prune_config turns off pruning this performs a vacuum
   ilog("Successfully vacuumed block log");
}

Here is the caller graph for this function:

initialize()

void blocklog::initialize

(

const variables_map &

options

)

Definition at line 205 of file main.cpp.

                                                      {
   try {
      auto bld = options.at( "blocks-dir" ).as<bfs::path>();
      if( bld.is_relative())
         blocks_dir = bfs::current_path() / bld;
      else
         blocks_dir = bld;
 
      if (options.count( "output-file" )) {
         bld = options.at( "output-file" ).as<bfs::path>();
         if( bld.is_relative())
            output_file = bfs::current_path() / bld;
         else
            output_file = bld;
      }
 
      //if the log is pruned, keep it that way by passing in a config with a large block pruning value. There is otherwise no
      // way to tell block_log "keep the current non/pruneness of the log"
      if(block_log::is_pruned_log(blocks_dir)) {
         blog_keep_prune_conf.emplace();
         blog_keep_prune_conf->prune_blocks = UINT32_MAX;
      }
   } FC_LOG_AND_RETHROW()
 
}

Here is the call graph for this function:

Here is the caller graph for this function:

read_log()

void blocklog::read_log

(

)

Definition at line 78 of file main.cpp.

                        {
   report_time rt("reading log");
   block_log block_logger(blocks_dir, blog_keep_prune_conf);
   const auto end = block_logger.read_head();
   SYS_ASSERT( end, block_log_exception, "No blocks found in block log" );
   SYS_ASSERT( end->block_num() > 1, block_log_exception, "Only one block found in block log" );
 
   //fix message below, first block might not be 1, first_block_num is not set yet
   ilog( "existing block log contains block num ${first} through block num ${n}",
         ("first",block_logger.first_block_num())("n",end->block_num()) );
   if (first_block < block_logger.first_block_num()) {
      first_block = block_logger.first_block_num();
   }
 
   sysio::chain::branch_type fork_db_branch;
   if( fc::exists( blocks_dir / config::reversible_blocks_dir_name / config::forkdb_filename ) ) {
      ilog( "opening fork_db" );
      fork_database fork_db( blocks_dir / config::reversible_blocks_dir_name );
 
      fork_db.open( []( block_timestamp_type timestamp,
                        const flat_set<digest_type>& cur_features,
                        const vector<digest_type>& new_features ) {}
      );
 
      fork_db_branch = fork_db.fetch_branch( fork_db.head()->id );
      if( fork_db_branch.empty() ) {
         elog( "no blocks available in reversible block database: only block_log blocks are available" );
      } else {
         auto first = fork_db_branch.rbegin();
         auto last = fork_db_branch.rend() - 1;
         ilog( "existing reversible fork_db block num ${first} through block num ${last} ",
               ("first", (*first)->block_num)( "last", (*last)->block_num ) );
         SYS_ASSERT( end->block_num() + 1 == (*first)->block_num, block_log_exception,
                     "fork_db does not start at end of block log" );
      }
   }
 
   std::ofstream output_blocks;
   std::ostream* out;
   if (!output_file.empty()) {
      output_blocks.open(output_file.generic_string().c_str());
      if (output_blocks.fail()) {
         std::ostringstream ss;
         ss << "Unable to open file '" << output_file.string() << "'";
         throw std::runtime_error(ss.str());
      }
      out = &output_blocks;
   }
   else
      out = &std::cout;
 
   if (as_json_array)
      *out << "[";
   uint32_t block_num = (first_block < 1) ? 1 : first_block;
   signed_block_ptr next;
   fc::variant pretty_output;
   const fc::microseconds deadline = fc::seconds(10);
   auto print_block = [&](signed_block_ptr& next) {
      abi_serializer::to_variant(*next,
                                 pretty_output,
                                 []( account_name n ) { return std::optional<abi_serializer>(); },
                                 abi_serializer::create_yield_function( deadline ));
      const auto block_id = next->calculate_id();
      const uint32_t ref_block_prefix = block_id._hash[1];
      const auto enhanced_object = fc::mutable_variant_object
                 ("block_num",next->block_num())
                 ("id", block_id)
                 ("ref_block_prefix", ref_block_prefix)
                 (pretty_output.get_object());
      fc::variant v(std::move(enhanced_object));
      if (no_pretty_print)
         *out << fc::json::to_string(v, fc::time_point::maximum());
      else
         *out << fc::json::to_pretty_string(v) << "\n";
   };
   bool contains_obj = false;
   while((block_num <= last_block) && (next = block_logger.read_block_by_num( block_num ))) {
      if (as_json_array && contains_obj)
         *out << ",";
      print_block(next);
      ++block_num;
      contains_obj = true;
   }
 
   if( !fork_db_branch.empty() ) {
      for( auto bitr = fork_db_branch.rbegin(); bitr != fork_db_branch.rend() && block_num <= last_block; ++bitr ) {
         if (as_json_array && contains_obj)
            *out << ",";
         auto next = (*bitr)->block;
         print_block(next);
         ++block_num;
         contains_obj = true;
      }
   }
 
   if (as_json_array)
      *out << "]";
   rt.report();
}

Here is the call graph for this function:

Here is the caller graph for this function:

set_program_options()

void blocklog::set_program_options

(

options_description &

cli

)

Definition at line 178 of file main.cpp.

{
   cli.add_options()
         ("blocks-dir", bpo::value<bfs::path>()->default_value("blocks"),
          "the location of the blocks directory (absolute path or relative to the current directory)")
         ("output-file,o", bpo::value<bfs::path>(),
          "the file to write the output to (absolute or relative path).  If not specified then output is to stdout.")
         ("first,f", bpo::value<uint32_t>(&first_block)->default_value(0),
          "the first block number to log or the first to keep if trim-blocklog")
         ("last,l", bpo::value<uint32_t>(&last_block)->default_value(std::numeric_limits<uint32_t>::max()),
          "the last block number to log or the last to keep if trim-blocklog")
         ("no-pretty-print", bpo::bool_switch(&no_pretty_print)->default_value(false),
          "Do not pretty print the output.  Useful if piping to jq to improve performance.")
         ("as-json-array", bpo::bool_switch(&as_json_array)->default_value(false),
          "Print out json blocks wrapped in json array (otherwise the output is free-standing json objects).")
         ("make-index", bpo::bool_switch(&make_index)->default_value(false),
          "Create blocks.index from blocks.log. Must give 'blocks-dir'. Give 'output-file' relative to current directory or absolute path (default is <blocks-dir>/blocks.index).")
         ("trim-blocklog", bpo::bool_switch(&trim_log)->default_value(false),
          "Trim blocks.log and blocks.index. Must give 'blocks-dir' and 'first and/or 'last'.")
         ("smoke-test", bpo::bool_switch(&smoke_test)->default_value(false),
          "Quick test that blocks.log and blocks.index are well formed and agree with each other.")
         ("vacuum", bpo::bool_switch(&vacuum)->default_value(false),
          "Vacuum a pruned blocks.log in to an un-pruned blocks.log")
         ("help,h", bpo::bool_switch(&help)->default_value(false), "Print this help message and exit.")
         ;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

as_json_array

bool blocklog::as_json_array = false

Definition at line 47 of file main.cpp.

blocks_dir

bfs::path blocklog::blocks_dir

Definition at line 42 of file main.cpp.

blog_keep_prune_conf

std::optional<block_log_prune_config> blocklog::blog_keep_prune_conf

Definition at line 54 of file main.cpp.

first_block

uint32_t blocklog::first_block = 0

Definition at line 44 of file main.cpp.

help

bool blocklog::help = false

Definition at line 52 of file main.cpp.

last_block

uint32_t blocklog::last_block = std::numeric_limits<uint32_t>::max()

Definition at line 45 of file main.cpp.

make_index

bool blocklog::make_index = false

Definition at line 48 of file main.cpp.

no_pretty_print

bool blocklog::no_pretty_print = false

Definition at line 46 of file main.cpp.

output_file

bfs::path blocklog::output_file

Definition at line 43 of file main.cpp.

smoke_test

bool blocklog::smoke_test = false

Definition at line 50 of file main.cpp.

trim_log

bool blocklog::trim_log = false

Definition at line 49 of file main.cpp.

vacuum

bool blocklog::vacuum = false

Definition at line 51 of file main.cpp.

---

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

• programs/sysio-blocklog/main.cpp