~impl() {
try {
tcp_serv.close();
if( accept_complete.valid() )
accept_complete.wait();
}catch(...){}
}
~client()
{
try {
if( chain_connect_loop_complete.valid() )
{
try {
_chain_con.close();
chain_connect_loop_complete.cancel();
chain_connect_loop_complete.wait();
}
catch( fc::exception& e )
{
wlog( "unhandled exception thrown in destructor.\n${e}", ("e", e.to_detail_string() ) );
}
}
_tcp_serv.close();
if( _accept_loop_complete.valid() )
{
_accept_loop_complete.cancel();
_accept_loop_complete.wait();
}
}
catch ( const fc::canceled_exception& ){}
catch ( const fc::exception& e )
{
wlog( "unhandled exception thrown in destructor.\n${e}", ("e", e.to_detail_string() ) );
}
}
void accept_loop() throw()
{
try
{
while( !accept_loop_complete.canceled() )
{
auto sock = std::make_shared<fc::tcp_socket>();
tcp_serv.accept( *sock );
// do the acceptance process async
fc::async( [=](){ accept_connection( sock ); } );
fc::usleep(fc::microseconds(1000) );
}
}
catch ( fc::eof_exception& e )
{
ilog( "accept loop eof" );
}
catch ( fc::canceled_exception& e )
{
ilog( "accept loop canceled" );
}
catch ( fc::exception& e )
{
elog( "tcp server socket threw exception\n ${e}",
("e", e.to_detail_string() ) );
// TODO: notify the server delegate of the error.
}
catch( ... )
{
elog( "unexpected exception" );
}
}
void client_impl::trustee_loop()
{
_last_block = _chain_db->get_head_block().timestamp;
while (!_trustee_loop_complete.canceled())
{
signed_transactions pending_trxs;
pending_trxs = get_pending_transactions();
if (pending_trxs.size() && (fc::time_point::now() - _last_block) > fc::seconds(30))
{
try {
bts::blockchain::trx_block blk = _wallet->generate_next_block(*_chain_db, pending_trxs);
blk.sign(_trustee_key);
// _chain_db->push_block( blk );
if (_chain_client)
_chain_client->broadcast_block(blk);
else
{
_p2p_node->broadcast(block_message(blk.id(), blk, blk.trustee_signature));
// with the p2p code, if you broadcast something to the network, it will not
// immediately send it back to you
on_new_block(blk);
}
_last_block = fc::time_point::now();
}
catch (const fc::exception& e)
{
elog("error producing block?: ${e}", ("e", e.to_detail_string()));
}
}
fc::usleep(fc::seconds(1));
}
}
void accept_loop() {
while( !accept_complete.canceled() )
{
http::connection_ptr con = std::make_shared<http::connection>();
tcp_serv.accept( con->get_socket() );
//ilog( "Accept Connection" );
fc::async( [=](){ handle_connection( con, on_req ); }, "http_server handle_connection" );
}
}
~bts_server_process_info()
{
server_process->kill();
if (stdout_reader_done.valid() && !stdout_reader_done.ready())
stdout_reader_done.wait();
if (stderr_reader_done.valid() && !stderr_reader_done.ready())
stderr_reader_done.wait();
}
void block_generation_loop()
{
while( !_block_gen_loop_complete.canceled() )
{
if( _pending.size() && (fc::time_point::now() - _current_block.timestamp) > fc::seconds(60) )
{
signed_block next_block;
next_block.number = _current_block.number + 1;
auto next_diff = _current_block.difficulty * 500 / _pending.size();
next_diff = (_current_block.difficulty * 99 + next_diff) / 100;
next_block.difficulty = std::max<uint64_t>(next_diff, 1000 );
next_block.timestamp = fc::time_point::now();
for( auto rec : _pending )
{
next_block.records.push_back( rec.second );
}
next_block.sign( _trustee_key );
_block_database.store(next_block.number,next_block);
for( uint32_t rec = 0; rec < next_block.records.size(); ++rec )
{
auto new_rec = next_block.records[rec];
auto hist = _self->fetch_history( new_rec.name );
hist.updates.push_back( name_index( next_block.number, rec ) );
_name_index.store( new_rec.name, hist );
_key_to_name.store( new_rec.active_key.to_base58(), new_rec.name );
}
_current_block = next_block;
_current_block_id = _current_block.id();
fc::path block_file = _data_dir / "block" / fc::to_string( uint64_t(_current_block.number) );
std::ofstream out( block_file.generic_string().c_str() );
auto block_str = fc::json::to_pretty_string( _current_block );
out.write( block_str.c_str(), block_str.size() );
}
fc::usleep( fc::seconds( 1 ) );
}
}
void accept_loop()
{
while( !_accept_loop_complete.canceled() )
{
fc::tcp_socket_ptr sock = std::make_shared<fc::tcp_socket>();
try
{
_tcp_serv.accept( *sock );
}
catch ( const fc::exception& e )
{
elog( "fatal: error opening socket for rpc connection: ${e}", ("e", e.to_detail_string() ) );
return;
}
auto buf_istream = std::make_shared<fc::buffered_istream>( sock );
auto buf_ostream = std::make_shared<fc::buffered_ostream>( sock );
auto json_con = std::make_shared<fc::rpc::json_connection>( std::move(buf_istream), std::move(buf_ostream) );
register_methods( json_con );
fc::async( [json_con]{ json_con->exec().wait(); } );
}
}
/**
* This method is called async
*/
void accept_loop() throw()
{
try
{
while( !accept_loop_complete.canceled() )
{
stcp_socket_ptr sock = std::make_shared<stcp_socket>();
tcp_serv.accept( sock->get_socket() );
// do the acceptance process async
fc::async( [=](){ accept_connection( sock ); } );
// limit the rate at which we accept connections to prevent
// DOS attacks.
fc::usleep( fc::microseconds( 1000*1 ) );
}
}
catch ( fc::eof_exception& e )
{
ilog( "accept loop eof" );
}
catch ( fc::canceled_exception& e )
{
ilog( "accept loop canceled" );
}
catch ( fc::exception& e )
{
elog( "tcp server socket threw exception\n ${e}",
("e", e.to_detail_string() ) );
// TODO: notify the server delegate of the error.
}
catch( ... )
{
elog( "unexpected exception" );
}
}
~impl() {
try {
tcp_serv.close();
accept_complete.wait();
}catch(...){}
}
void read_loop()
{
const int BUFFER_SIZE = 16;
const int LEFTOVER = BUFFER_SIZE - sizeof(message_header);
try {
message m;
while( !_read_loop_complete.canceled() )
{
char tmp[BUFFER_SIZE];
sock->read( tmp, BUFFER_SIZE );
memcpy( (char*)&m, tmp, sizeof(message_header) );
m.data.resize( m.size + 16 ); //give extra 16 bytes to allow for padding added in send call
memcpy( (char*)m.data.data(), tmp + sizeof(message_header), LEFTOVER );
sock->read( m.data.data() + LEFTOVER, 16*((m.size -LEFTOVER + 15)/16) );
m.data.resize(m.size);
try { // message handling errors are warnings...
con_del->on_connection_message( self, m );
}
catch ( fc::canceled_exception& e ) { wlog(".");throw; }
catch ( fc::eof_exception& e ) { wlog(".");throw; }
catch ( fc::exception& e )
{
wlog( "disconnected ${er}", ("er", e.to_detail_string() ) );
return;
// TODO: log and potentiall disconnect... for now just warn.
}
catch( ... )
{
wlog("...????" );
return;
}
}
}
catch ( const fc::canceled_exception& e )
{
if( con_del )
{
con_del->on_connection_disconnected( self );
}
else
{
wlog( "disconnected ${e}", ("e", e.to_detail_string() ) );
}
wlog( "exit read loop" );
return;
}
catch ( const fc::eof_exception& e )
{
if( con_del )
{
ilog( ".");
fc::async( [=](){con_del->on_connection_disconnected( self );} );
ilog( ".");
}
else
{
wlog( "disconnected ${e}", ("e", e.to_detail_string() ) );
}
}
catch ( fc::exception& er )
{
wlog( ".." );
if( con_del )
{
elog( "disconnected ${er}", ("er", er.to_detail_string() ) );
//con_del->on_connection_disconnected( self );
fc::async( [=](){con_del->on_connection_disconnected( self );} );
}
else
{
elog( "disconnected ${e}", ("e", er.to_detail_string() ) );
}
FC_RETHROW_EXCEPTION( er, warn, "disconnected ${e}", ("e", er.to_detail_string() ) );
}
catch ( ... )
{
wlog( "unhandled??" );
// TODO: call con_del->????
FC_THROW_EXCEPTION( unhandled_exception, "disconnected: {e}", ("e", fc::except_str() ) );
}
}
int wait_any( fc::future<T1>& f1, fc::future<T2>& f2, const microseconds& timeout_us = microseconds::max() ) {
fc::vector<promise_base::ptr> p(2);
p[0] = static_pointer_cast<promise_base*>(f1.promise());
p[1] = static_pointer_cast<promise_base*>(f2.promise());
return wait( fc::move(p), timeout_us );
}
void mining_loop()
{
while( !_mining_loop_complete.canceled() )
{
try {
if( _current_block.prev == block_id_type() || !_callback || _effort < 0.01 || _prev_header.next_difficulty == 0 )
{
ilog( "${current.prev} _effort ${effort} prev_header: ${prev_header}",
("current.prev",_current_block.prev)("effort",_effort)("prev_header",_prev_header) );
fc::usleep( fc::microseconds( 1000*1000 ) );
continue;
}
auto start = fc::time_point::now();
block_header tmp = _current_block;
tmp.timestamp = fc::time_point::now();
auto next_diff = _prev_header.next_difficulty * 300*1000000ll / (tmp.timestamp - _prev_header.timestamp).count();
tmp.next_difficulty = (_prev_header.next_difficulty * 24 + next_diff ) / 25;
tmp.noncea = 0;
tmp.nonceb = 0;
auto tmp_id = tmp.id();
auto seed = fc::sha256::hash( (char*)&tmp_id, sizeof(tmp_id) );
auto pairs = momentum_search( seed );
for( auto collision : pairs )
{
tmp.noncea = collision.first;
tmp.nonceb = collision.second;
FC_ASSERT( _min_votes > 0 );
FC_ASSERT( _prev_header.next_difficulty > 0 );
ilog( "difficlty ${d} target ${t} tmp.get_difficulty ${dd} mv ${mv} min: ${min} block:\n${block}", ("min",_min_votes)("mv",_miner_votes)("dd",tmp.get_difficulty())
("d",(tmp.get_difficulty() * _miner_votes)/_min_votes)("t",_prev_header.next_difficulty)("block",_current_block) );
if( (tmp.get_difficulty() * _miner_votes)/_min_votes >= _prev_header.next_difficulty )
{
if( _callback )
{
auto cb = _callback;
_main_thread->async( [cb,tmp](){cb( tmp );} );
}
_effort = 0;
break;
}
}
// search space...
auto end = fc::time_point::now();
// wait while checking for cancel...
if( _effort < 1.0 )
{
auto calc_time = (end-start).count();
auto wait_time = ((1-_effort)/_effort) * calc_time;
auto wait_until = end + fc::microseconds(wait_time);
if( wait_until > fc::time_point::now() && !_mining_loop_complete.canceled() )
{
ilog( "." );
fc::usleep( fc::microseconds( 1000*100 ) );
}
}
else
{
ilog( "." );
fc::usleep( fc::microseconds(1000*10) );
}
}
catch ( const fc::exception& e )
{
wlog( "${e}", ("e",e.to_detail_string() ));
}
} // while
} /// mining_loop