channel_proxy::channel_proxy(threadpool& pool, socket_ptr socket)
: strand_(pool.service()), socket_(socket),
timeout_(pool.service()), heartbeat_(pool.service()), stopped_(false)
{
#define CHANNEL_TRANSPORT_MECHANISM(MESSAGE_TYPE) \
MESSAGE_TYPE##_subscriber_ = \
std::make_shared<MESSAGE_TYPE##_subscriber_type>(pool); \
loader_.add(new channel_loader_module<MESSAGE_TYPE##_type>( \
std::bind(&MESSAGE_TYPE##_subscriber_type::relay, \
MESSAGE_TYPE##_subscriber_, _1, _2)));
CHANNEL_TRANSPORT_MECHANISM(version);
CHANNEL_TRANSPORT_MECHANISM(verack);
CHANNEL_TRANSPORT_MECHANISM(address);
CHANNEL_TRANSPORT_MECHANISM(get_address);
CHANNEL_TRANSPORT_MECHANISM(inventory);
CHANNEL_TRANSPORT_MECHANISM(get_data);
CHANNEL_TRANSPORT_MECHANISM(get_blocks);
CHANNEL_TRANSPORT_MECHANISM(transaction);
CHANNEL_TRANSPORT_MECHANISM(block);
#undef CHANNEL_TRANSPORT_MECHANISM
raw_subscriber_ = std::make_shared<raw_subscriber_type>(pool);
stop_subscriber_ = std::make_shared<stop_subscriber_type>(pool);
}
connector::connector(threadpool& pool, const settings& settings)
: pool_(pool),
settings_(settings),
resolver_(std::make_shared<asio::resolver>(pool.service())),
CONSTRUCT_TRACK(connector, LOG_NETWORK)
{
}
protocol::protocol(threadpool& pool, hosts& hsts,
handshake& shake, network& net)
: strand_(pool), hosts_(hsts), handshake_(shake), network_(net),
watermark_timer_(pool.service())
{
channel_subscribe_ = std::make_shared<channel_subscriber_type>(pool);
}
session::session(threadpool& pool, const session_params& params)
: strand_(pool.service()),
handshake_(params.handshake_), protocol_(params.protocol_),
chain_(params.blockchain_), poll_(params.poller_),
tx_pool_(params.transaction_pool_),
grabbed_invs_(20)
{
}
void print_tp_status(threadpool &tp) {
std::stringstream ss;
for(u_int i=0;i<num_threads;i++){
std::string status = tp.get_thread_status(i);
if(status.size() && status!="Free"){
ss << "Thread " << i << ": " << status << "\n";
}
}
std::cout << ss.str() << "\n";
}
connector::connector(threadpool& pool, const settings& settings)
: stopped_(false),
pool_(pool),
settings_(settings),
pending_(settings_),
dispatch_(pool, NAME),
resolver_(std::make_shared<asio::resolver>(pool.service())),
CONSTRUCT_TRACK(connector)
{
}
work::work(threadpool& pool, const std::string& name)
: name_(name),
////ordered_(std::make_shared<monitor::count>(0)),
////unordered_(std::make_shared<monitor::count>(0)),
////concurrent_(std::make_shared<monitor::count>(0)),
////sequential_(std::make_shared<monitor::count>(0)),
service_(pool.service()),
strand_(service_),
sequence_(service_)
{
}
blockchain_impl::blockchain_impl(threadpool& pool, const std::string& prefix,
const db_active_heights &active_heights, size_t orphan_capacity)
: ios_(pool.service()), write_strand_(pool), reorg_strand_(pool),
flock_(init_lock(prefix)), seqlock_(0), stopped_(false), db_paths_(prefix),
interface_(db_paths_, active_heights), orphans_(orphan_capacity),
chain_(simple_chain_impl(interface_)),
reorganize_subscriber_(std::make_shared<reorganize_subscriber_type>(pool)),
organizer_(organizer_factory(reorg_strand_, interface_, orphans_, chain_,
reorganize_subscriber_))
{
}
void fullnode::stop()
{
std::promise<std::error_code> ec_promise;
auto session_stopped =
[&ec_promise](const std::error_code& ec)
{
ec_promise.set_value(ec);
};
session_.stop(session_stopped);
std::error_code ec = ec_promise.get_future().get();
if (ec)
log_error() << "Problem stopping session: " << ec.message();
// Stop threadpools.
net_pool_.stop();
disk_pool_.stop();
mem_pool_.stop();
// Join threadpools. Wait for them to finish.
net_pool_.join();
disk_pool_.join();
mem_pool_.join();
// Safely close blockchain database.
chain_.stop();
}
handshake::handshake(threadpool& pool)
: strand_(pool.service())
{
// Setup template version packet with defaults
template_version_.version = protocol_version;
template_version_.services = 1;
// non-constant field
//template_version_.timestamp = time(NULL);
template_version_.address_me.services = template_version_.services;
template_version_.address_me.ip = localhost_ip();
template_version_.address_me.port = protocol_port;
template_version_.address_you.services = template_version_.services;
template_version_.address_you.ip =
ip_address_type{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0xff, 0xff, 0x0a, 0x00, 0x00, 0x01}};
template_version_.address_you.port = protocol_port;
template_version_.user_agent = "/libbitcoin:" LIBBITCOIN_VERSION "/";
template_version_.start_height = 0;
template_version_.nonce = rand();
}
handshake::handshake(threadpool& pool, p2p_network p2p)
: strand_(pool.service()), p2p_(p2p)
{
// Setup template version packet with defaults
template_version_.version = protocol_version;
template_version_.services = 1;
// non-constant field
//template_version_.timestamp = time(NULL);
template_version_.address_me.services = template_version_.services;
template_version_.address_me.ip = localhost_ip();
template_version_.address_me.port = p2p_.get_port();
template_version_.address_you.services = template_version_.services;
template_version_.address_you.ip =
ip_address_type{ { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0xff, 0xff, 0x0a, 0x00, 0x00, 0x01 } };
template_version_.address_you.port = p2p_.get_port();
template_version_.user_agent = "/decentralised:" DC_CORE_LIB_VERSION "/";
template_version_.start_height = 0;
template_version_.nonce = rand();
}
async_strand::async_strand(threadpool& pool)
: ios_(pool.service()), strand_(ios_)
{
}
leveldb_blockchain::leveldb_blockchain(threadpool& pool)
: ios_(pool.service()), strand_(pool), reorg_strand_(pool), seqlock_(0)
{
reorganize_subscriber_ =
std::make_shared<reorganize_subscriber_type>(pool);
}
// This protects timer_ against concurrent access with no chance of deadlock.
// This can be dereferenced with an outstanding callback because the timer
// closure captures an instance of this class and the callback.
// This is guaranteed to call handler exactly once unless canceled or reset.
deadline::deadline(threadpool& pool, const asio::duration duration)
: duration_(duration),
timer_(pool.service()),
CONSTRUCT_TRACK(deadline)
{
}
subscriber(threadpool& pool)
: strand_(pool.service())
{
}
perform_connect_with_timeout(threadpool& pool)
: timer_(pool.service())
{
socket_ = std::make_shared<tcp::socket>(pool.service());
proxy_ = std::make_shared<channel_proxy>(pool, socket_);
}
poller::poller(threadpool& pool, blockchain& chain)
: strand_(pool.service()), chain_(chain),
last_locator_begin_(null_hash), last_hash_stop_(null_hash),
last_block_hash_(null_hash)
{
}
