344 lines
11 KiB
C++
344 lines
11 KiB
C++
/*
|
|
* Copyright (c) 2015 Cryptonomex, Inc., and contributors.
|
|
*
|
|
* The MIT License
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in
|
|
* all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
* THE SOFTWARE.
|
|
*/
|
|
|
|
#include <graphene/chain/database.hpp>
|
|
|
|
#include <graphene/chain/chain_property_object.hpp>
|
|
#include <graphene/chain/witness_schedule_object.hpp>
|
|
#include <graphene/chain/special_authority_object.hpp>
|
|
#include <graphene/chain/operation_history_object.hpp>
|
|
#include <graphene/chain/nft_object.hpp>
|
|
#include <graphene/chain/protocol/fee_schedule.hpp>
|
|
|
|
#include <fc/io/fstream.hpp>
|
|
|
|
#include <fstream>
|
|
#include <functional>
|
|
#include <iostream>
|
|
|
|
namespace graphene { namespace chain {
|
|
|
|
database::database() :
|
|
_random_number_generator(fc::ripemd160().data())
|
|
{
|
|
initialize_indexes();
|
|
initialize_evaluators();
|
|
initialize_hardforks();
|
|
}
|
|
|
|
database::~database()
|
|
{
|
|
clear_pending();
|
|
}
|
|
|
|
// Right now, we leave undo_db enabled when replaying when the bookie plugin is
|
|
// enabled. It depends on new/changed/removed object notifications, and those are
|
|
// only fired when the undo_db is enabled.
|
|
// So we use this helper object to disable undo_db only if it is not forbidden
|
|
// with _slow_replays flag.
|
|
class auto_undo_enabler
|
|
{
|
|
const bool _slow_replays;
|
|
undo_database& _undo_db;
|
|
bool _disabled;
|
|
public:
|
|
auto_undo_enabler(bool slow_replays, undo_database& undo_db) :
|
|
_slow_replays(slow_replays),
|
|
_undo_db(undo_db),
|
|
_disabled(false)
|
|
{
|
|
}
|
|
|
|
~auto_undo_enabler()
|
|
{
|
|
try{
|
|
enable();
|
|
} FC_CAPTURE_AND_LOG(("undo_db enabling crash"))
|
|
}
|
|
|
|
void enable()
|
|
{
|
|
if(!_disabled)
|
|
return;
|
|
_undo_db.enable();
|
|
_disabled = false;
|
|
}
|
|
|
|
void disable()
|
|
{
|
|
if(_disabled)
|
|
return;
|
|
if(_slow_replays)
|
|
return;
|
|
_undo_db.disable();
|
|
_disabled = true;
|
|
}
|
|
};
|
|
|
|
void database::reindex( fc::path data_dir )
|
|
{ try {
|
|
auto last_block = _block_id_to_block.last();
|
|
if( !last_block ) {
|
|
elog( "!no last block" );
|
|
edump((last_block));
|
|
return;
|
|
}
|
|
if( last_block->block_num() <= head_block_num()) return;
|
|
|
|
ilog( "reindexing blockchain" );
|
|
auto start = fc::time_point::now();
|
|
const auto last_block_num = last_block->block_num();
|
|
uint32_t undo_point = last_block_num < 50 ? 0 : last_block_num - 50;
|
|
|
|
ilog( "Replaying blocks, starting at ${next}...", ("next",head_block_num() + 1) );
|
|
auto_undo_enabler undo(_slow_replays, _undo_db);
|
|
if( head_block_num() >= undo_point )
|
|
{
|
|
if( head_block_num() > 0 )
|
|
_fork_db.start_block( *fetch_block_by_number( head_block_num() ) );
|
|
}
|
|
else
|
|
{
|
|
undo.disable();
|
|
}
|
|
for( uint32_t i = head_block_num() + 1; i <= last_block_num; ++i )
|
|
{
|
|
if( i % 1000000 == 0 )
|
|
{
|
|
ilog( "Writing database to disk at block ${i}", ("i",i) );
|
|
flush();
|
|
ilog( "Done" );
|
|
}
|
|
fc::optional< signed_block > block = _block_id_to_block.fetch_by_number(i);
|
|
if( !block.valid() )
|
|
{
|
|
wlog( "Reindexing terminated due to gap: Block ${i} does not exist!", ("i", i) );
|
|
uint32_t dropped_count = 0;
|
|
while( true )
|
|
{
|
|
fc::optional< block_id_type > last_id = _block_id_to_block.last_id();
|
|
// this can trigger if we attempt to e.g. read a file that has block #2 but no block #1
|
|
if( !last_id.valid() )
|
|
break;
|
|
// we've caught up to the gap
|
|
if( block_header::num_from_id( *last_id ) <= i )
|
|
break;
|
|
_block_id_to_block.remove( *last_id );
|
|
dropped_count++;
|
|
}
|
|
wlog( "Dropped ${n} blocks from after the gap", ("n", dropped_count) );
|
|
break;
|
|
}
|
|
if( i < undo_point && !_slow_replays)
|
|
{
|
|
apply_block(*block, skip_witness_signature |
|
|
skip_transaction_signatures |
|
|
skip_transaction_dupe_check |
|
|
skip_tapos_check |
|
|
skip_witness_schedule_check |
|
|
skip_authority_check);
|
|
}
|
|
else
|
|
{
|
|
undo.enable();
|
|
push_block(*block, skip_witness_signature |
|
|
skip_transaction_signatures |
|
|
skip_transaction_dupe_check |
|
|
skip_tapos_check |
|
|
skip_witness_schedule_check |
|
|
skip_authority_check);
|
|
}
|
|
}
|
|
undo.enable();
|
|
auto end = fc::time_point::now();
|
|
ilog( "Done reindexing, elapsed time: ${t} sec", ("t",double((end-start).count())/1000000.0 ) );
|
|
} FC_CAPTURE_AND_RETHROW( (data_dir) ) }
|
|
|
|
void database::wipe(const fc::path& data_dir, bool include_blocks)
|
|
{
|
|
ilog("Wiping database", ("include_blocks", include_blocks));
|
|
if (_opened) {
|
|
close(false);
|
|
}
|
|
object_database::wipe(data_dir);
|
|
if( include_blocks )
|
|
fc::remove_all( data_dir / "database" );
|
|
}
|
|
|
|
void database::open(
|
|
const fc::path& data_dir,
|
|
std::function<genesis_state_type()> genesis_loader,
|
|
const std::string& db_version)
|
|
{
|
|
try
|
|
{
|
|
bool wipe_object_db = false;
|
|
if( !fc::exists( data_dir / "db_version" ) )
|
|
wipe_object_db = true;
|
|
else
|
|
{
|
|
std::string version_string;
|
|
fc::read_file_contents( data_dir / "db_version", version_string );
|
|
wipe_object_db = ( version_string != db_version );
|
|
}
|
|
if( wipe_object_db ) {
|
|
ilog("Wiping object_database due to missing or wrong version");
|
|
object_database::wipe( data_dir );
|
|
std::ofstream version_file( (data_dir / "db_version").generic_string().c_str(),
|
|
std::ios::out | std::ios::binary | std::ios::trunc );
|
|
version_file.write( db_version.c_str(), db_version.size() );
|
|
version_file.close();
|
|
}
|
|
|
|
object_database::open(data_dir);
|
|
|
|
_block_id_to_block.open(data_dir / "database" / "block_num_to_block");
|
|
|
|
if( !find(global_property_id_type()) )
|
|
init_genesis(genesis_loader());
|
|
else
|
|
{
|
|
_p_core_asset_obj = &get( asset_id_type() );
|
|
_p_core_dynamic_data_obj = &get( asset_dynamic_data_id_type() );
|
|
_p_global_prop_obj = &get( global_property_id_type() );
|
|
_p_chain_property_obj = &get( chain_property_id_type() );
|
|
_p_dyn_global_prop_obj = &get( dynamic_global_property_id_type() );
|
|
_p_witness_schedule_obj = &get( witness_schedule_id_type() );
|
|
}
|
|
|
|
fc::optional<block_id_type> last_block = _block_id_to_block.last_id();
|
|
if( last_block.valid() )
|
|
{
|
|
FC_ASSERT( *last_block >= head_block_id(),
|
|
"last block ID does not match current chain state",
|
|
("last_block->id", last_block)("head_block_id",head_block_num()) );
|
|
|
|
_block_id_to_block.set_replay_mode(true);
|
|
|
|
reindex( data_dir );
|
|
|
|
_block_id_to_block.set_replay_mode(false);
|
|
}
|
|
_opened = true;
|
|
}
|
|
FC_CAPTURE_LOG_AND_RETHROW( (data_dir) )
|
|
}
|
|
|
|
void database::close(bool rewind)
|
|
{
|
|
if (!_opened)
|
|
return;
|
|
|
|
// TODO: Save pending tx's on close()
|
|
clear_pending();
|
|
|
|
// pop all of the blocks that we can given our undo history, this should
|
|
// throw when there is no more undo history to pop
|
|
if( rewind )
|
|
{
|
|
try
|
|
{
|
|
uint32_t cutoff = get_dynamic_global_properties().last_irreversible_block_num;
|
|
|
|
while( head_block_num() > cutoff )
|
|
{
|
|
block_id_type popped_block_id = head_block_id();
|
|
pop_block();
|
|
_fork_db.remove(popped_block_id); // doesn't throw on missing
|
|
}
|
|
}
|
|
catch ( const fc::exception& e )
|
|
{
|
|
wlog( "Database close unexpected exception: ${e}", ("e", e) );
|
|
}
|
|
}
|
|
|
|
// Since pop_block() will move tx's in the popped blocks into pending,
|
|
// we have to clear_pending() after we're done popping to get a clean
|
|
// DB state (issue #336).
|
|
clear_pending();
|
|
|
|
object_database::flush();
|
|
object_database::close();
|
|
|
|
if( _block_id_to_block.is_open() )
|
|
_block_id_to_block.close();
|
|
|
|
_fork_db.reset();
|
|
|
|
_opened = false;
|
|
}
|
|
|
|
void database::force_slow_replays()
|
|
{
|
|
ilog("enabling slow replays");
|
|
_slow_replays = true;
|
|
}
|
|
|
|
void database::check_ending_lotteries()
|
|
{
|
|
try {
|
|
const auto& lotteries_idx = get_index_type<asset_index>().indices().get<active_lotteries>();
|
|
for( auto checking_asset: lotteries_idx )
|
|
{
|
|
FC_ASSERT( checking_asset.is_lottery() );
|
|
FC_ASSERT( checking_asset.lottery_options->is_active );
|
|
FC_ASSERT( checking_asset.lottery_options->end_date != time_point_sec() );
|
|
if( checking_asset.lottery_options->end_date > head_block_time() ) continue;
|
|
checking_asset.end_lottery(*this);
|
|
}
|
|
} catch( ... ) {}
|
|
}
|
|
|
|
void database::check_ending_nft_lotteries()
|
|
{
|
|
try {
|
|
const auto &nft_lotteries_idx = get_index_type<nft_metadata_index>().indices().get<active_nft_lotteries>();
|
|
for (auto checking_token : nft_lotteries_idx)
|
|
{
|
|
FC_ASSERT(checking_token.is_lottery());
|
|
const auto &lottery_options = checking_token.lottery_data->lottery_options;
|
|
FC_ASSERT(lottery_options.is_active);
|
|
// Check the current supply of lottery tokens
|
|
auto current_supply = checking_token.get_token_current_supply(*this);
|
|
if ((lottery_options.ending_on_soldout && (current_supply == checking_token.max_supply)) ||
|
|
(lottery_options.end_date != time_point_sec() && (lottery_options.end_date <= head_block_time())))
|
|
checking_token.end_lottery(*this);
|
|
}
|
|
} catch( ... ) {}
|
|
}
|
|
|
|
void database::check_lottery_end_by_participants( asset_id_type asset_id )
|
|
{
|
|
try {
|
|
asset_object asset_to_check = asset_id( *this );
|
|
auto asset_dyn_props = asset_to_check.dynamic_data( *this );
|
|
FC_ASSERT( asset_dyn_props.current_supply == asset_to_check.options.max_supply );
|
|
FC_ASSERT( asset_to_check.is_lottery() );
|
|
FC_ASSERT( asset_to_check.lottery_options->ending_on_soldout );
|
|
asset_to_check.end_lottery( *this );
|
|
} catch( ... ) {}
|
|
}
|
|
|
|
} }
|