dn724/dncurrency
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages 1 Wiki Activity Actions

Move from deprecated io_service to io_context (#1469)

Browse source
This commit is contained in:
cryptocode 2018-12-21 16:48:11 +01:00 • committed by Roy Keene
commit c230110fba
19 changed files with 389 additions and 389 deletions
Download patch file Download diff file Expand all files Collapse all files

4
rai/core_test/ledger.cpp
View file

@ -568,7 +568,7 @@ TEST (ledger, DISABLED_checksum_range)
TEST (system, DISABLED_generate_send_existing) TEST (system, DISABLED_generate_send_existing)
{ {
rai::system system (24000, 1); rai::system system (24000, 1);
rai::thread_runner runner (system.service, system.nodes[0]->config.io_threads); rai::thread_runner runner (system.io_ctx, system.nodes[0]->config.io_threads);
system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv);
rai::keypair stake_preserver; rai::keypair stake_preserver;
auto send_block (system.wallet (0)->send_action (rai::genesis_account, stake_preserver.pub, rai::genesis_amount / 3 * 2, true)); auto send_block (system.wallet (0)->send_action (rai::genesis_account, stake_preserver.pub, rai::genesis_amount / 3 * 2, true));
@ -614,7 +614,7 @@ TEST (system, DISABLED_generate_send_existing)
TEST (system, generate_send_new) TEST (system, generate_send_new)
{ {
rai::system system (24000, 1); rai::system system (24000, 1);
rai::thread_runner runner (system.service, system.nodes[0]->config.io_threads); rai::thread_runner runner (system.io_ctx, system.nodes[0]->config.io_threads);
system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv);
{ {
auto transaction (system.nodes[0]->store.tx_begin ()); auto transaction (system.nodes[0]->store.tx_begin ());

54
rai/core_test/network.cpp
View file

@ -7,14 +7,14 @@ using namespace std::chrono_literals;
TEST (network, tcp_connection) TEST (network, tcp_connection)
{ {
boost::asio::io_service service; boost::asio::io_context io_ctx;
boost::asio::ip::tcp::acceptor acceptor (service); boost::asio::ip::tcp::acceptor acceptor (io_ctx);
boost::asio::ip::tcp::endpoint endpoint (boost::asio::ip::address_v4::any (), 24000); boost::asio::ip::tcp::endpoint endpoint (boost::asio::ip::address_v4::any (), 24000);
acceptor.open (endpoint.protocol ()); acceptor.open (endpoint.protocol ());
acceptor.set_option (boost::asio::ip::tcp::acceptor::reuse_address (true)); acceptor.set_option (boost::asio::ip::tcp::acceptor::reuse_address (true));
acceptor.bind (endpoint); acceptor.bind (endpoint);
acceptor.listen (); acceptor.listen ();
boost::asio::ip::tcp::socket incoming (service); boost::asio::ip::tcp::socket incoming (io_ctx);
auto done1 (false); auto done1 (false);
std::string message1; std::string message1;
acceptor.async_accept (incoming, acceptor.async_accept (incoming,
@ -25,7 +25,7 @@ TEST (network, tcp_connection)
std::cerr << message1; std::cerr << message1;
} }
done1 = true; }); done1 = true; });
boost::asio::ip::tcp::socket connector (service); boost::asio::ip::tcp::socket connector (io_ctx);
auto done2 (false); auto done2 (false);
std::string message2; std::string message2;
connector.async_connect (boost::asio::ip::tcp::endpoint (boost::asio::ip::address_v4::loopback (), 24000), connector.async_connect (boost::asio::ip::tcp::endpoint (boost::asio::ip::address_v4::loopback (), 24000),
@ -39,7 +39,7 @@ TEST (network, tcp_connection)
}); });
while (!done1 || !done2) while (!done1 || !done2)
{ {
service.poll (); io_ctx.poll ();
} }
ASSERT_EQ (0, message1.size ()); ASSERT_EQ (0, message1.size ());
ASSERT_EQ (0, message2.size ()); ASSERT_EQ (0, message2.size ());
@ -68,7 +68,7 @@ TEST (network, send_node_id_handshake)
auto list1 (system.nodes[0]->peers.list ()); auto list1 (system.nodes[0]->peers.list ());
ASSERT_EQ (0, list1.size ()); ASSERT_EQ (0, list1.size ());
rai::node_init init1; rai::node_init init1;
auto node1 (std::make_shared<rai::node> (init1, system.service, 24001, rai::unique_path (), system.alarm, system.logging, system.work)); auto node1 (std::make_shared<rai::node> (init1, system.io_ctx, 24001, rai::unique_path (), system.alarm, system.logging, system.work));
node1->start (); node1->start ();
system.nodes.push_back (node1); system.nodes.push_back (node1);
auto initial (system.nodes[0]->stats.count (rai::stat::type::message, rai::stat::detail::node_id_handshake, rai::stat::dir::in)); auto initial (system.nodes[0]->stats.count (rai::stat::type::message, rai::stat::detail::node_id_handshake, rai::stat::dir::in));
@ -103,7 +103,7 @@ TEST (network, keepalive_ipv4)
auto list1 (system.nodes[0]->peers.list ()); auto list1 (system.nodes[0]->peers.list ());
ASSERT_EQ (0, list1.size ()); ASSERT_EQ (0, list1.size ());
rai::node_init init1; rai::node_init init1;
auto node1 (std::make_shared<rai::node> (init1, system.service, 24001, rai::unique_path (), system.alarm, system.logging, system.work)); auto node1 (std::make_shared<rai::node> (init1, system.io_ctx, 24001, rai::unique_path (), system.alarm, system.logging, system.work));
node1->start (); node1->start ();
system.nodes.push_back (node1); system.nodes.push_back (node1);
node1->send_keepalive (rai::endpoint (boost::asio::ip::address_v4::loopback (), 24000)); node1->send_keepalive (rai::endpoint (boost::asio::ip::address_v4::loopback (), 24000));
@ -122,7 +122,7 @@ TEST (network, multi_keepalive)
auto list1 (system.nodes[0]->peers.list ()); auto list1 (system.nodes[0]->peers.list ());
ASSERT_EQ (0, list1.size ()); ASSERT_EQ (0, list1.size ());
rai::node_init init1; rai::node_init init1;
auto node1 (std::make_shared<rai::node> (init1, system.service, 24001, rai::unique_path (), system.alarm, system.logging, system.work)); auto node1 (std::make_shared<rai::node> (init1, system.io_ctx, 24001, rai::unique_path (), system.alarm, system.logging, system.work));
ASSERT_FALSE (init1.error ()); ASSERT_FALSE (init1.error ());
node1->start (); node1->start ();
system.nodes.push_back (node1); system.nodes.push_back (node1);
@ -136,7 +136,7 @@ TEST (network, multi_keepalive)
ASSERT_NO_ERROR (system.poll ()); ASSERT_NO_ERROR (system.poll ());
} }
rai::node_init init2; rai::node_init init2;
auto node2 (std::make_shared<rai::node> (init2, system.service, 24002, rai::unique_path (), system.alarm, system.logging, system.work)); auto node2 (std::make_shared<rai::node> (init2, system.io_ctx, 24002, rai::unique_path (), system.alarm, system.logging, system.work));
ASSERT_FALSE (init2.error ()); ASSERT_FALSE (init2.error ());
node2->start (); node2->start ();
system.nodes.push_back (node2); system.nodes.push_back (node2);
@ -550,13 +550,13 @@ TEST (bootstrap_processor, DISABLED_process_none)
{ {
rai::system system (24000, 1); rai::system system (24000, 1);
rai::node_init init1; rai::node_init init1;
auto node1 (std::make_shared<rai::node> (init1, system.service, 24001, rai::unique_path (), system.alarm, system.logging, system.work)); auto node1 (std::make_shared<rai::node> (init1, system.io_ctx, 24001, rai::unique_path (), system.alarm, system.logging, system.work));
ASSERT_FALSE (init1.error ()); ASSERT_FALSE (init1.error ());
auto done (false); auto done (false);
node1->bootstrap_initiator.bootstrap (system.nodes[0]->network.endpoint ()); node1->bootstrap_initiator.bootstrap (system.nodes[0]->network.endpoint ());
while (!done) while (!done)
{ {
system.service.run_one (); system.io_ctx.run_one ();
} }
node1->stop (); node1->stop ();
} }
@ -568,7 +568,7 @@ TEST (bootstrap_processor, process_one)
system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv);
ASSERT_NE (nullptr, system.wallet (0)->send_action (rai::test_genesis_key.pub, rai::test_genesis_key.pub, 100)); ASSERT_NE (nullptr, system.wallet (0)->send_action (rai::test_genesis_key.pub, rai::test_genesis_key.pub, 100));
rai::node_init init1; rai::node_init init1;
auto node1 (std::make_shared<rai::node> (init1, system.service, 24001, rai::unique_path (), system.alarm, system.logging, system.work)); auto node1 (std::make_shared<rai::node> (init1, system.io_ctx, 24001, rai::unique_path (), system.alarm, system.logging, system.work));
rai::block_hash hash1 (system.nodes[0]->latest (rai::test_genesis_key.pub)); rai::block_hash hash1 (system.nodes[0]->latest (rai::test_genesis_key.pub));
rai::block_hash hash2 (node1->latest (rai::test_genesis_key.pub)); rai::block_hash hash2 (node1->latest (rai::test_genesis_key.pub));
ASSERT_NE (hash1, hash2); ASSERT_NE (hash1, hash2);
@ -596,7 +596,7 @@ TEST (bootstrap_processor, process_two)
ASSERT_NE (hash1, hash3); ASSERT_NE (hash1, hash3);
ASSERT_NE (hash2, hash3); ASSERT_NE (hash2, hash3);
rai::node_init init1; rai::node_init init1;
auto node1 (std::make_shared<rai::node> (init1, system.service, 24001, rai::unique_path (), system.alarm, system.logging, system.work)); auto node1 (std::make_shared<rai::node> (init1, system.io_ctx, 24001, rai::unique_path (), system.alarm, system.logging, system.work));
ASSERT_FALSE (init1.error ()); ASSERT_FALSE (init1.error ());
node1->bootstrap_initiator.bootstrap (system.nodes[0]->network.endpoint ()); node1->bootstrap_initiator.bootstrap (system.nodes[0]->network.endpoint ());
ASSERT_NE (node1->latest (rai::test_genesis_key.pub), system.nodes[0]->latest (rai::test_genesis_key.pub)); ASSERT_NE (node1->latest (rai::test_genesis_key.pub), system.nodes[0]->latest (rai::test_genesis_key.pub));
@ -622,7 +622,7 @@ TEST (bootstrap_processor, process_state)
node0->process (*block1); node0->process (*block1);
node0->process (*block2); node0->process (*block2);
rai::node_init init1; rai::node_init init1;
auto node1 (std::make_shared<rai::node> (init1, system.service, 24001, rai::unique_path (), system.alarm, system.logging, system.work)); auto node1 (std::make_shared<rai::node> (init1, system.io_ctx, 24001, rai::unique_path (), system.alarm, system.logging, system.work));
ASSERT_EQ (node0->latest (rai::test_genesis_key.pub), block2->hash ()); ASSERT_EQ (node0->latest (rai::test_genesis_key.pub), block2->hash ());
ASSERT_NE (node1->latest (rai::test_genesis_key.pub), block2->hash ()); ASSERT_NE (node1->latest (rai::test_genesis_key.pub), block2->hash ());
node1->bootstrap_initiator.bootstrap (node0->network.endpoint ()); node1->bootstrap_initiator.bootstrap (node0->network.endpoint ());
@ -651,7 +651,7 @@ TEST (bootstrap_processor, process_new)
rai::uint128_t balance1 (system.nodes[0]->balance (rai::test_genesis_key.pub)); rai::uint128_t balance1 (system.nodes[0]->balance (rai::test_genesis_key.pub));
rai::uint128_t balance2 (system.nodes[0]->balance (key2.pub)); rai::uint128_t balance2 (system.nodes[0]->balance (key2.pub));
rai::node_init init1; rai::node_init init1;
auto node1 (std::make_shared<rai::node> (init1, system.service, 24002, rai::unique_path (), system.alarm, system.logging, system.work)); auto node1 (std::make_shared<rai::node> (init1, system.io_ctx, 24002, rai::unique_path (), system.alarm, system.logging, system.work));
ASSERT_FALSE (init1.error ()); ASSERT_FALSE (init1.error ());
node1->bootstrap_initiator.bootstrap (system.nodes[0]->network.endpoint ()); node1->bootstrap_initiator.bootstrap (system.nodes[0]->network.endpoint ());
system.deadline_set (10s); system.deadline_set (10s);
@ -676,7 +676,7 @@ TEST (bootstrap_processor, pull_diamond)
auto receive (std::make_shared<rai::receive_block> (send1->hash (), send2->hash (), rai::test_genesis_key.prv, rai::test_genesis_key.pub, system.work.generate (send1->hash ()))); auto receive (std::make_shared<rai::receive_block> (send1->hash (), send2->hash (), rai::test_genesis_key.prv, rai::test_genesis_key.pub, system.work.generate (send1->hash ())));
ASSERT_EQ (rai::process_result::progress, system.nodes[0]->process (*receive).code); ASSERT_EQ (rai::process_result::progress, system.nodes[0]->process (*receive).code);
rai::node_init init1; rai::node_init init1;
auto node1 (std::make_shared<rai::node> (init1, system.service, 24002, rai::unique_path (), system.alarm, system.logging, system.work)); auto node1 (std::make_shared<rai::node> (init1, system.io_ctx, 24002, rai::unique_path (), system.alarm, system.logging, system.work));
ASSERT_FALSE (init1.error ()); ASSERT_FALSE (init1.error ());
node1->bootstrap_initiator.bootstrap (system.nodes[0]->network.endpoint ()); node1->bootstrap_initiator.bootstrap (system.nodes[0]->network.endpoint ());
system.deadline_set (10s); system.deadline_set (10s);
@ -693,7 +693,7 @@ TEST (bootstrap_processor, push_diamond)
rai::system system (24000, 1); rai::system system (24000, 1);
rai::keypair key; rai::keypair key;
rai::node_init init1; rai::node_init init1;
auto node1 (std::make_shared<rai::node> (init1, system.service, 24002, rai::unique_path (), system.alarm, system.logging, system.work)); auto node1 (std::make_shared<rai::node> (init1, system.io_ctx, 24002, rai::unique_path (), system.alarm, system.logging, system.work));
ASSERT_FALSE (init1.error ()); ASSERT_FALSE (init1.error ());
auto wallet1 (node1->wallets.create (100)); auto wallet1 (node1->wallets.create (100));
wallet1->insert_adhoc (rai::test_genesis_key.prv); wallet1->insert_adhoc (rai::test_genesis_key.prv);
@ -721,7 +721,7 @@ TEST (bootstrap_processor, push_one)
rai::system system (24000, 1); rai::system system (24000, 1);
rai::node_init init1; rai::node_init init1;
rai::keypair key1; rai::keypair key1;
auto node1 (std::make_shared<rai::node> (init1, system.service, 24001, rai::unique_path (), system.alarm, system.logging, system.work)); auto node1 (std::make_shared<rai::node> (init1, system.io_ctx, 24001, rai::unique_path (), system.alarm, system.logging, system.work));
auto wallet (node1->wallets.create (rai::uint256_union ())); auto wallet (node1->wallets.create (rai::uint256_union ()));
ASSERT_NE (nullptr, wallet); ASSERT_NE (nullptr, wallet);
wallet->insert_adhoc (rai::test_genesis_key.prv); wallet->insert_adhoc (rai::test_genesis_key.prv);
@ -756,7 +756,7 @@ TEST (bootstrap_processor, lazy_hash)
system.nodes[0]->block_processor.add (receive2, std::chrono::steady_clock::time_point ()); system.nodes[0]->block_processor.add (receive2, std::chrono::steady_clock::time_point ());
system.nodes[0]->block_processor.flush (); system.nodes[0]->block_processor.flush ();
// Start lazy bootstrap with last block in chain known // Start lazy bootstrap with last block in chain known
auto node1 (std::make_shared<rai::node> (init1, system.service, 24001, rai::unique_path (), system.alarm, system.logging, system.work)); auto node1 (std::make_shared<rai::node> (init1, system.io_ctx, 24001, rai::unique_path (), system.alarm, system.logging, system.work));
node1->peers.insert (system.nodes[0]->network.endpoint (), rai::protocol_version); node1->peers.insert (system.nodes[0]->network.endpoint (), rai::protocol_version);
node1->bootstrap_initiator.bootstrap_lazy (receive2->hash ()); node1->bootstrap_initiator.bootstrap_lazy (receive2->hash ());
// Check processed blocks // Check processed blocks
@ -793,7 +793,7 @@ TEST (bootstrap_processor, lazy_max_pull_count)
system.nodes[0]->block_processor.add (change3, std::chrono::steady_clock::time_point ()); system.nodes[0]->block_processor.add (change3, std::chrono::steady_clock::time_point ());
system.nodes[0]->block_processor.flush (); system.nodes[0]->block_processor.flush ();
// Start lazy bootstrap with last block in chain known // Start lazy bootstrap with last block in chain known
auto node1 (std::make_shared<rai::node> (init1, system.service, 24001, rai::unique_path (), system.alarm, system.logging, system.work)); auto node1 (std::make_shared<rai::node> (init1, system.io_ctx, 24001, rai::unique_path (), system.alarm, system.logging, system.work));
node1->peers.insert (system.nodes[0]->network.endpoint (), rai::protocol_version); node1->peers.insert (system.nodes[0]->network.endpoint (), rai::protocol_version);
node1->bootstrap_initiator.bootstrap_lazy (change3->hash ()); node1->bootstrap_initiator.bootstrap_lazy (change3->hash ());
// Check processed blocks // Check processed blocks
@ -808,7 +808,7 @@ TEST (bootstrap_processor, lazy_max_pull_count)
TEST (frontier_req_response, DISABLED_destruction) TEST (frontier_req_response, DISABLED_destruction)
{ {
{ {
std::shared_ptr<rai::frontier_req_server> hold; // Destructing tcp acceptor on non-existent io_service std::shared_ptr<rai::frontier_req_server> hold; // Destructing tcp acceptor on non-existent io_context
{ {
rai::system system (24000, 1); rai::system system (24000, 1);
auto connection (std::make_shared<rai::bootstrap_server> (nullptr, system.nodes[0])); auto connection (std::make_shared<rai::bootstrap_server> (nullptr, system.nodes[0]));
@ -928,7 +928,7 @@ TEST (bulk, genesis)
rai::system system (24000, 1); rai::system system (24000, 1);
system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv);
rai::node_init init1; rai::node_init init1;
auto node1 (std::make_shared<rai::node> (init1, system.service, 24001, rai::unique_path (), system.alarm, system.logging, system.work)); auto node1 (std::make_shared<rai::node> (init1, system.io_ctx, 24001, rai::unique_path (), system.alarm, system.logging, system.work));
ASSERT_FALSE (init1.error ()); ASSERT_FALSE (init1.error ());
rai::block_hash latest1 (system.nodes[0]->latest (rai::test_genesis_key.pub)); rai::block_hash latest1 (system.nodes[0]->latest (rai::test_genesis_key.pub));
rai::block_hash latest2 (node1->latest (rai::test_genesis_key.pub)); rai::block_hash latest2 (node1->latest (rai::test_genesis_key.pub));
@ -952,7 +952,7 @@ TEST (bulk, offline_send)
rai::system system (24000, 1); rai::system system (24000, 1);
system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv);
rai::node_init init1; rai::node_init init1;
auto node1 (std::make_shared<rai::node> (init1, system.service, 24001, rai::unique_path (), system.alarm, system.logging, system.work)); auto node1 (std::make_shared<rai::node> (init1, system.io_ctx, 24001, rai::unique_path (), system.alarm, system.logging, system.work));
ASSERT_FALSE (init1.error ()); ASSERT_FALSE (init1.error ());
node1->start (); node1->start ();
system.nodes.push_back (node1); system.nodes.push_back (node1);
@ -1022,19 +1022,19 @@ TEST (network, ipv6_from_ipv4)
TEST (network, ipv6_bind_send_ipv4) TEST (network, ipv6_bind_send_ipv4)
{ {
boost::asio::io_service service; boost::asio::io_context io_ctx;
rai::endpoint endpoint1 (boost::asio::ip::address_v6::any (), 24000); rai::endpoint endpoint1 (boost::asio::ip::address_v6::any (), 24000);
rai::endpoint endpoint2 (boost::asio::ip::address_v4::any (), 24001); rai::endpoint endpoint2 (boost::asio::ip::address_v4::any (), 24001);
std::array<uint8_t, 16> bytes1; std::array<uint8_t, 16> bytes1;
auto finish1 (false); auto finish1 (false);
rai::endpoint endpoint3; rai::endpoint endpoint3;
boost::asio::ip::udp::socket socket1 (service, endpoint1); boost::asio::ip::udp::socket socket1 (io_ctx, endpoint1);
socket1.async_receive_from (boost::asio::buffer (bytes1.data (), bytes1.size ()), endpoint3, [&finish1](boost::system::error_code const & error, size_t size_a) { socket1.async_receive_from (boost::asio::buffer (bytes1.data (), bytes1.size ()), endpoint3, [&finish1](boost::system::error_code const & error, size_t size_a) {
ASSERT_FALSE (error); ASSERT_FALSE (error);
ASSERT_EQ (16, size_a); ASSERT_EQ (16, size_a);
finish1 = true; finish1 = true;
}); });
boost::asio::ip::udp::socket socket2 (service, endpoint2); boost::asio::ip::udp::socket socket2 (io_ctx, endpoint2);
rai::endpoint endpoint5 (boost::asio::ip::address_v4::loopback (), 24000); rai::endpoint endpoint5 (boost::asio::ip::address_v4::loopback (), 24000);
rai::endpoint endpoint6 (boost::asio::ip::address_v6::v4_mapped (boost::asio::ip::address_v4::loopback ()), 24001); rai::endpoint endpoint6 (boost::asio::ip::address_v6::v4_mapped (boost::asio::ip::address_v4::loopback ()), 24001);
socket2.async_send_to (boost::asio::buffer (std::array<uint8_t, 16>{}, 16), endpoint5, [](boost::system::error_code const & error, size_t size_a) { socket2.async_send_to (boost::asio::buffer (std::array<uint8_t, 16>{}, 16), endpoint5, [](boost::system::error_code const & error, size_t size_a) {
@ -1044,7 +1044,7 @@ TEST (network, ipv6_bind_send_ipv4)
auto iterations (0); auto iterations (0);
while (!finish1) while (!finish1)
{ {
service.poll (); io_ctx.poll ();
++iterations; ++iterations;
ASSERT_LT (iterations, 200); ASSERT_LT (iterations, 200);
} }

12
rai/core_test/node.cpp
View file

@ -13,14 +13,14 @@ TEST (node, stop)
rai::system system (24000, 1); rai::system system (24000, 1);
ASSERT_NE (system.nodes[0]->wallets.items.end (), system.nodes[0]->wallets.items.begin ()); ASSERT_NE (system.nodes[0]->wallets.items.end (), system.nodes[0]->wallets.items.begin ());
system.nodes[0]->stop (); system.nodes[0]->stop ();
system.service.run (); system.io_ctx.run ();
ASSERT_TRUE (true); ASSERT_TRUE (true);
} }
TEST (node, block_store_path_failure) TEST (node, block_store_path_failure)
{ {
rai::node_init init; rai::node_init init;
auto service (boost::make_shared<boost::asio::io_service> ()); auto service (boost::make_shared<boost::asio::io_context> ());
rai::alarm alarm (*service); rai::alarm alarm (*service);
auto path (rai::unique_path ()); auto path (rai::unique_path ());
rai::logging logging; rai::logging logging;
@ -34,7 +34,7 @@ TEST (node, block_store_path_failure)
TEST (node, password_fanout) TEST (node, password_fanout)
{ {
rai::node_init init; rai::node_init init;
auto service (boost::make_shared<boost::asio::io_service> ()); auto service (boost::make_shared<boost::asio::io_context> ());
rai::alarm alarm (*service); rai::alarm alarm (*service);
auto path (rai::unique_path ()); auto path (rai::unique_path ());
rai::node_config config; rai::node_config config;
@ -222,7 +222,7 @@ TEST (node, auto_bootstrap)
ASSERT_NO_ERROR (system.poll ()); ASSERT_NO_ERROR (system.poll ());
} }
rai::node_init init1; rai::node_init init1;
auto node1 (std::make_shared<rai::node> (init1, system.service, 24001, rai::unique_path (), system.alarm, system.logging, system.work)); auto node1 (std::make_shared<rai::node> (init1, system.io_ctx, 24001, rai::unique_path (), system.alarm, system.logging, system.work));
ASSERT_FALSE (init1.error ()); ASSERT_FALSE (init1.error ());
node1->network.send_keepalive (system.nodes[0]->network.endpoint ()); node1->network.send_keepalive (system.nodes[0]->network.endpoint ());
node1->start (); node1->start ();
@ -251,7 +251,7 @@ TEST (node, auto_bootstrap_reverse)
system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv);
system.wallet (0)->insert_adhoc (key2.prv); system.wallet (0)->insert_adhoc (key2.prv);
rai::node_init init1; rai::node_init init1;
auto node1 (std::make_shared<rai::node> (init1, system.service, 24001, rai::unique_path (), system.alarm, system.logging, system.work)); auto node1 (std::make_shared<rai::node> (init1, system.io_ctx, 24001, rai::unique_path (), system.alarm, system.logging, system.work));
ASSERT_FALSE (init1.error ()); ASSERT_FALSE (init1.error ());
ASSERT_NE (nullptr, system.wallet (0)->send_action (rai::test_genesis_key.pub, key2.pub, system.nodes[0]->config.receive_minimum.number ())); ASSERT_NE (nullptr, system.wallet (0)->send_action (rai::test_genesis_key.pub, key2.pub, system.nodes[0]->config.receive_minimum.number ()));
system.nodes[0]->network.send_keepalive (node1->network.endpoint ()); system.nodes[0]->network.send_keepalive (node1->network.endpoint ());
@ -380,7 +380,7 @@ TEST (node, connect_after_junk)
{ {
rai::system system (24000, 1); rai::system system (24000, 1);
rai::node_init init1; rai::node_init init1;
auto node1 (std::make_shared<rai::node> (init1, system.service, 24001, rai::unique_path (), system.alarm, system.logging, system.work)); auto node1 (std::make_shared<rai::node> (init1, system.io_ctx, 24001, rai::unique_path (), system.alarm, system.logging, system.work));
uint64_t junk (0); uint64_t junk (0);
node1->network.socket.async_send_to (boost::asio::buffer (&junk, sizeof (junk)), system.nodes[0]->network.endpoint (), [](boost::system::error_code const &, size_t) {}); node1->network.socket.async_send_to (boost::asio::buffer (&junk, sizeof (junk)), system.nodes[0]->network.endpoint (), [](boost::system::error_code const &, size_t) {});
system.deadline_set (10s); system.deadline_set (10s);

32
rai/core_test/processor_service.cpp
View file

@ -48,8 +48,8 @@ TEST (processor_service, bad_receive_signature)
TEST (alarm, one) TEST (alarm, one)
{ {
boost::asio::io_service service; boost::asio::io_context io_ctx;
rai::alarm alarm (service); rai::alarm alarm (io_ctx);
std::atomic<bool> done (false); std::atomic<bool> done (false);
std::mutex mutex; std::mutex mutex;
std::condition_variable condition; std::condition_variable condition;
@ -60,18 +60,18 @@ TEST (alarm, one)
} }
condition.notify_one (); condition.notify_one ();
}); });
boost::asio::io_service::work work (service); boost::asio::io_context::work work (io_ctx);
boost::thread thread ([&service]() { service.run (); }); boost::thread thread ([&io_ctx]() { io_ctx.run (); });
std::unique_lock<std::mutex> unique (mutex); std::unique_lock<std::mutex> unique (mutex);
condition.wait (unique, [&]() { return !!done; }); condition.wait (unique, [&]() { return !!done; });
service.stop (); io_ctx.stop ();
thread.join (); thread.join ();
} }
TEST (alarm, many) TEST (alarm, many)
{ {
boost::asio::io_service service; boost::asio::io_context io_ctx;
rai::alarm alarm (service); rai::alarm alarm (io_ctx);
std::atomic<int> count (0); std::atomic<int> count (0);
std::mutex mutex; std::mutex mutex;
std::condition_variable condition; std::condition_variable condition;
@ -85,15 +85,15 @@ TEST (alarm, many)
condition.notify_one (); condition.notify_one ();
}); });
} }
boost::asio::io_service::work work (service); boost::asio::io_context::work work (io_ctx);
std::vector<boost::thread> threads; std::vector<boost::thread> threads;
for (auto i (0); i < 50; ++i) for (auto i (0); i < 50; ++i)
{ {
threads.push_back (boost::thread ([&service]() { service.run (); })); threads.push_back (boost::thread ([&io_ctx]() { io_ctx.run (); }));
} }
std::unique_lock<std::mutex> unique (mutex); std::unique_lock<std::mutex> unique (mutex);
condition.wait (unique, [&]() { return count == 50; }); condition.wait (unique, [&]() { return count == 50; });
service.stop (); io_ctx.stop ();
for (auto i (threads.begin ()), j (threads.end ()); i != j; ++i) for (auto i (threads.begin ()), j (threads.end ()); i != j; ++i)
{ {
i->join (); i->join ();
@ -102,8 +102,8 @@ TEST (alarm, many)
TEST (alarm, top_execution) TEST (alarm, top_execution)
{ {
boost::asio::io_service service; boost::asio::io_context io_ctx;
rai::alarm alarm (service); rai::alarm alarm (io_ctx);
int value1 (0); int value1 (0);
int value2 (0); int value2 (0);
std::mutex mutex; std::mutex mutex;
@ -118,14 +118,14 @@ TEST (alarm, top_execution)
value2 = 2; value2 = 2;
promise.set_value (false); promise.set_value (false);
}); });
boost::asio::io_service::work work (service); boost::asio::io_context::work work (io_ctx);
boost::thread thread ([&service]() { boost::thread thread ([&io_ctx]() {
service.run (); io_ctx.run ();
}); });
promise.get_future ().get (); promise.get_future ().get ();
std::lock_guard<std::mutex> lock (mutex); std::lock_guard<std::mutex> lock (mutex);
ASSERT_EQ (1, value1); ASSERT_EQ (1, value1);
ASSERT_EQ (2, value2); ASSERT_EQ (2, value2);
service.stop (); io_ctx.stop ();
thread.join (); thread.join ();
} }

538
rai/core_test/rpc.cpp
View file

File diff suppressed because it is too large Load diff

4
rai/core_test/wallet.cpp
View file

@ -880,7 +880,7 @@ TEST (wallet, send_race)
TEST (wallet, password_race) TEST (wallet, password_race)
{ {
rai::system system (24000, 1); rai::system system (24000, 1);
rai::thread_runner runner (system.service, system.nodes[0]->config.io_threads); rai::thread_runner runner (system.io_ctx, system.nodes[0]->config.io_threads);
auto wallet = system.wallet (0); auto wallet = system.wallet (0);
system.nodes[0]->background ([&wallet]() { system.nodes[0]->background ([&wallet]() {
for (int i = 0; i < 100; i++) for (int i = 0; i < 100; i++)
@ -907,7 +907,7 @@ TEST (wallet, password_race)
TEST (wallet, password_race_corrupt_seed) TEST (wallet, password_race_corrupt_seed)
{ {
rai::system system (24000, 1); rai::system system (24000, 1);
rai::thread_runner runner (system.service, system.nodes[0]->config.io_threads); rai::thread_runner runner (system.io_ctx, system.nodes[0]->config.io_threads);
auto wallet = system.wallet (0); auto wallet = system.wallet (0);
rai::raw_key seed; rai::raw_key seed;
{ {

12
rai/node/bootstrap.cpp
View file

@ -15,7 +15,7 @@ constexpr unsigned bootstrap_max_new_connections = 10;
constexpr unsigned bulk_push_cost_limit = 200; constexpr unsigned bulk_push_cost_limit = 200;
rai::socket::socket (std::shared_ptr<rai::node> node_a) : rai::socket::socket (std::shared_ptr<rai::node> node_a) :
socket_m (node_a->service), socket_m (node_a->io_ctx),
cutoff (std::numeric_limits<uint64_t>::max ()), cutoff (std::numeric_limits<uint64_t>::max ()),
node (node_a) node (node_a)
{ {
@ -809,7 +809,7 @@ bool rai::bootstrap_attempt::request_frontier (std::unique_lock<std::mutex> & lo
future = client->promise.get_future (); future = client->promise.get_future ();
} }
lock_a.unlock (); lock_a.unlock ();
result = consume_future (future); // This is out of scope of `client' so when the last reference via boost::asio::io_service is lost and the client is destroyed, the future throws an exception. result = consume_future (future); // This is out of scope of `client' so when the last reference via boost::asio::io_context is lost and the client is destroyed, the future throws an exception.
lock_a.lock (); lock_a.lock ();
if (result) if (result)
{ {
@ -870,7 +870,7 @@ void rai::bootstrap_attempt::request_push (std::unique_lock<std::mutex> & lock_a
future = client->promise.get_future (); future = client->promise.get_future ();
} }
lock_a.unlock (); lock_a.unlock ();
error = consume_future (future); // This is out of scope of `client' so when the last reference via boost::asio::io_service is lost and the client is destroyed, the future throws an exception. error = consume_future (future); // This is out of scope of `client' so when the last reference via boost::asio::io_context is lost and the client is destroyed, the future throws an exception.
lock_a.lock (); lock_a.lock ();
} }
if (node->config.logging.network_logging ()) if (node->config.logging.network_logging ())
@ -1618,10 +1618,10 @@ void rai::bootstrap_initiator::notify_listeners (bool in_progress_a)
} }
} }
rai::bootstrap_listener::bootstrap_listener (boost::asio::io_service & service_a, uint16_t port_a, rai::node & node_a) : rai::bootstrap_listener::bootstrap_listener (boost::asio::io_context & io_ctx_a, uint16_t port_a, rai::node & node_a) :
acceptor (service_a), acceptor (io_ctx_a),
local (boost::asio::ip::tcp::endpoint (boost::asio::ip::address_v6::any (), port_a)), local (boost::asio::ip::tcp::endpoint (boost::asio::ip::address_v6::any (), port_a)),
service (service_a), io_ctx (io_ctx_a),
node (node_a) node (node_a)
{ {
} }

4
rai/node/bootstrap.hpp
View file

@ -219,7 +219,7 @@ class bootstrap_server;
class bootstrap_listener class bootstrap_listener
{ {
public: public:
bootstrap_listener (boost::asio::io_service &, uint16_t, rai::node &); bootstrap_listener (boost::asio::io_context &, uint16_t, rai::node &);
void start (); void start ();
void stop (); void stop ();
void accept_connection (); void accept_connection ();
@ -229,7 +229,7 @@ public:
rai::tcp_endpoint endpoint (); rai::tcp_endpoint endpoint ();
boost::asio::ip::tcp::acceptor acceptor; boost::asio::ip::tcp::acceptor acceptor;
rai::tcp_endpoint local; rai::tcp_endpoint local;
boost::asio::io_service & service; boost::asio::io_context & io_ctx;
rai::node & node; rai::node & node;
bool on; bool on;
}; };

46
rai/node/node.cpp
View file

@ -35,8 +35,8 @@ extern size_t rai_bootstrap_weights_size;
rai::network::network (rai::node & node_a, uint16_t port) : rai::network::network (rai::node & node_a, uint16_t port) :
buffer_container (node_a.stats, rai::network::buffer_size, 4096), // 2Mb receive buffer buffer_container (node_a.stats, rai::network::buffer_size, 4096), // 2Mb receive buffer
socket (node_a.service, rai::endpoint (boost::asio::ip::address_v6::any (), port)), socket (node_a.io_ctx, rai::endpoint (boost::asio::ip::address_v6::any (), port)),
resolver (node_a.service), resolver (node_a.io_ctx),
node (node_a), node (node_a),
on (true) on (true)
{ {
@ -704,8 +704,8 @@ bool rai::operation::operator> (rai::operation const & other_a) const
return wakeup > other_a.wakeup; return wakeup > other_a.wakeup;
} }
rai::alarm::alarm (boost::asio::io_service & service_a) : rai::alarm::alarm (boost::asio::io_context & io_ctx_a) :
service (service_a), io_ctx (io_ctx_a),
thread ([this]() { thread ([this]() {
rai::thread_role::set (rai::thread_role::name::alarm); rai::thread_role::set (rai::thread_role::name::alarm);
run (); run ();
@ -732,7 +732,7 @@ void rai::alarm::run ()
{ {
if (operation.wakeup <= std::chrono::steady_clock::now ()) if (operation.wakeup <= std::chrono::steady_clock::now ())
{ {
service.post (operation.function); io_ctx.post (operation.function);
operations.pop (); operations.pop ();
} }
else else
@ -1592,13 +1592,13 @@ void rai::block_processor::queue_unchecked (rai::transaction const & transaction
node.gap_cache.blocks.get<1> ().erase (hash_a); node.gap_cache.blocks.get<1> ().erase (hash_a);
} }
rai::node::node (rai::node_init & init_a, boost::asio::io_service & service_a, uint16_t peering_port_a, boost::filesystem::path const & application_path_a, rai::alarm & alarm_a, rai::logging const & logging_a, rai::work_pool & work_a) : rai::node::node (rai::node_init & init_a, boost::asio::io_context & io_ctx_a, uint16_t peering_port_a, boost::filesystem::path const & application_path_a, rai::alarm & alarm_a, rai::logging const & logging_a, rai::work_pool & work_a) :
node (init_a, service_a, application_path_a, alarm_a, rai::node_config (peering_port_a, logging_a), work_a) node (init_a, io_ctx_a, application_path_a, alarm_a, rai::node_config (peering_port_a, logging_a), work_a)
{ {
} }
rai::node::node (rai::node_init & init_a, boost::asio::io_service & service_a, boost::filesystem::path const & application_path_a, rai::alarm & alarm_a, rai::node_config const & config_a, rai::work_pool & work_a) : rai::node::node (rai::node_init & init_a, boost::asio::io_context & io_ctx_a, boost::filesystem::path const & application_path_a, rai::alarm & alarm_a, rai::node_config const & config_a, rai::work_pool & work_a) :
service (service_a), io_ctx (io_ctx_a),
config (config_a), config (config_a),
alarm (alarm_a), alarm (alarm_a),
work (work_a), work (work_a),
@ -1609,7 +1609,7 @@ ledger (store, stats, config.epoch_block_link, config.epoch_block_signer),
active (*this), active (*this),
network (*this, config.peering_port), network (*this, config.peering_port),
bootstrap_initiator (*this), bootstrap_initiator (*this),
bootstrap (service_a, config.peering_port, *this), bootstrap (io_ctx_a, config.peering_port, *this),
peers (network.endpoint ()), peers (network.endpoint ()),
application_path (application_path_a), application_path (application_path_a),
wallets (init_a.block_store_init, *this), wallets (init_a.block_store_init, *this),
@ -1659,13 +1659,13 @@ vote_uniquer (block_uniquer)
auto address (node_l->config.callback_address); auto address (node_l->config.callback_address);
auto port (node_l->config.callback_port); auto port (node_l->config.callback_port);
auto target (std::make_shared<std::string> (node_l->config.callback_target)); auto target (std::make_shared<std::string> (node_l->config.callback_target));
auto resolver (std::make_shared<boost::asio::ip::tcp::resolver> (node_l->service)); auto resolver (std::make_shared<boost::asio::ip::tcp::resolver> (node_l->io_ctx));
resolver->async_resolve (boost::asio::ip::tcp::resolver::query (address, std::to_string (port)), [node_l, address, port, target, body, resolver](boost::system::error_code const & ec, boost::asio::ip::tcp::resolver::iterator i_a) { resolver->async_resolve (boost::asio::ip::tcp::resolver::query (address, std::to_string (port)), [node_l, address, port, target, body, resolver](boost::system::error_code const & ec, boost::asio::ip::tcp::resolver::iterator i_a) {
if (!ec) if (!ec)
{ {
for (auto i (i_a), n (boost::asio::ip::tcp::resolver::iterator{}); i != n; ++i) for (auto i (i_a), n (boost::asio::ip::tcp::resolver::iterator{}); i != n; ++i)
{ {
auto sock (std::make_shared<boost::asio::ip::tcp::socket> (node_l->service)); auto sock (std::make_shared<boost::asio::ip::tcp::socket> (node_l->io_ctx));
sock->async_connect (i->endpoint (), [node_l, target, body, sock, address, port](boost::system::error_code const & ec) { sock->async_connect (i->endpoint (), [node_l, target, body, sock, address, port](boost::system::error_code const & ec) {
if (!ec) if (!ec)
{ {
@ -2262,10 +2262,10 @@ namespace
class work_request class work_request
{ {
public: public:
work_request (boost::asio::io_service & service_a, boost::asio::ip::address address_a, uint16_t port_a) : work_request (boost::asio::io_context & io_ctx_a, boost::asio::ip::address address_a, uint16_t port_a) :
address (address_a), address (address_a),
port (port_a), port (port_a),
socket (service_a) socket (io_ctx_a)
{ {
} }
boost::asio::ip::address address; boost::asio::ip::address address;
@ -2342,7 +2342,7 @@ public:
auto host (i.first); auto host (i.first);
auto service (i.second); auto service (i.second);
node->background ([this_l, host, service]() { node->background ([this_l, host, service]() {
auto connection (std::make_shared<work_request> (this_l->node->service, host, service)); auto connection (std::make_shared<work_request> (this_l->node->io_ctx, host, service));
connection->socket.async_connect (rai::tcp_endpoint (host, service), [this_l, connection](boost::system::error_code const & ec) { connection->socket.async_connect (rai::tcp_endpoint (host, service), [this_l, connection](boost::system::error_code const & ec) {
if (!ec) if (!ec)
{ {
@ -2428,7 +2428,7 @@ public:
request.version (11); request.version (11);
request.body () = request_string; request.body () = request_string;
request.prepare_payload (); request.prepare_payload ();
auto socket (std::make_shared<boost::asio::ip::tcp::socket> (this_l->node->service)); auto socket (std::make_shared<boost::asio::ip::tcp::socket> (this_l->node->io_ctx));
boost::beast::http::async_write (*socket, request, [socket](boost::system::error_code const & ec, size_t bytes_transferred) { boost::beast::http::async_write (*socket, request, [socket](boost::system::error_code const & ec, size_t bytes_transferred) {
}); });
}); });
@ -3579,24 +3579,24 @@ int rai::node::store_version ()
return store.version_get (transaction); return store.version_get (transaction);
} }
rai::thread_runner::thread_runner (boost::asio::io_service & service_a, unsigned service_threads_a) rai::thread_runner::thread_runner (boost::asio::io_context & io_ctx_a, unsigned service_threads_a)
{ {
boost::thread::attributes attrs; boost::thread::attributes attrs;
rai::thread_attributes::set (attrs); rai::thread_attributes::set (attrs);
for (auto i (0); i < service_threads_a; ++i) for (auto i (0); i < service_threads_a; ++i)
{ {
threads.push_back (boost::thread (attrs, [&service_a]() { threads.push_back (boost::thread (attrs, [&io_ctx_a]() {
rai::thread_role::set (rai::thread_role::name::io); rai::thread_role::set (rai::thread_role::name::io);
try try
{ {
service_a.run (); io_ctx_a.run ();
} }
catch (...) catch (...)
{ {
#ifndef NDEBUG #ifndef NDEBUG
/* /*
* In a release build, catch and swallow the * In a release build, catch and swallow the
* service exception, in debug mode pass it * io_context exception, in debug mode pass it
* on * on
*/ */
throw; throw;
@ -3624,8 +3624,8 @@ void rai::thread_runner::join ()
rai::inactive_node::inactive_node (boost::filesystem::path const & path) : rai::inactive_node::inactive_node (boost::filesystem::path const & path) :
path (path), path (path),
service (std::make_shared<boost::asio::io_service> ()), io_context (std::make_shared<boost::asio::io_context> ()),
alarm (*service), alarm (*io_context),
work (1, nullptr) work (1, nullptr)
{ {
boost::system::error_code error_chmod; boost::system::error_code error_chmod;
@ -3637,7 +3637,7 @@ work (1, nullptr)
rai::set_secure_perm_directory (path, error_chmod); rai::set_secure_perm_directory (path, error_chmod);
logging.max_size = std::numeric_limits<std::uintmax_t>::max (); logging.max_size = std::numeric_limits<std::uintmax_t>::max ();
logging.init (path); logging.init (path);
node = std::make_shared<rai::node> (init, *service, 24000, path, alarm, logging, work); node = std::make_shared<rai::node> (init, *io_context, 24000, path, alarm, logging, work);
} }
rai::inactive_node::~inactive_node () rai::inactive_node::~inactive_node ()

16
rai/node/node.hpp
View file

@ -147,11 +147,11 @@ public:
class alarm class alarm
{ {
public: public:
alarm (boost::asio::io_service &); alarm (boost::asio::io_context &);
~alarm (); ~alarm ();
void add (std::chrono::steady_clock::time_point const &, std::function<void()> const &); void add (std::chrono::steady_clock::time_point const &, std::function<void()> const &);
void run (); void run ();
boost::asio::io_service & service; boost::asio::io_context & io_ctx;
std::mutex mutex; std::mutex mutex;
std::condition_variable condition; std::condition_variable condition;
std::priority_queue<operation, std::vector<operation>, std::greater<operation>> operations; std::priority_queue<operation, std::vector<operation>, std::greater<operation>> operations;
@ -446,13 +446,13 @@ private:
class node : public std::enable_shared_from_this<rai::node> class node : public std::enable_shared_from_this<rai::node>
{ {
public: public:
node (rai::node_init &, boost::asio::io_service &, uint16_t, boost::filesystem::path const &, rai::alarm &, rai::logging const &, rai::work_pool &); node (rai::node_init &, boost::asio::io_context &, uint16_t, boost::filesystem::path const &, rai::alarm &, rai::logging const &, rai::work_pool &);
node (rai::node_init &, boost::asio::io_service &, boost::filesystem::path const &, rai::alarm &, rai::node_config const &, rai::work_pool &); node (rai::node_init &, boost::asio::io_context &, boost::filesystem::path const &, rai::alarm &, rai::node_config const &, rai::work_pool &);
~node (); ~node ();
template <typename T> template <typename T>
void background (T action_a) void background (T action_a)
{ {
alarm.service.post (action_a); alarm.io_ctx.post (action_a);
} }
void send_keepalive (rai::endpoint const &); void send_keepalive (rai::endpoint const &);
bool copy_with_compaction (boost::filesystem::path const &); bool copy_with_compaction (boost::filesystem::path const &);
@ -489,7 +489,7 @@ public:
void process_fork (rai::transaction const &, std::shared_ptr<rai::block>); void process_fork (rai::transaction const &, std::shared_ptr<rai::block>);
bool validate_block_by_previous (rai::transaction const &, std::shared_ptr<rai::block>); bool validate_block_by_previous (rai::transaction const &, std::shared_ptr<rai::block>);
rai::uint128_t delta (); rai::uint128_t delta ();
boost::asio::io_service & service; boost::asio::io_context & io_ctx;
rai::node_config config; rai::node_config config;
rai::node_flags flags; rai::node_flags flags;
rai::alarm & alarm; rai::alarm & alarm;
@ -531,7 +531,7 @@ public:
class thread_runner class thread_runner
{ {
public: public:
thread_runner (boost::asio::io_service &, unsigned); thread_runner (boost::asio::io_context &, unsigned);
~thread_runner (); ~thread_runner ();
void join (); void join ();
std::vector<boost::thread> threads; std::vector<boost::thread> threads;
@ -542,7 +542,7 @@ public:
inactive_node (boost::filesystem::path const & path = rai::working_path ()); inactive_node (boost::filesystem::path const & path = rai::working_path ());
~inactive_node (); ~inactive_node ();
boost::filesystem::path path; boost::filesystem::path path;
std::shared_ptr<boost::asio::io_service> service; std::shared_ptr<boost::asio::io_context> io_context;
rai::alarm alarm; rai::alarm alarm;
rai::logging logging; rai::logging logging;
rai::node_init init; rai::node_init init;

12
rai/node/rpc.cpp
View file

@ -122,8 +122,8 @@ bool rai::rpc_config::deserialize_json (boost::property_tree::ptree const & tree
return result; return result;
} }
rai::rpc::rpc (boost::asio::io_service & service_a, rai::node & node_a, rai::rpc_config const & config_a) : rai::rpc::rpc (boost::asio::io_context & io_ctx_a, rai::node & node_a, rai::rpc_config const & config_a) :
acceptor (service_a), acceptor (io_ctx_a),
config (config_a), config (config_a),
node (node_a) node (node_a)
{ {
@ -3713,7 +3713,7 @@ void rai::rpc_handler::work_peers_clear ()
rai::rpc_connection::rpc_connection (rai::node & node_a, rai::rpc & rpc_a) : rai::rpc_connection::rpc_connection (rai::node & node_a, rai::rpc & rpc_a) :
node (node_a.shared ()), node (node_a.shared ()),
rpc (rpc_a), rpc (rpc_a),
socket (node_a.service) socket (node_a.io_ctx)
{ {
responded.clear (); responded.clear ();
} }
@ -4391,21 +4391,21 @@ void rai::payment_observer::complete (rai::payment_status status)
} }
} }
std::unique_ptr<rai::rpc> rai::get_rpc (boost::asio::io_service & service_a, rai::node & node_a, rai::rpc_config const & config_a) std::unique_ptr<rai::rpc> rai::get_rpc (boost::asio::io_context & io_ctx_a, rai::node & node_a, rai::rpc_config const & config_a)
{ {
std::unique_ptr<rpc> impl; std::unique_ptr<rpc> impl;
if (config_a.secure.enable) if (config_a.secure.enable)
{ {
#ifdef RAIBLOCKS_SECURE_RPC #ifdef RAIBLOCKS_SECURE_RPC
impl.reset (new rpc_secure (service_a, node_a, config_a)); impl.reset (new rpc_secure (io_ctx_a, node_a, config_a));
#else #else
std::cerr << "RPC configured for TLS, but the node is not compiled with TLS support" << std::endl; std::cerr << "RPC configured for TLS, but the node is not compiled with TLS support" << std::endl;
#endif #endif
} }
else else
{ {
impl.reset (new rpc (service_a, node_a, config_a)); impl.reset (new rpc (io_ctx_a, node_a, config_a));
} }
return impl; return impl;

4
rai/node/rpc.hpp
View file

@ -65,7 +65,7 @@ class payment_observer;
class rpc class rpc
{ {
public: public:
rpc (boost::asio::io_service &, rai::node &, rai::rpc_config const &); rpc (boost::asio::io_context &, rai::node &, rai::rpc_config const &);
virtual ~rpc () = default; virtual ~rpc () = default;
void start (); void start ();
virtual void accept (); virtual void accept ();
@ -241,5 +241,5 @@ public:
bool rpc_control_impl (); bool rpc_control_impl ();
}; };
/** Returns the correct RPC implementation based on TLS configuration */ /** Returns the correct RPC implementation based on TLS configuration */
std::unique_ptr<rai::rpc> get_rpc (boost::asio::io_service & service_a, rai::node & node_a, rai::rpc_config const & config_a); std::unique_ptr<rai::rpc> get_rpc (boost::asio::io_context & io_ctx_a, rai::node & node_a, rai::rpc_config const & config_a);
} }

6
rai/node/testing.cpp
View file

@ -18,7 +18,7 @@ std::string rai::error_system_messages::message (int ev) const
} }
rai::system::system (uint16_t port_a, size_t count_a) : rai::system::system (uint16_t port_a, size_t count_a) :
alarm (service), alarm (io_ctx),
work (1, nullptr) work (1, nullptr)
{ {
auto scale_str = std::getenv ("DEADLINE_SCALE_FACTOR"); auto scale_str = std::getenv ("DEADLINE_SCALE_FACTOR");
@ -32,7 +32,7 @@ work (1, nullptr)
{ {
rai::node_init init; rai::node_init init;
rai::node_config config (port_a + i, logging); rai::node_config config (port_a + i, logging);
auto node (std::make_shared<rai::node> (init, service, rai::unique_path (), alarm, config, work)); auto node (std::make_shared<rai::node> (init, io_ctx, rai::unique_path (), alarm, config, work));
assert (!init.error ()); assert (!init.error ());
node->start (); node->start ();
rai::uint256_union wallet; rai::uint256_union wallet;
@ -105,7 +105,7 @@ void rai::system::deadline_set (std::chrono::duration<double, std::nano> const &
std::error_code rai::system::poll (std::chrono::nanoseconds const & wait_time) std::error_code rai::system::poll (std::chrono::nanoseconds const & wait_time)
{ {
std::error_code ec; std::error_code ec;
service.run_one_for (wait_time); io_ctx.run_one_for (wait_time);
if (std::chrono::steady_clock::now () > deadline) if (std::chrono::steady_clock::now () > deadline)
{ {

2
rai/node/testing.hpp
View file

@ -38,7 +38,7 @@ public:
std::error_code poll (const std::chrono::nanoseconds & sleep_time = std::chrono::milliseconds (50)); std::error_code poll (const std::chrono::nanoseconds & sleep_time = std::chrono::milliseconds (50));
void stop (); void stop ();
void deadline_set (const std::chrono::duration<double, std::nano> & delta); void deadline_set (const std::chrono::duration<double, std::nano> & delta);
boost::asio::io_service service; boost::asio::io_context io_ctx;
rai::alarm alarm; rai::alarm alarm;
std::vector<std::shared_ptr<rai::node>> nodes; std::vector<std::shared_ptr<rai::node>> nodes;
rai::logging logging; rai::logging logging;

2
rai/qt_system/entry.cpp
View file

@ -25,7 +25,7 @@ int main (int argc, char ** argv)
client_tabs->addTab (guis.back ()->client_window, boost::str (boost::format ("Wallet %1%") % i).c_str ()); client_tabs->addTab (guis.back ()->client_window, boost::str (boost::format ("Wallet %1%") % i).c_str ());
} }
client_tabs->show (); client_tabs->show ();
rai::thread_runner runner (system.service, system.nodes[0]->config.io_threads); rai::thread_runner runner (system.io_ctx, system.nodes[0]->config.io_threads);
QObject::connect (&application, &QApplication::aboutToQuit, [&]() { QObject::connect (&application, &QApplication::aboutToQuit, [&]() {
system.stop (); system.stop ();
}); });

10
rai/rai_node/daemon.cpp
View file

@ -109,27 +109,27 @@ void rai_daemon::daemon::run (boost::filesystem::path const & data_path, rai::no
{ {
config.node.logging.init (data_path); config.node.logging.init (data_path);
config_file.close (); config_file.close ();
boost::asio::io_service service; boost::asio::io_context io_ctx;
auto opencl (rai::opencl_work::create (config.opencl_enable, config.opencl, config.node.logging)); auto opencl (rai::opencl_work::create (config.opencl_enable, config.opencl, config.node.logging));
rai::work_pool opencl_work (config.node.work_threads, opencl ? [&opencl](rai::uint256_union const & root_a) { rai::work_pool opencl_work (config.node.work_threads, opencl ? [&opencl](rai::uint256_union const & root_a) {
return opencl->generate_work (root_a); return opencl->generate_work (root_a);
} }
: std::function<boost::optional<uint64_t> (rai::uint256_union const &)> (nullptr)); : std::function<boost::optional<uint64_t> (rai::uint256_union const &)> (nullptr));
rai::alarm alarm (service); rai::alarm alarm (io_ctx);
rai::node_init init; rai::node_init init;
try try
{ {
auto node (std::make_shared<rai::node> (init, service, data_path, alarm, config.node, opencl_work)); auto node (std::make_shared<rai::node> (init, io_ctx, data_path, alarm, config.node, opencl_work));
if (!init.error ()) if (!init.error ())
{ {
node->flags = flags; node->flags = flags;
node->start (); node->start ();
std::unique_ptr<rai::rpc> rpc = get_rpc (service, *node, config.rpc); std::unique_ptr<rai::rpc> rpc = get_rpc (io_ctx, *node, config.rpc);
if (rpc && config.rpc_enable) if (rpc && config.rpc_enable)
{ {
rpc->start (); rpc->start ();
} }
runner = std::make_unique<rai::thread_runner> (service, node->config.io_threads); runner = std::make_unique<rai::thread_runner> (io_ctx, node->config.io_threads);
runner->join (); runner->join ();
} }
else else

4
rai/rai_node/entry.cpp
View file

@ -369,7 +369,7 @@ int main (int argc, char * const * argv)
rai::logging logging; rai::logging logging;
auto path (rai::unique_path ()); auto path (rai::unique_path ());
logging.init (path); logging.init (path);
auto node (std::make_shared<rai::node> (init, system.service, 24001, path, system.alarm, logging, work)); auto node (std::make_shared<rai::node> (init, system.io_ctx, 24001, path, system.alarm, logging, work));
rai::block_hash genesis_latest (node->latest (rai::test_genesis_key.pub)); rai::block_hash genesis_latest (node->latest (rai::test_genesis_key.pub));
rai::uint128_t genesis_balance (std::numeric_limits<rai::uint128_t>::max ()); rai::uint128_t genesis_balance (std::numeric_limits<rai::uint128_t>::max ());
// Generating keys // Generating keys
@ -445,7 +445,7 @@ int main (int argc, char * const * argv)
rai::logging logging; rai::logging logging;
auto path (rai::unique_path ()); auto path (rai::unique_path ());
logging.init (path); logging.init (path);
auto node (std::make_shared<rai::node> (init, system.service, 24001, path, system.alarm, logging, work)); auto node (std::make_shared<rai::node> (init, system.io_ctx, 24001, path, system.alarm, logging, work));
rai::block_hash genesis_latest (node->latest (rai::test_genesis_key.pub)); rai::block_hash genesis_latest (node->latest (rai::test_genesis_key.pub));
rai::uint128_t genesis_balance (std::numeric_limits<rai::uint128_t>::max ()); rai::uint128_t genesis_balance (std::numeric_limits<rai::uint128_t>::max ());
// Generating keys // Generating keys

10
rai/rai_wallet/entry.cpp
View file

@ -210,7 +210,7 @@ int run_wallet (QApplication & application, int argc, char * const * argv, boost
rai::set_secure_perm_file (config_path, error_chmod); rai::set_secure_perm_file (config_path, error_chmod);
if (!error) if (!error)
{ {
boost::asio::io_service service; boost::asio::io_context io_ctx;
config.node.logging.init (data_path); config.node.logging.init (data_path);
std::shared_ptr<rai::node> node; std::shared_ptr<rai::node> node;
std::shared_ptr<rai_qt::wallet> gui; std::shared_ptr<rai_qt::wallet> gui;
@ -220,9 +220,9 @@ int run_wallet (QApplication & application, int argc, char * const * argv, boost
return opencl->generate_work (root_a); return opencl->generate_work (root_a);
} }
: std::function<boost::optional<uint64_t> (rai::uint256_union const &)> (nullptr)); : std::function<boost::optional<uint64_t> (rai::uint256_union const &)> (nullptr));
rai::alarm alarm (service); rai::alarm alarm (io_ctx);
rai::node_init init; rai::node_init init;
node = std::make_shared<rai::node> (init, service, data_path, alarm, config.node, work); node = std::make_shared<rai::node> (init, io_ctx, data_path, alarm, config.node, work);
if (!init.error ()) if (!init.error ())
{ {
auto wallet (node->wallets.open (config.wallet)); auto wallet (node->wallets.open (config.wallet));
@ -256,12 +256,12 @@ int run_wallet (QApplication & application, int argc, char * const * argv, boost
assert (wallet->exists (config.account)); assert (wallet->exists (config.account));
update_config (config, config_path, config_file); update_config (config, config_path, config_file);
node->start (); node->start ();
std::unique_ptr<rai::rpc> rpc = get_rpc (service, *node, config.rpc); std::unique_ptr<rai::rpc> rpc = get_rpc (io_ctx, *node, config.rpc);
if (rpc && config.rpc_enable) if (rpc && config.rpc_enable)
{ {
rpc->start (); rpc->start ();
} }
rai::thread_runner runner (service, node->config.io_threads); rai::thread_runner runner (io_ctx, node->config.io_threads);
QObject::connect (&application, &QApplication::aboutToQuit, [&]() { QObject::connect (&application, &QApplication::aboutToQuit, [&]() {
rpc->stop (); rpc->stop ();
node->stop (); node->stop ();

6
rai/slow_test/node.cpp
View file

@ -20,7 +20,7 @@ TEST (system, generate_mass_activity)
TEST (system, generate_mass_activity_long) TEST (system, generate_mass_activity_long)
{ {
rai::system system (24000, 1); rai::system system (24000, 1);
rai::thread_runner runner (system.service, system.nodes[0]->config.io_threads); rai::thread_runner runner (system.io_ctx, system.nodes[0]->config.io_threads);
system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv);
size_t count (1000000000); size_t count (1000000000);
system.generate_mass_activity (count, *system.nodes[0]); system.generate_mass_activity (count, *system.nodes[0]);
@ -39,13 +39,13 @@ TEST (system, receive_while_synchronizing)
std::vector<boost::thread> threads; std::vector<boost::thread> threads;
{ {
rai::system system (24000, 1); rai::system system (24000, 1);
rai::thread_runner runner (system.service, system.nodes[0]->config.io_threads); rai::thread_runner runner (system.io_ctx, system.nodes[0]->config.io_threads);
system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv);
size_t count (1000); size_t count (1000);
system.generate_mass_activity (count, *system.nodes[0]); system.generate_mass_activity (count, *system.nodes[0]);
rai::keypair key; rai::keypair key;
rai::node_init init1; rai::node_init init1;
auto node1 (std::make_shared<rai::node> (init1, system.service, 24001, rai::unique_path (), system.alarm, system.logging, system.work)); auto node1 (std::make_shared<rai::node> (init1, system.io_ctx, 24001, rai::unique_path (), system.alarm, system.logging, system.work));
ASSERT_FALSE (init1.error ()); ASSERT_FALSE (init1.error ());
node1->network.send_keepalive (system.nodes[0]->network.endpoint ()); node1->network.send_keepalive (system.nodes[0]->network.endpoint ());
auto wallet (node1->wallets.create (1)); auto wallet (node1->wallets.create (1));