sysio::chain::fork_database_impl Struct Reference

Collaboration diagram for sysio::chain::fork_database_impl:

Public Member Functions
	fork_database_impl (const fc::path &data_dir)
void	open_impl (const std::function< void(block_timestamp_type, const flat_set< digest_type > &, const vector< digest_type > &)> &validator)
void	close_impl ()
block_header_state_ptr	get_block_header_impl (const block_id_type &id) const
block_state_ptr	get_block_impl (const block_id_type &id) const
void	reset_impl (const block_header_state &root_bhs)
void	rollback_head_to_root_impl ()
void	advance_root_impl (const block_id_type &id)
void	remove_impl (const block_id_type &id)
branch_type	fetch_branch_impl (const block_id_type &h, uint32_t trim_after_block_num) const
block_state_ptr	search_on_branch_impl (const block_id_type &h, uint32_t block_num) const
pair< branch_type, branch_type >	fetch_branch_from_impl (const block_id_type &first, const block_id_type &second) const
void	mark_valid_impl (const block_state_ptr &h)
void	add_impl (const block_state_ptr &n, bool ignore_duplicate, bool validate, const std::function< void(block_timestamp_type, const flat_set< digest_type > &, const vector< digest_type > &)> &validator)

Public Attributes
std::shared_mutex	mtx
fork_multi_index_type	index
block_state_ptr	root
block_state_ptr	head
fc::path	datadir

Detailed Description

Definition at line 63 of file fork_database.cpp.

Constructor & Destructor Documentation

fork_database_impl()

sysio::chain::fork_database_impl::fork_database_impl ( const fc::path & data_dir )

inlineexplicit

Definition at line 64 of file fork_database.cpp.

      :datadir(data_dir)
      {}

Member Function Documentation

add_impl()

void sysio::chain::fork_database_impl::add_impl	(	const block_state_ptr &	n,
		bool	ignore_duplicate,
		bool	validate,
		const std::function< void(block_timestamp_type, const flat_set< digest_type > &, const vector< digest_type > &)> &	validator )

Definition at line 348 of file fork_database.cpp.

   {
      SYS_ASSERT( root, fork_database_exception, "root not yet set" );
      SYS_ASSERT( n, fork_database_exception, "attempt to add null block state" );
 
      auto prev_bh = get_block_header_impl( n->header.previous );
 
      SYS_ASSERT( prev_bh, unlinkable_block_exception,
                  "unlinkable block", ("id", n->id)("previous", n->header.previous) );
 
      if( validate ) {
         try {
            const auto& exts = n->header_exts;
 
            if( exts.count(protocol_feature_activation::extension_id()) > 0 ) {
               const auto& new_protocol_features = std::get<protocol_feature_activation>(exts.lower_bound(protocol_feature_activation::extension_id())->second).protocol_features;
               validator( n->header.timestamp, prev_bh->activated_protocol_features->protocol_features, new_protocol_features );
            }
         } SYS_RETHROW_EXCEPTIONS( fork_database_exception, "serialized fork database is incompatible with configured protocol features"  )
      }
 
      auto inserted = index.insert(n);
      if( !inserted.second ) {
         if( ignore_duplicate ) return;
         SYS_THROW( fork_database_exception, "duplicate block added", ("id", n->id) );
      }
 
      auto candidate = index.get<by_lib_block_num>().begin();
      if( (*candidate)->is_valid() ) {
         head = *candidate;
      }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

advance_root_impl()

void sysio::chain::fork_database_impl::advance_root_impl

(

const block_id_type &

id

)

Definition at line 298 of file fork_database.cpp.

                                                                       {
      SYS_ASSERT( root, fork_database_exception, "root not yet set" );
 
      auto new_root = get_block_impl( id );
      SYS_ASSERT( new_root, fork_database_exception,
                  "cannot advance root to a block that does not exist in the fork database" );
      SYS_ASSERT( new_root->is_valid(), fork_database_exception,
                  "cannot advance root to a block that has not yet been validated" );
 
 
      deque<block_id_type> blocks_to_remove;
      for( auto b = new_root; b; ) {
         blocks_to_remove.emplace_back( b->header.previous );
         b = get_block_impl( blocks_to_remove.back() );
         SYS_ASSERT( b || blocks_to_remove.back() == root->id, fork_database_exception, "invariant violation: orphaned branch was present in forked database" );
      }
 
      // The new root block should be erased from the fork database index individually rather than with the remove method,
      // because we do not want the blocks branching off of it to be removed from the fork database.
      index.erase( index.find( id ) );
 
      // The other blocks to be removed are removed using the remove method so that orphaned branches do not remain in the fork database.
      for( const auto& block_id : blocks_to_remove ) {
         remove_impl( block_id );
      }
 
      // Even though fork database no longer needs block or trxs when a block state becomes a root of the tree,
      // avoid mutating the block state at all, for example clearing the block shared pointer, because other
      // parts of the code which run asynchronously may later expect it remain unmodified.
 
      root = new_root;
   }

Here is the call graph for this function:

close_impl()

void sysio::chain::fork_database_impl::close_impl

(

)

Definition at line 196 of file fork_database.cpp.

                                       {
      auto fork_db_dat = datadir / config::forkdb_filename;
 
      if( !root ) {
         if( index.size() > 0 ) {
            elog( "fork_database is in a bad state when closing; not writing out '${filename}'",
                  ("filename", fork_db_dat.generic_string()) );
         }
         return;
      }
 
      std::ofstream out( fork_db_dat.generic_string().c_str(), std::ios::out | std::ios::binary | std::ofstream::trunc );
      fc::raw::pack( out, fork_database::magic_number );
      fc::raw::pack( out, fork_database::max_supported_version ); // write out current version which is always max_supported_version
      fc::raw::pack( out, *static_cast<block_header_state*>(&*root) );
      uint32_t num_blocks_in_fork_db = index.size();
      fc::raw::pack( out, unsigned_int{num_blocks_in_fork_db} );
 
      const auto& indx = index.get<by_lib_block_num>();
 
      auto unvalidated_itr = indx.rbegin();
      auto unvalidated_end = boost::make_reverse_iterator( indx.lower_bound( false ) );
 
      auto validated_itr = unvalidated_end;
      auto validated_end = indx.rend();
 
      for(  bool unvalidated_remaining = (unvalidated_itr != unvalidated_end),
                 validated_remaining   = (validated_itr != validated_end);
 
            unvalidated_remaining || validated_remaining;
 
            unvalidated_remaining = (unvalidated_itr != unvalidated_end),
            validated_remaining   = (validated_itr != validated_end)
         )
      {
         auto itr = (validated_remaining ? validated_itr : unvalidated_itr);
 
         if( unvalidated_remaining && validated_remaining ) {
            if( first_preferred( **validated_itr, **unvalidated_itr ) ) {
               itr = unvalidated_itr;
               ++unvalidated_itr;
            } else {
               ++validated_itr;
            }
         } else if( unvalidated_remaining ) {
            ++unvalidated_itr;
         } else {
            ++validated_itr;
         }
 
         fc::raw::pack( out, *(*itr) );
      }
 
      if( head ) {
         fc::raw::pack( out, head->id );
      } else {
         elog( "head not set in fork database; '${filename}' will be corrupted",
               ("filename", fork_db_dat.generic_string()) );
      }
 
      index.clear();
   }

Here is the call graph for this function:

fetch_branch_from_impl()

pair< branch_type, branch_type > sysio::chain::fork_database_impl::fetch_branch_from_impl	(	const block_id_type &	first,
		const block_id_type &	second ) const

Definition at line 457 of file fork_database.cpp.

                                                                                                                    {
      pair<branch_type,branch_type> result;
      auto first_branch = (first == root->id) ? root : get_block_impl(first);
      auto second_branch = (second == root->id) ? root : get_block_impl(second);
 
      SYS_ASSERT(first_branch, fork_db_block_not_found, "block ${id} does not exist", ("id", first));
      SYS_ASSERT(second_branch, fork_db_block_not_found, "block ${id} does not exist", ("id", second));
 
      while( first_branch->block_num > second_branch->block_num )
      {
         result.first.push_back(first_branch);
         const auto& prev = first_branch->header.previous;
         first_branch = (prev == root->id) ? root : get_block_impl( prev );
         SYS_ASSERT( first_branch, fork_db_block_not_found,
                     "block ${id} does not exist",
                     ("id", prev)
         );
      }
 
      while( second_branch->block_num > first_branch->block_num )
      {
         result.second.push_back( second_branch );
         const auto& prev = second_branch->header.previous;
         second_branch = (prev == root->id) ? root : get_block_impl( prev );
         SYS_ASSERT( second_branch, fork_db_block_not_found,
                     "block ${id} does not exist",
                     ("id", prev)
         );
      }
 
      if (first_branch->id == second_branch->id) return result;
 
      while( first_branch->header.previous != second_branch->header.previous )
      {
         result.first.push_back(first_branch);
         result.second.push_back(second_branch);
         const auto &first_prev = first_branch->header.previous;
         first_branch = get_block_impl( first_prev );
         const auto &second_prev = second_branch->header.previous;
         second_branch = get_block_impl( second_prev );
         SYS_ASSERT( first_branch, fork_db_block_not_found,
                     "block ${id} does not exist",
                     ("id", first_prev)
         );
         SYS_ASSERT( second_branch, fork_db_block_not_found,
                     "block ${id} does not exist",
                     ("id", second_prev)
         );
      }
 
      if( first_branch && second_branch )
      {
         result.first.push_back(first_branch);
         result.second.push_back(second_branch);
      }
      return result;
   } 

Here is the call graph for this function:

fetch_branch_impl()

branch_type sysio::chain::fork_database_impl::fetch_branch_impl	(	const block_id_type &	h,
		uint32_t	trim_after_block_num ) const

Definition at line 423 of file fork_database.cpp.

                                                                                                                 {
      branch_type result;
      for( auto s = get_block_impl(h); s; s = get_block_impl( s->header.previous ) ) {
         if( s->block_num <= trim_after_block_num )
             result.push_back( s );
      }
 
      return result;
   }

Here is the call graph for this function:

get_block_header_impl()

block_header_state_ptr sysio::chain::fork_database_impl::get_block_header_impl

(

const block_id_type &

id

)

const

Definition at line 336 of file fork_database.cpp.

                                                                                                  {
      if( root->id == id ) {
         return root;
      }
 
      auto itr = index.find( id );
      if( itr != index.end() )
         return *itr;
 
      return block_header_state_ptr();
   }

Here is the caller graph for this function:

get_block_impl()

block_state_ptr sysio::chain::fork_database_impl::get_block_impl

(

const block_id_type &

id

)

const

Definition at line 573 of file fork_database.cpp.

                                                                                  {
      auto itr = index.find( id );
      if( itr != index.end() )
         return *itr;
      return block_state_ptr();
   }

Here is the caller graph for this function:

mark_valid_impl()

void sysio::chain::fork_database_impl::mark_valid_impl

(

const block_state_ptr &

h

)

Definition at line 548 of file fork_database.cpp.

                                                                      {
      if( h->validated ) return;
 
      auto& by_id_idx = index.get<by_block_id>();
 
      auto itr = by_id_idx.find( h->id );
      SYS_ASSERT( itr != by_id_idx.end(), fork_database_exception,
                  "block state not in fork database; cannot mark as valid",
                  ("id", h->id) );
 
      by_id_idx.modify( itr, []( block_state_ptr& bsp ) {
         bsp->validated = true;
      } );
 
      auto candidate = index.get<by_lib_block_num>().begin();
      if( first_preferred( **candidate, *head ) ) {
         head = *candidate;
      }
   }

Here is the call graph for this function:

open_impl()

void sysio::chain::fork_database_impl::open_impl

(

const std::function< void(block_timestamp_type, const flat_set< digest_type > &, const vector< digest_type > &)> &

validator

)

Definition at line 113 of file fork_database.cpp.

   {
      if (!fc::is_directory(datadir))
         fc::create_directories(datadir);
 
      auto fork_db_dat = datadir / config::forkdb_filename;
      if( fc::exists( fork_db_dat ) ) {
         try {
            string content;
            fc::read_file_contents( fork_db_dat, content );
 
            fc::datastream<const char*> ds( content.data(), content.size() );
 
            // validate totem
            uint32_t totem = 0;
            fc::raw::unpack( ds, totem );
            SYS_ASSERT( totem == fork_database::magic_number, fork_database_exception,
                        "Fork database file '${filename}' has unexpected magic number: ${actual_totem}. Expected ${expected_totem}",
                        ("filename", fork_db_dat.generic_string())
                        ("actual_totem", totem)
                        ("expected_totem", fork_database::magic_number)
            );
 
            // validate version
            uint32_t version = 0;
            fc::raw::unpack( ds, version );
            SYS_ASSERT( version >= fork_database::min_supported_version && version <= fork_database::max_supported_version,
                        fork_database_exception,
                       "Unsupported version of fork database file '${filename}'. "
                       "Fork database version is ${version} while code supports version(s) [${min},${max}]",
                       ("filename", fork_db_dat.generic_string())
                       ("version", version)
                       ("min", fork_database::min_supported_version)
                       ("max", fork_database::max_supported_version)
            );
 
            block_header_state bhs;
            fc::raw::unpack( ds, bhs );
            reset_impl( bhs );
 
            unsigned_int size; fc::raw::unpack( ds, size );
            for( uint32_t i = 0, n = size.value; i < n; ++i ) {
               block_state s;
               fc::raw::unpack( ds, s );
               // do not populate transaction_metadatas, they will be created as needed in apply_block with appropriate key recovery
               s.header_exts = s.block->validate_and_extract_header_extensions();
               add_impl( std::make_shared<block_state>( std::move( s ) ), false, true, validator );
            }
            block_id_type head_id;
            fc::raw::unpack( ds, head_id );
 
            if( root->id == head_id ) {
               head = root;
            } else {
               head = get_block_impl( head_id );
               SYS_ASSERT( head, fork_database_exception,
                           "could not find head while reconstructing fork database from file; '${filename}' is likely corrupted",
                           ("filename", fork_db_dat.generic_string()) );
            }
 
            auto candidate = index.get<by_lib_block_num>().begin();
            if( candidate == index.get<by_lib_block_num>().end() || !(*candidate)->is_valid() ) {
               SYS_ASSERT( head->id == root->id, fork_database_exception,
                           "head not set to root despite no better option available; '${filename}' is likely corrupted",
                           ("filename", fork_db_dat.generic_string()) );
            } else {
               SYS_ASSERT( !first_preferred( **candidate, *head ), fork_database_exception,
                           "head not set to best available option available; '${filename}' is likely corrupted",
                           ("filename", fork_db_dat.generic_string()) );
            }
         } FC_CAPTURE_AND_RETHROW( (fork_db_dat) )
 
         fc::remove( fork_db_dat );
      }
   }

Here is the call graph for this function:

remove_impl()

void sysio::chain::fork_database_impl::remove_impl

(

const block_id_type &

id

)

Definition at line 522 of file fork_database.cpp.

                                                                 {
      deque<block_id_type> remove_queue{id};
      const auto& previdx = index.get<by_prev>();
      const auto& head_id = head->id;
 
      for( uint32_t i = 0; i < remove_queue.size(); ++i ) {
         SYS_ASSERT( remove_queue[i] != head_id, fork_database_exception,
                     "removing the block and its descendants would remove the current head block" );
 
         auto previtr = previdx.lower_bound( remove_queue[i] );
         while( previtr != previdx.end() && (*previtr)->header.previous == remove_queue[i] ) {
            remove_queue.emplace_back( (*previtr)->id );
            ++previtr;
         }
      }
 
      for( const auto& block_id : remove_queue ) {
         index.erase( block_id );
      }
   }

Here is the caller graph for this function:

reset_impl()

void sysio::chain::fork_database_impl::reset_impl

(

const block_header_state &

root_bhs

)

Definition at line 268 of file fork_database.cpp.

                                                                           {
      index.clear();
      root = std::make_shared<block_state>();
      static_cast<block_header_state&>(*root) = root_bhs;
      root->validated = true;
      head = root;
   }

Here is the caller graph for this function:

rollback_head_to_root_impl()

void sysio::chain::fork_database_impl::rollback_head_to_root_impl

(

)

Definition at line 281 of file fork_database.cpp.

                                                       {
      auto& by_id_idx = index.get<by_block_id>();
      auto itr = by_id_idx.begin();
      while (itr != by_id_idx.end()) {
         by_id_idx.modify( itr, [&]( block_state_ptr& bsp ) {
            bsp->validated = false;
         } );
         ++itr;
      }
      head = root;
   }

search_on_branch_impl()

block_state_ptr sysio::chain::fork_database_impl::search_on_branch_impl	(	const block_id_type &	h,
		uint32_t	block_num ) const

Definition at line 438 of file fork_database.cpp.

                                                                                                              {
      for( auto s = get_block_impl(h); s; s = get_block_impl( s->header.previous ) ) {
         if( s->block_num == block_num )
             return s;
      }
 
      return {};
   }

Here is the call graph for this function:

Member Data Documentation

datadir

fc::path sysio::chain::fork_database_impl::datadir

Definition at line 72 of file fork_database.cpp.

head

block_state_ptr sysio::chain::fork_database_impl::head

Definition at line 71 of file fork_database.cpp.

index

fork_multi_index_type sysio::chain::fork_database_impl::index

Definition at line 69 of file fork_database.cpp.

mtx

std::shared_mutex sysio::chain::fork_database_impl::mtx

Definition at line 68 of file fork_database.cpp.

root

block_state_ptr sysio::chain::fork_database_impl::root

Definition at line 70 of file fork_database.cpp.

---

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

• libraries/chain/fork_database.cpp