main.cpp File Reference

#include <memory>
#include <sysio/chain/abi_serializer.hpp>
#include <sysio/chain/block_log.hpp>
#include <sysio/chain/fork_database.hpp>
#include <sysio/chain/config.hpp>
#include <fc/io/json.hpp>
#include <fc/filesystem.hpp>
#include <fc/variant.hpp>
#include <fc/bitutil.hpp>
#include <boost/exception/diagnostic_information.hpp>
#include <boost/program_options.hpp>
#include <boost/filesystem.hpp>
#include <boost/filesystem/path.hpp>
#include <chrono>

Include dependency graph for main.cpp:

Go to the source code of this file.

Classes
struct	blocklog
struct	report_time

Macros
#define	FOPEN(p, m)

Functions
int	trim_blocklog_end (bfs::path block_dir, uint32_t n)
bool	trim_blocklog_front (bfs::path block_dir, uint32_t n)
void	smoke_test (bfs::path block_dir)
int	main (int argc, char **argv)

Macro Definition Documentation

FOPEN

#define FOPEN	(		p,
			m )

Value:

fopen(p, m)

Definition at line 20 of file main.cpp.

Function Documentation

main()

int main	(	int	argc,
		char **	argv )

Definition at line 292 of file main.cpp.

                                {
   std::ios::sync_with_stdio(false); // for potential performance boost for large block log files
   options_description cli ("sysio-blocklog command line options");
   try {
      blocklog blog;
      blog.set_program_options(cli);
      variables_map vmap;
      bpo::store(bpo::parse_command_line(argc, argv, cli), vmap);
      bpo::notify(vmap);
      if (blog.help) {
         cli.print(std::cerr);
         return 0;
      }
      if (blog.smoke_test) {
         smoke_test(vmap.at("blocks-dir").as<bfs::path>());
         return 0;
      }
      if (blog.trim_log) {
         if (blog.first_block == 0 && blog.last_block == std::numeric_limits<uint32_t>::max()) {
            std::cerr << "trim-blocklog does nothing unless specify first and/or last block.";
            return -1;
         }
         if (blog.last_block != std::numeric_limits<uint32_t>::max()) {
            if (trim_blocklog_end(vmap.at("blocks-dir").as<bfs::path>(), blog.last_block) != 0)
               return -1;
         }
         if (blog.first_block != 0) {
            if (!trim_blocklog_front(vmap.at("blocks-dir").as<bfs::path>(), blog.first_block))
               return -1;
         }
         return 0;
      }
      if (blog.vacuum) {
         blog.initialize(vmap);
         blog.do_vacuum();
         return 0;
      }
      if (blog.make_index) {
         const bfs::path blocks_dir = vmap.at("blocks-dir").as<bfs::path>();
         bfs::path out_file = blocks_dir / "blocks.index";
         const bfs::path block_file = blocks_dir / "blocks.log";
 
         if (vmap.count("output-file") > 0)
             out_file = vmap.at("output-file").as<bfs::path>();
 
         report_time rt("making index");
         const auto log_level = fc::logger::get(DEFAULT_LOGGER).get_log_level();
         fc::logger::get(DEFAULT_LOGGER).set_log_level(fc::log_level::debug);
         block_log::construct_index(block_file.generic_string(), out_file.generic_string());
         fc::logger::get(DEFAULT_LOGGER).set_log_level(log_level);
         rt.report();
         return 0;
      }
      //else print blocks.log as JSON
      blog.initialize(vmap);
      blog.read_log();
   } catch( const fc::exception& e ) {
      elog( "${e}", ("e", e.to_detail_string()));
      return -1;
   } catch( const boost::exception& e ) {
      elog("${e}", ("e",boost::diagnostic_information(e)));
      return -1;
   } catch( const std::exception& e ) {
      elog("${e}", ("e",e.what()));
      return -1;
   } catch( ... ) {
      elog("unknown exception");
      return -1;
   }
 
   return 0;
}

Here is the call graph for this function:

smoke_test()

void smoke_test

(

bfs::path

block_dir

)

Definition at line 262 of file main.cpp.

                                   {
   using namespace std;
   cout << "\nSmoke test of blocks.log and blocks.index in directory " << block_dir << '\n';
   trim_data td(block_dir);
   auto status = fseek(td.blk_in, -sizeof(uint64_t), SEEK_END);             //get last_block from blocks.log, compare to from blocks.index
   SYS_ASSERT( status == 0, block_log_exception, "cannot seek to ${file} ${pos} from beginning of file", ("file", td.block_file_name.string())("pos", sizeof(uint64_t)) );
   uint64_t file_pos;
   auto size = fread((void*)&file_pos, sizeof(uint64_t), 1, td.blk_in);
   SYS_ASSERT( size == 1, block_log_exception, "${file} read fails", ("file", td.block_file_name.string()) );
   status = fseek(td.blk_in, file_pos + trim_data::blknum_offset, SEEK_SET);
   SYS_ASSERT( status == 0, block_log_exception, "cannot seek to ${file} ${pos} from beginning of file", ("file", td.block_file_name.string())("pos", file_pos + trim_data::blknum_offset) );
   uint32_t bnum;
   size = fread((void*)&bnum, sizeof(uint32_t), 1, td.blk_in);
   SYS_ASSERT( size == 1, block_log_exception, "${file} read fails", ("file", td.block_file_name.string()) );
   bnum = endian_reverse_u32(bnum) + 1;                       //convert from big endian to little endian and add 1
   SYS_ASSERT( td.last_block == bnum, block_log_exception, "blocks.log says last block is ${lb} which disagrees with blocks.index", ("lb", bnum) );
   cout << "blocks.log and blocks.index agree on number of blocks\n";
   uint32_t delta = (td.last_block + 8 - td.first_block) >> 3;
   if (delta < 1)
      delta = 1;
   for (uint32_t n = td.first_block; ; n += delta) {
      if (n > td.last_block)
         n = td.last_block;
      td.block_pos(n);                                 //check block 'n' is where blocks.index says
      if (n == td.last_block)
         break;
   }
   cout << "\nno problems found\n";                         //if get here there were no exceptions
}

Here is the call graph for this function:

Here is the caller graph for this function:

trim_blocklog_end()

int trim_blocklog_end	(	bfs::path	block_dir,
		uint32_t	n )

Definition at line 231 of file main.cpp.

                                                     {       //n is last block to keep (remove later blocks)
   report_time rt("trimming blocklog end");
   using namespace std;
   trim_data td(block_dir);
   cout << "\nIn directory " << block_dir << " will trim all blocks after block " << n << " from "
        << td.block_file_name.generic_string() << " and " << td.index_file_name.generic_string() << ".\n";
   if (n < td.first_block) {
      cerr << "All blocks are after block " << n << " so do nothing (trim_end would delete entire blocks.log)\n";
      return 1;
   }
   if (n >= td.last_block) {
      cerr << "There are no blocks after block " << n << " so do nothing\n";
      return 2;
   }
   const uint64_t end_of_new_file = td.block_pos(n + 1);
   bfs::resize_file(td.block_file_name, end_of_new_file);
   const uint64_t index_end= td.block_index(n) + sizeof(uint64_t);             //advance past record for block n
   bfs::resize_file(td.index_file_name, index_end);
   cout << "blocks.index has been trimmed to " << index_end << " bytes\n";
   rt.report();
   return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

trim_blocklog_front()

bool trim_blocklog_front	(	bfs::path	block_dir,
		uint32_t	n )

Definition at line 254 of file main.cpp.

                                                        {        //n is first block to keep (remove prior blocks)
   report_time rt("trimming blocklog start");
   const bool status = block_log::trim_blocklog_front(block_dir, block_dir / "old", n);
   rt.report();
   return status;
}

Here is the call graph for this function:

Here is the caller graph for this function: