diff --git a/nano/core_test/bootstrap.cpp b/nano/core_test/bootstrap.cpp index 794e086b0..899fa4edc 100644 --- a/nano/core_test/bootstrap.cpp +++ b/nano/core_test/bootstrap.cpp @@ -13,7 +13,7 @@ using namespace std::chrono_literals; TEST (bulk_pull, no_address) { nano::test::system system (1); - auto connection (std::make_shared (std::make_shared (*system.nodes[0], nano::socket::endpoint_type_t::server), system.nodes[0])); + auto connection (std::make_shared (std::make_shared (*system.nodes[0], nano::transport::socket::endpoint_type_t::server), system.nodes[0])); auto req = std::make_unique (nano::dev::network_params.network); req->start = 1; req->end = 2; @@ -25,7 +25,7 @@ TEST (bulk_pull, no_address) TEST (bulk_pull, genesis_to_end) { nano::test::system system (1); - auto connection (std::make_shared (std::make_shared (*system.nodes[0], nano::socket::endpoint_type_t::server), system.nodes[0])); + auto connection (std::make_shared (std::make_shared (*system.nodes[0], nano::transport::socket::endpoint_type_t::server), system.nodes[0])); auto req = std::make_unique (nano::dev::network_params.network); req->start = nano::dev::genesis_key.pub; req->end.clear (); @@ -38,7 +38,7 @@ TEST (bulk_pull, genesis_to_end) TEST (bulk_pull, no_end) { nano::test::system system (1); - auto connection (std::make_shared (std::make_shared (*system.nodes[0], nano::socket::endpoint_type_t::server), system.nodes[0])); + auto connection (std::make_shared (std::make_shared (*system.nodes[0], nano::transport::socket::endpoint_type_t::server), system.nodes[0])); auto req = std::make_unique (nano::dev::network_params.network); req->start = nano::dev::genesis_key.pub; req->end = 1; @@ -70,7 +70,7 @@ TEST (bulk_pull, end_not_owned) open->signature = nano::sign_message (key2.prv, key2.pub, open->hash ()); system.nodes[0]->work_generate_blocking (*open); ASSERT_EQ (nano::process_result::progress, system.nodes[0]->process (*open).code); - auto connection (std::make_shared (std::make_shared (*system.nodes[0], nano::socket::endpoint_type_t::server), system.nodes[0])); + auto connection (std::make_shared (std::make_shared (*system.nodes[0], nano::transport::socket::endpoint_type_t::server), system.nodes[0])); auto req = std::make_unique (nano::dev::network_params.network); req->start = key2.pub; req->end = nano::dev::genesis->hash (); @@ -81,7 +81,7 @@ TEST (bulk_pull, end_not_owned) TEST (bulk_pull, none) { nano::test::system system (1); - auto connection (std::make_shared (std::make_shared (*system.nodes[0], nano::socket::endpoint_type_t::server), system.nodes[0])); + auto connection (std::make_shared (std::make_shared (*system.nodes[0], nano::transport::socket::endpoint_type_t::server), system.nodes[0])); auto req = std::make_unique (nano::dev::network_params.network); req->start = nano::dev::genesis_key.pub; req->end = nano::dev::genesis->hash (); @@ -93,7 +93,7 @@ TEST (bulk_pull, none) TEST (bulk_pull, get_next_on_open) { nano::test::system system (1); - auto connection (std::make_shared (std::make_shared (*system.nodes[0], nano::socket::endpoint_type_t::server), system.nodes[0])); + auto connection (std::make_shared (std::make_shared (*system.nodes[0], nano::transport::socket::endpoint_type_t::server), system.nodes[0])); auto req = std::make_unique (nano::dev::network_params.network); req->start = nano::dev::genesis_key.pub; req->end.clear (); @@ -123,7 +123,7 @@ TEST (bulk_pull, ascending_one_hash) .build_shared (); node.work_generate_blocking (*block1); ASSERT_EQ (nano::process_result::progress, node.process (*block1).code); - auto socket = std::make_shared (node, nano::socket::endpoint_type_t::server); + auto socket = std::make_shared (node, nano::transport::socket::endpoint_type_t::server); auto connection = std::make_shared (socket, system.nodes[0]); auto req = std::make_unique (nano::dev::network_params.network); req->start = nano::dev::genesis->hash (); @@ -155,7 +155,7 @@ TEST (bulk_pull, ascending_two_account) .build_shared (); node.work_generate_blocking (*block1); ASSERT_EQ (nano::process_result::progress, node.process (*block1).code); - auto socket = std::make_shared (node, nano::socket::endpoint_type_t::server); + auto socket = std::make_shared (node, nano::transport::socket::endpoint_type_t::server); auto connection = std::make_shared (socket, system.nodes[0]); auto req = std::make_unique (nano::dev::network_params.network); req->start = nano::dev::genesis->hash (); @@ -190,7 +190,7 @@ TEST (bulk_pull, ascending_end) .build_shared (); node.work_generate_blocking (*block1); ASSERT_EQ (nano::process_result::progress, node.process (*block1).code); - auto socket = std::make_shared (node, nano::socket::endpoint_type_t::server); + auto socket = std::make_shared (node, nano::transport::socket::endpoint_type_t::server); auto connection = std::make_shared (socket, system.nodes[0]); auto req = std::make_unique (nano::dev::network_params.network); req->start = nano::dev::genesis_key.pub; @@ -206,7 +206,7 @@ TEST (bulk_pull, ascending_end) TEST (bulk_pull, by_block) { nano::test::system system (1); - auto connection (std::make_shared (std::make_shared (*system.nodes[0], nano::socket::endpoint_type_t::server), system.nodes[0])); + auto connection (std::make_shared (std::make_shared (*system.nodes[0], nano::transport::socket::endpoint_type_t::server), system.nodes[0])); auto req = std::make_unique (nano::dev::network_params.network); req->start = nano::dev::genesis->hash (); req->end.clear (); @@ -222,7 +222,7 @@ TEST (bulk_pull, by_block) TEST (bulk_pull, by_block_single) { nano::test::system system (1); - auto connection (std::make_shared (std::make_shared (*system.nodes[0], nano::socket::endpoint_type_t::server), system.nodes[0])); + auto connection (std::make_shared (std::make_shared (*system.nodes[0], nano::transport::socket::endpoint_type_t::server), system.nodes[0])); auto req = std::make_unique (nano::dev::network_params.network); req->start = nano::dev::genesis->hash (); req->end = nano::dev::genesis->hash (); @@ -259,7 +259,7 @@ TEST (bulk_pull, count_limit) .build_shared (); ASSERT_EQ (nano::process_result::progress, node0->process (*receive1).code); - auto connection (std::make_shared (std::make_shared (*node0, nano::socket::endpoint_type_t::server), node0)); + auto connection (std::make_shared (std::make_shared (*node0, nano::transport::socket::endpoint_type_t::server), node0)); auto req = std::make_unique (nano::dev::network_params.network); req->start = receive1->hash (); req->set_count_present (true); @@ -1643,7 +1643,7 @@ TEST (frontier_req_response, DISABLED_destruction) TEST (frontier_req, begin) { nano::test::system system (1); - auto connection (std::make_shared (std::make_shared (*system.nodes[0], nano::socket::endpoint_type_t::server), system.nodes[0])); + auto connection (std::make_shared (std::make_shared (*system.nodes[0], nano::transport::socket::endpoint_type_t::server), system.nodes[0])); auto req = std::make_unique (nano::dev::network_params.network); req->start.clear (); req->age = std::numeric_limitsage)>::max (); @@ -1656,7 +1656,7 @@ TEST (frontier_req, begin) TEST (frontier_req, end) { nano::test::system system (1); - auto connection (std::make_shared (std::make_shared (*system.nodes[0], nano::socket::endpoint_type_t::server), system.nodes[0])); + auto connection (std::make_shared (std::make_shared (*system.nodes[0], nano::transport::socket::endpoint_type_t::server), system.nodes[0])); auto req = std::make_unique (nano::dev::network_params.network); req->start = nano::dev::genesis_key.pub.number () + 1; req->age = std::numeric_limitsage)>::max (); @@ -1697,7 +1697,7 @@ TEST (frontier_req, count) node1->work_generate_blocking (*receive1); ASSERT_EQ (nano::process_result::progress, node1->process (*receive1).code); - auto connection (std::make_shared (std::make_shared (*node1, nano::socket::endpoint_type_t::server), node1)); + auto connection (std::make_shared (std::make_shared (*node1, nano::transport::socket::endpoint_type_t::server), node1)); auto req = std::make_unique (nano::dev::network_params.network); req->start.clear (); req->age = std::numeric_limitsage)>::max (); @@ -1710,7 +1710,7 @@ TEST (frontier_req, count) TEST (frontier_req, time_bound) { nano::test::system system (1); - auto connection (std::make_shared (std::make_shared (*system.nodes[0], nano::socket::endpoint_type_t::server), system.nodes[0])); + auto connection (std::make_shared (std::make_shared (*system.nodes[0], nano::transport::socket::endpoint_type_t::server), system.nodes[0])); auto req = std::make_unique (nano::dev::network_params.network); req->start.clear (); req->age = 1; @@ -1723,7 +1723,7 @@ TEST (frontier_req, time_bound) req2->start.clear (); req2->age = 1; req2->count = std::numeric_limitscount)>::max (); - auto connection2 (std::make_shared (std::make_shared (*system.nodes[0], nano::socket::endpoint_type_t::server), system.nodes[0])); + auto connection2 (std::make_shared (std::make_shared (*system.nodes[0], nano::transport::socket::endpoint_type_t::server), system.nodes[0])); auto request2 (std::make_shared (connection, std::move (req2))); ASSERT_TRUE (request2->current.is_zero ()); } @@ -1731,7 +1731,7 @@ TEST (frontier_req, time_bound) TEST (frontier_req, time_cutoff) { nano::test::system system (1); - auto connection (std::make_shared (std::make_shared (*system.nodes[0], nano::socket::endpoint_type_t::server), system.nodes[0])); + auto connection (std::make_shared (std::make_shared (*system.nodes[0], nano::transport::socket::endpoint_type_t::server), system.nodes[0])); auto req = std::make_unique (nano::dev::network_params.network); req->start.clear (); req->age = 3; @@ -1745,7 +1745,7 @@ TEST (frontier_req, time_cutoff) req2->start.clear (); req2->age = 3; req2->count = std::numeric_limitscount)>::max (); - auto connection2 (std::make_shared (std::make_shared (*system.nodes[0], nano::socket::endpoint_type_t::server), system.nodes[0])); + auto connection2 (std::make_shared (std::make_shared (*system.nodes[0], nano::transport::socket::endpoint_type_t::server), system.nodes[0])); auto request2 (std::make_shared (connection, std::move (req2))); ASSERT_TRUE (request2->frontier.is_zero ()); } @@ -1817,7 +1817,7 @@ TEST (frontier_req, confirmed_frontier) ASSERT_EQ (nano::process_result::progress, node1->process (*receive2).code); // Request for all accounts (confirmed only) - auto connection (std::make_shared (std::make_shared (*node1, nano::socket::endpoint_type_t::server), node1)); + auto connection (std::make_shared (std::make_shared (*node1, nano::transport::socket::endpoint_type_t::server), node1)); auto req = std::make_unique (nano::dev::network_params.network); req->start.clear (); req->age = std::numeric_limitsage)>::max (); @@ -1830,7 +1830,7 @@ TEST (frontier_req, confirmed_frontier) ASSERT_EQ (nano::dev::genesis->hash (), request->frontier); // Request starting with account before genesis (confirmed only) - auto connection2 (std::make_shared (std::make_shared (*node1, nano::socket::endpoint_type_t::server), node1)); + auto connection2 (std::make_shared (std::make_shared (*node1, nano::transport::socket::endpoint_type_t::server), node1)); auto req2 = std::make_unique (nano::dev::network_params.network); req2->start = key_before_genesis.pub; req2->age = std::numeric_limitsage)>::max (); @@ -1843,7 +1843,7 @@ TEST (frontier_req, confirmed_frontier) ASSERT_EQ (nano::dev::genesis->hash (), request2->frontier); // Request starting with account after genesis (confirmed only) - auto connection3 (std::make_shared (std::make_shared (*node1, nano::socket::endpoint_type_t::server), node1)); + auto connection3 (std::make_shared (std::make_shared (*node1, nano::transport::socket::endpoint_type_t::server), node1)); auto req3 = std::make_unique (nano::dev::network_params.network); req3->start = key_after_genesis.pub; req3->age = std::numeric_limitsage)>::max (); @@ -1856,7 +1856,7 @@ TEST (frontier_req, confirmed_frontier) ASSERT_TRUE (request3->frontier.is_zero ()); // Request for all accounts (unconfirmed blocks) - auto connection4 (std::make_shared (std::make_shared (*node1, nano::socket::endpoint_type_t::server), node1)); + auto connection4 (std::make_shared (std::make_shared (*node1, nano::transport::socket::endpoint_type_t::server), node1)); auto req4 = std::make_unique (nano::dev::network_params.network); req4->start.clear (); req4->age = std::numeric_limitsage)>::max (); @@ -1867,7 +1867,7 @@ TEST (frontier_req, confirmed_frontier) ASSERT_EQ (receive1->hash (), request4->frontier); // Request starting with account after genesis (unconfirmed blocks) - auto connection5 (std::make_shared (std::make_shared (*node1, nano::socket::endpoint_type_t::server), node1)); + auto connection5 (std::make_shared (std::make_shared (*node1, nano::transport::socket::endpoint_type_t::server), node1)); auto req5 = std::make_unique (nano::dev::network_params.network); req5->start = key_after_genesis.pub; req5->age = std::numeric_limitsage)>::max (); @@ -1880,7 +1880,7 @@ TEST (frontier_req, confirmed_frontier) // Confirm account before genesis (confirmed only) nano::test::start_elections (system, *node1, { send1, receive1 }, true); ASSERT_TIMELY (5s, node1->block_confirmed (send1->hash ()) && node1->block_confirmed (receive1->hash ())); - auto connection6 (std::make_shared (std::make_shared (*node1, nano::socket::endpoint_type_t::server), node1)); + auto connection6 (std::make_shared (std::make_shared (*node1, nano::transport::socket::endpoint_type_t::server), node1)); auto req6 = std::make_unique (nano::dev::network_params.network); req6->start = key_before_genesis.pub; req6->age = std::numeric_limitsage)>::max (); @@ -1895,7 +1895,7 @@ TEST (frontier_req, confirmed_frontier) // Confirm account after genesis (confirmed only) nano::test::start_elections (system, *node1, { send2, receive2 }, true); ASSERT_TIMELY (5s, node1->block_confirmed (send2->hash ()) && node1->block_confirmed (receive2->hash ())); - auto connection7 (std::make_shared (std::make_shared (*node1, nano::socket::endpoint_type_t::server), node1)); + auto connection7 (std::make_shared (std::make_shared (*node1, nano::transport::socket::endpoint_type_t::server), node1)); auto req7 = std::make_unique (nano::dev::network_params.network); req7->start = key_after_genesis.pub; req7->age = std::numeric_limitsage)>::max (); @@ -2071,7 +2071,7 @@ TEST (bulk_pull_account, basics) auto send2 (system.wallet (0)->send_action (nano::dev::genesis->account (), key1.pub, 10)); auto send3 (system.wallet (0)->send_action (nano::dev::genesis->account (), key1.pub, 2)); ASSERT_TIMELY (5s, system.nodes[0]->balance (key1.pub) == 25); - auto connection (std::make_shared (std::make_shared (*system.nodes[0], nano::socket::endpoint_type_t::server), system.nodes[0])); + auto connection (std::make_shared (std::make_shared (*system.nodes[0], nano::transport::socket::endpoint_type_t::server), system.nodes[0])); { auto req = std::make_unique (nano::dev::network_params.network); diff --git a/nano/core_test/network.cpp b/nano/core_test/network.cpp index 6ce5670f9..6f4b8e2dd 100644 --- a/nano/core_test/network.cpp +++ b/nano/core_test/network.cpp @@ -1,7 +1,7 @@ #include #include -#include #include +#include #include #include #include @@ -177,8 +177,8 @@ TEST (network, last_contacted) { // check that the endpoints are part of the same connection - std::shared_ptr sock0 = channel0->socket.lock (); - std::shared_ptr sock1 = channel1->socket.lock (); + std::shared_ptr sock0 = channel0->socket.lock (); + std::shared_ptr sock1 = channel1->socket.lock (); ASSERT_TRUE (sock0->local_endpoint () == sock1->remote_endpoint ()); ASSERT_TRUE (sock1->local_endpoint () == sock0->remote_endpoint ()); } @@ -703,7 +703,7 @@ TEST (node, port_mapping) TEST (tcp_listener, tcp_node_id_handshake) { nano::test::system system (1); - auto socket (std::make_shared (*system.nodes[0])); + auto socket (std::make_shared (*system.nodes[0])); auto bootstrap_endpoint (system.nodes[0]->tcp_listener.endpoint ()); auto cookie (system.nodes[0]->network.syn_cookies.assign (nano::transport::map_tcp_to_endpoint (bootstrap_endpoint))); nano::node_id_handshake node_id_handshake{ nano::dev::network_params.network, cookie, boost::none }; @@ -739,7 +739,7 @@ TEST (tcp_listener, DISABLED_tcp_listener_timeout_empty) { nano::test::system system (1); auto node0 (system.nodes[0]); - auto socket (std::make_shared (*node0)); + auto socket (std::make_shared (*node0)); std::atomic connected (false); socket->async_connect (node0->tcp_listener.endpoint (), [&connected] (boost::system::error_code const & ec) { ASSERT_FALSE (ec); @@ -762,7 +762,7 @@ TEST (tcp_listener, tcp_listener_timeout_node_id_handshake) { nano::test::system system (1); auto node0 (system.nodes[0]); - auto socket (std::make_shared (*node0)); + auto socket (std::make_shared (*node0)); auto cookie (node0->network.syn_cookies.assign (nano::transport::map_tcp_to_endpoint (node0->tcp_listener.endpoint ()))); nano::node_id_handshake node_id_handshake{ nano::dev::network_params.network, cookie, boost::none }; auto channel = std::make_shared (*node0, socket); @@ -919,7 +919,7 @@ TEST (network, bandwidth_limiter) ASSERT_TIMELY (1s, 1 == node.stats.count (nano::stat::type::drop, nano::stat::detail::publish, nano::stat::dir::out)); // Send non-droppable message, i.e. drop stats should not increase - channel2.send (message, nullptr, nano::buffer_drop_policy::no_limiter_drop); + channel2.send (message, nullptr, nano::transport::buffer_drop_policy::no_limiter_drop); ASSERT_TIMELY (1s, 1 == node.stats.count (nano::stat::type::drop, nano::stat::detail::publish, nano::stat::dir::out)); // change the bandwidth settings, 2 packets will be dropped @@ -1195,11 +1195,11 @@ TEST (network, purge_dead_channel_outgoing) auto & node1 = *system.add_node (flags); // We expect one incoming and one outgoing connection - std::shared_ptr outgoing; - std::shared_ptr incoming; + std::shared_ptr outgoing; + std::shared_ptr incoming; std::atomic connected_count{ 0 }; - node1.observers.socket_connected.add ([&] (nano::socket & socket) { + node1.observers.socket_connected.add ([&] (nano::transport::socket & socket) { connected_count++; outgoing = socket.shared_from_this (); @@ -1207,7 +1207,7 @@ TEST (network, purge_dead_channel_outgoing) }); std::atomic accepted_count{ 0 }; - node1.observers.socket_accepted.add ([&] (nano::socket & socket) { + node1.observers.socket_accepted.add ([&] (nano::transport::socket & socket) { accepted_count++; incoming = socket.shared_from_this (); @@ -1267,11 +1267,11 @@ TEST (network, purge_dead_channel_incoming) auto & node1 = *system.add_node (flags); // We expect one incoming and one outgoing connection - std::shared_ptr outgoing; - std::shared_ptr incoming; + std::shared_ptr outgoing; + std::shared_ptr incoming; std::atomic connected_count{ 0 }; - node1.observers.socket_connected.add ([&] (nano::socket & socket) { + node1.observers.socket_connected.add ([&] (nano::transport::socket & socket) { connected_count++; outgoing = socket.shared_from_this (); @@ -1279,7 +1279,7 @@ TEST (network, purge_dead_channel_incoming) }); std::atomic accepted_count{ 0 }; - node1.observers.socket_accepted.add ([&] (nano::socket & socket) { + node1.observers.socket_accepted.add ([&] (nano::transport::socket & socket) { accepted_count++; incoming = socket.shared_from_this (); diff --git a/nano/core_test/node.cpp b/nano/core_test/node.cpp index ee20551d3..a88c72a43 100644 --- a/nano/core_test/node.cpp +++ b/nano/core_test/node.cpp @@ -743,7 +743,7 @@ TEST (node, fork_flip) .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); nano::publish publish2{ nano::dev::network_params.network, send2 }; - auto ignored_channel{ std::make_shared (node1, std::weak_ptr ()) }; + auto ignored_channel{ std::make_shared (node1, std::weak_ptr ()) }; node1.network.inbound (publish1, ignored_channel); node1.block_processor.flush (); diff --git a/nano/core_test/peer_container.cpp b/nano/core_test/peer_container.cpp index 26d92aea6..e896e909d 100644 --- a/nano/core_test/peer_container.cpp +++ b/nano/core_test/peer_container.cpp @@ -1,4 +1,4 @@ -#include +#include #include #include #include diff --git a/nano/core_test/request_aggregator.cpp b/nano/core_test/request_aggregator.cpp index 1ca73fa55..3aca37a6a 100644 --- a/nano/core_test/request_aggregator.cpp +++ b/nano/core_test/request_aggregator.cpp @@ -29,7 +29,7 @@ TEST (request_aggregator, one) .build_shared (); std::vector> request; request.emplace_back (send1->hash (), send1->root ()); - auto client = std::make_shared (node); + auto client = std::make_shared (node); std::shared_ptr dummy_channel = std::make_shared (node, client); node.aggregator.add (dummy_channel, request); ASSERT_EQ (1, node.aggregator.size ()); @@ -98,7 +98,7 @@ TEST (request_aggregator, one_update) ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *receive1).code); std::vector> request; request.emplace_back (send2->hash (), send2->root ()); - auto client = std::make_shared (node); + auto client = std::make_shared (node); std::shared_ptr dummy_channel = std::make_shared (node, client); node.aggregator.add (dummy_channel, request); request.clear (); @@ -165,7 +165,7 @@ TEST (request_aggregator, two) std::vector> request; request.emplace_back (send2->hash (), send2->root ()); request.emplace_back (receive1->hash (), receive1->root ()); - auto client = std::make_shared (node); + auto client = std::make_shared (node); std::shared_ptr dummy_channel = std::make_shared (node, client); // Process both blocks node.aggregator.add (dummy_channel, request); @@ -289,7 +289,7 @@ TEST (request_aggregator, split) election->force_confirm (); ASSERT_TIMELY (5s, max_vbh + 2 == node.ledger.cache.cemented_count); ASSERT_EQ (max_vbh + 1, request.size ()); - auto client = std::make_shared (node); + auto client = std::make_shared (node); std::shared_ptr dummy_channel = std::make_shared (node, client); node.aggregator.add (dummy_channel, request); ASSERT_EQ (1, node.aggregator.size ()); @@ -330,7 +330,7 @@ TEST (request_aggregator, channel_lifetime) request.emplace_back (send1->hash (), send1->root ()); { // The aggregator should extend the lifetime of the channel - auto client = std::make_shared (node); + auto client = std::make_shared (node); std::shared_ptr dummy_channel = std::make_shared (node, client); node.aggregator.add (dummy_channel, request); } @@ -361,11 +361,11 @@ TEST (request_aggregator, channel_update) request.emplace_back (send1->hash (), send1->root ()); std::weak_ptr channel1_w; { - auto client1 = std::make_shared (node); + auto client1 = std::make_shared (node); std::shared_ptr dummy_channel1 = std::make_shared (node, client1); channel1_w = dummy_channel1; node.aggregator.add (dummy_channel1, request); - auto client2 = std::make_shared (node); + auto client2 = std::make_shared (node); std::shared_ptr dummy_channel2 = std::make_shared (node, client2); // The aggregator then hold channel2 and drop channel1 node.aggregator.add (dummy_channel2, request); @@ -399,7 +399,7 @@ TEST (request_aggregator, channel_max_queue) ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send1).code); std::vector> request; request.emplace_back (send1->hash (), send1->root ()); - auto client = std::make_shared (node); + auto client = std::make_shared (node); std::shared_ptr dummy_channel = std::make_shared (node, client); node.aggregator.add (dummy_channel, request); node.aggregator.add (dummy_channel, request); @@ -427,7 +427,7 @@ TEST (request_aggregator, unique) ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send1).code); std::vector> request; request.emplace_back (send1->hash (), send1->root ()); - auto client = std::make_shared (node); + auto client = std::make_shared (node); std::shared_ptr dummy_channel = std::make_shared (node, client); node.aggregator.add (dummy_channel, request); node.aggregator.add (dummy_channel, request); @@ -474,7 +474,7 @@ TEST (request_aggregator, cannot_vote) request.emplace_back (send2->hash (), send2->root ()); // Incorrect hash, correct root request.emplace_back (1, send2->root ()); - auto client = std::make_shared (node); + auto client = std::make_shared (node); std::shared_ptr dummy_channel = std::make_shared (node, client); node.aggregator.add (dummy_channel, request); ASSERT_EQ (1, node.aggregator.size ()); diff --git a/nano/core_test/socket.cpp b/nano/core_test/socket.cpp index 9aab60453..a34af37b0 100644 --- a/nano/core_test/socket.cpp +++ b/nano/core_test/socket.cpp @@ -1,7 +1,7 @@ #include #include #include -#include +#include #include #include @@ -27,14 +27,14 @@ TEST (socket, max_connections) boost::asio::ip::tcp::endpoint dst_endpoint{ boost::asio::ip::address_v6::loopback (), server_port }; // start a server socket that allows max 2 live connections - auto server_socket = std::make_shared (*node, listen_endpoint, 2); + auto server_socket = std::make_shared (*node, listen_endpoint, 2); boost::system::error_code ec; server_socket->start (ec); ASSERT_FALSE (ec); // successful incoming connections are stored in server_sockets to keep them alive (server side) - std::vector> server_sockets; - server_socket->on_connection ([&server_sockets] (std::shared_ptr const & new_connection, boost::system::error_code const & ec_a) { + std::vector> server_sockets; + server_socket->on_connection ([&server_sockets] (std::shared_ptr const & new_connection, boost::system::error_code const & ec_a) { server_sockets.push_back (new_connection); return true; }); @@ -48,13 +48,13 @@ TEST (socket, max_connections) // start 3 clients, 2 will persist but 1 will be dropped - auto client1 = std::make_shared (*node); + auto client1 = std::make_shared (*node); client1->async_connect (dst_endpoint, connect_handler); - auto client2 = std::make_shared (*node); + auto client2 = std::make_shared (*node); client2->async_connect (dst_endpoint, connect_handler); - auto client3 = std::make_shared (*node); + auto client3 = std::make_shared (*node); client3->async_connect (dst_endpoint, connect_handler); auto get_tcp_accept_failures = [&node] () { @@ -73,10 +73,10 @@ TEST (socket, max_connections) server_sockets[0].reset (); - auto client4 = std::make_shared (*node); + auto client4 = std::make_shared (*node); client4->async_connect (dst_endpoint, connect_handler); - auto client5 = std::make_shared (*node); + auto client5 = std::make_shared (*node); client5->async_connect (dst_endpoint, connect_handler); ASSERT_TIMELY (5s, get_tcp_accept_failures () == 2); @@ -90,13 +90,13 @@ TEST (socket, max_connections) server_sockets[2].reset (); ASSERT_EQ (server_sockets.size (), 3); - auto client6 = std::make_shared (*node); + auto client6 = std::make_shared (*node); client6->async_connect (dst_endpoint, connect_handler); - auto client7 = std::make_shared (*node); + auto client7 = std::make_shared (*node); client7->async_connect (dst_endpoint, connect_handler); - auto client8 = std::make_shared (*node); + auto client8 = std::make_shared (*node); client8->async_connect (dst_endpoint, connect_handler); ASSERT_TIMELY (5s, get_tcp_accept_failures () == 3); @@ -123,14 +123,14 @@ TEST (socket, max_connections_per_ip) const auto max_global_connections = 1000; - auto server_socket = std::make_shared (*node, listen_endpoint, max_global_connections); + auto server_socket = std::make_shared (*node, listen_endpoint, max_global_connections); boost::system::error_code ec; server_socket->start (ec); ASSERT_FALSE (ec); // successful incoming connections are stored in server_sockets to keep them alive (server side) - std::vector> server_sockets; - server_socket->on_connection ([&server_sockets] (std::shared_ptr const & new_connection, boost::system::error_code const & ec_a) { + std::vector> server_sockets; + server_socket->on_connection ([&server_sockets] (std::shared_ptr const & new_connection, boost::system::error_code const & ec_a) { server_sockets.push_back (new_connection); return true; }); @@ -143,12 +143,12 @@ TEST (socket, max_connections_per_ip) }; // start n clients, n-1 will persist but 1 will be dropped, where n == max_ip_connections - std::vector> client_list; + std::vector> client_list; client_list.reserve (max_ip_connections + 1); for (auto idx = 0; idx < max_ip_connections + 1; ++idx) { - auto client = std::make_shared (*node); + auto client = std::make_shared (*node); client->async_connect (dst_endpoint, connect_handler); client_list.push_back (client); } @@ -171,7 +171,7 @@ TEST (socket, max_connections_per_ip) TEST (socket, limited_subnet_address) { auto address = boost::asio::ip::make_address ("a41d:b7b2:8298:cf45:672e:bd1a:e7fb:f713"); - auto network = nano::socket_functions::get_ipv6_subnet_address (address.to_v6 (), 32); // network prefix = 32. + auto network = nano::transport::socket_functions::get_ipv6_subnet_address (address.to_v6 (), 32); // network prefix = 32. ASSERT_EQ ("a41d:b7b2:8298:cf45:672e:bd1a:e7fb:f713/32", network.to_string ()); ASSERT_EQ ("a41d:b7b2::/32", network.canonical ().to_string ()); } @@ -179,14 +179,14 @@ TEST (socket, limited_subnet_address) TEST (socket, first_ipv6_subnet_address) { auto address = boost::asio::ip::make_address ("a41d:b7b2:8298:cf45:672e:bd1a:e7fb:f713"); - auto first_address = nano::socket_functions::first_ipv6_subnet_address (address.to_v6 (), 32); // network prefix = 32. + auto first_address = nano::transport::socket_functions::first_ipv6_subnet_address (address.to_v6 (), 32); // network prefix = 32. ASSERT_EQ ("a41d:b7b2::", first_address.to_string ()); } TEST (socket, last_ipv6_subnet_address) { auto address = boost::asio::ip::make_address ("a41d:b7b2:8298:cf45:672e:bd1a:e7fb:f713"); - auto last_address = nano::socket_functions::last_ipv6_subnet_address (address.to_v6 (), 32); // network prefix = 32. + auto last_address = nano::transport::socket_functions::last_ipv6_subnet_address (address.to_v6 (), 32); // network prefix = 32. ASSERT_EQ ("a41d:b7b2:ffff:ffff:ffff:ffff:ffff:ffff", last_address.to_string ()); } @@ -203,15 +203,15 @@ TEST (socket, count_subnetwork_connections) auto address5 = boost::asio::ip::make_address ("a41d:b7b3::"); // out of the network prefix auto address6 = boost::asio::ip::make_address ("a41d:b7b3::1"); // out of the network prefix - auto connection0 = std::make_shared (*node); - auto connection1 = std::make_shared (*node); - auto connection2 = std::make_shared (*node); - auto connection3 = std::make_shared (*node); - auto connection4 = std::make_shared (*node); - auto connection5 = std::make_shared (*node); - auto connection6 = std::make_shared (*node); + auto connection0 = std::make_shared (*node); + auto connection1 = std::make_shared (*node); + auto connection2 = std::make_shared (*node); + auto connection3 = std::make_shared (*node); + auto connection4 = std::make_shared (*node); + auto connection5 = std::make_shared (*node); + auto connection6 = std::make_shared (*node); - nano::address_socket_mmap connections_per_address; + nano::transport::address_socket_mmap connections_per_address; connections_per_address.emplace (address0, connection0); connections_per_address.emplace (address1, connection1); connections_per_address.emplace (address2, connection2); @@ -221,7 +221,7 @@ TEST (socket, count_subnetwork_connections) connections_per_address.emplace (address6, connection6); // Asserts it counts only the connections for the specified address and its network prefix. - ASSERT_EQ (4, nano::socket_functions::count_subnetwork_connections (connections_per_address, address1.to_v6 (), 32)); + ASSERT_EQ (4, nano::transport::socket_functions::count_subnetwork_connections (connections_per_address, address1.to_v6 (), 32)); } TEST (socket, max_connections_per_subnetwork) @@ -245,14 +245,14 @@ TEST (socket, max_connections_per_subnetwork) const auto max_global_connections = 1000; - auto server_socket = std::make_shared (*node, listen_endpoint, max_global_connections); + auto server_socket = std::make_shared (*node, listen_endpoint, max_global_connections); boost::system::error_code ec; server_socket->start (ec); ASSERT_FALSE (ec); // successful incoming connections are stored in server_sockets to keep them alive (server side) - std::vector> server_sockets; - server_socket->on_connection ([&server_sockets] (std::shared_ptr const & new_connection, boost::system::error_code const & ec_a) { + std::vector> server_sockets; + server_socket->on_connection ([&server_sockets] (std::shared_ptr const & new_connection, boost::system::error_code const & ec_a) { server_sockets.push_back (new_connection); return true; }); @@ -265,12 +265,12 @@ TEST (socket, max_connections_per_subnetwork) }; // start n clients, n-1 will persist but 1 will be dropped, where n == max_subnetwork_connections - std::vector> client_list; + std::vector> client_list; client_list.reserve (max_subnetwork_connections + 1); for (auto idx = 0; idx < max_subnetwork_connections + 1; ++idx) { - auto client = std::make_shared (*node); + auto client = std::make_shared (*node); client->async_connect (dst_endpoint, connect_handler); client_list.push_back (client); } @@ -308,14 +308,14 @@ TEST (socket, disabled_max_peers_per_ip) const auto max_global_connections = 1000; - auto server_socket = std::make_shared (*node, listen_endpoint, max_global_connections); + auto server_socket = std::make_shared (*node, listen_endpoint, max_global_connections); boost::system::error_code ec; server_socket->start (ec); ASSERT_FALSE (ec); // successful incoming connections are stored in server_sockets to keep them alive (server side) - std::vector> server_sockets; - server_socket->on_connection ([&server_sockets] (std::shared_ptr const & new_connection, boost::system::error_code const & ec_a) { + std::vector> server_sockets; + server_socket->on_connection ([&server_sockets] (std::shared_ptr const & new_connection, boost::system::error_code const & ec_a) { server_sockets.push_back (new_connection); return true; }); @@ -328,12 +328,12 @@ TEST (socket, disabled_max_peers_per_ip) }; // start n clients, n-1 will persist but 1 will be dropped, where n == max_ip_connections - std::vector> client_list; + std::vector> client_list; client_list.reserve (max_ip_connections + 1); for (auto idx = 0; idx < max_ip_connections + 1; ++idx) { - auto client = std::make_shared (*node); + auto client = std::make_shared (*node); client->async_connect (dst_endpoint, connect_handler); client_list.push_back (client); } @@ -371,20 +371,20 @@ TEST (socket, disconnection_of_silent_connections) boost::asio::ip::tcp::endpoint dst_endpoint{ boost::asio::ip::address_v6::loopback (), server_port }; // start a server listening socket - auto server_socket = std::make_shared (*node, listen_endpoint, 1); + auto server_socket = std::make_shared (*node, listen_endpoint, 1); boost::system::error_code ec; server_socket->start (ec); ASSERT_FALSE (ec); // on a connection, a server data socket is created. The shared pointer guarantees the object's lifecycle until the end of this test. - std::shared_ptr server_data_socket; - server_socket->on_connection ([&server_data_socket] (std::shared_ptr const & new_connection, boost::system::error_code const & ec_a) { + std::shared_ptr server_data_socket; + server_socket->on_connection ([&server_data_socket] (std::shared_ptr const & new_connection, boost::system::error_code const & ec_a) { server_data_socket = new_connection; return true; }); // Instantiates a client to simulate an incoming connection. - auto client_socket = std::make_shared (*node); + auto client_socket = std::make_shared (*node); std::atomic connected{ false }; // Opening a connection that will be closed because it remains silent during the tolerance time. client_socket->async_connect (dst_endpoint, [client_socket, &connected] (boost::system::error_code const & ec_a) { @@ -419,24 +419,24 @@ TEST (socket, drop_policy) nano::thread_runner runner (node->io_ctx, 1); - std::vector> connections; + std::vector> connections; - auto func = [&] (size_t total_message_count, nano::buffer_drop_policy drop_policy) { + auto func = [&] (size_t total_message_count, nano::transport::buffer_drop_policy drop_policy) { auto server_port (nano::test::get_available_port ()); boost::asio::ip::tcp::endpoint endpoint (boost::asio::ip::address_v6::any (), server_port); - auto server_socket = std::make_shared (*node, endpoint, 1); + auto server_socket = std::make_shared (*node, endpoint, 1); boost::system::error_code ec; server_socket->start (ec); ASSERT_FALSE (ec); // Accept connection, but don't read so the writer will drop. - server_socket->on_connection ([&connections] (std::shared_ptr const & new_connection, boost::system::error_code const & ec_a) { + server_socket->on_connection ([&connections] (std::shared_ptr const & new_connection, boost::system::error_code const & ec_a) { connections.push_back (new_connection); return true; }); - auto client = std::make_shared (*node); + auto client = std::make_shared (*node); nano::transport::channel_tcp channel{ *node, client }; nano::test::counted_completion write_completion (static_cast (total_message_count)); @@ -459,11 +459,11 @@ TEST (socket, drop_policy) // We're going to write twice the queue size + 1, and the server isn't reading // The total number of drops should thus be 1 (the socket allows doubling the queue size for no_socket_drop) - func (nano::socket::queue_size_max * 2 + 1, nano::buffer_drop_policy::no_socket_drop); + func (nano::transport::socket::queue_size_max * 2 + 1, nano::transport::buffer_drop_policy::no_socket_drop); ASSERT_EQ (1, node->stats.count (nano::stat::type::tcp, nano::stat::detail::tcp_write_no_socket_drop, nano::stat::dir::out)); ASSERT_EQ (0, node->stats.count (nano::stat::type::tcp, nano::stat::detail::tcp_write_drop, nano::stat::dir::out)); - func (nano::socket::queue_size_max + 1, nano::buffer_drop_policy::limiter); + func (nano::transport::socket::queue_size_max + 1, nano::transport::buffer_drop_policy::limiter); // The stats are accumulated from before ASSERT_EQ (1, node->stats.count (nano::stat::type::tcp, nano::stat::detail::tcp_write_no_socket_drop, nano::stat::dir::out)); ASSERT_EQ (1, node->stats.count (nano::stat::type::tcp, nano::stat::detail::tcp_write_drop, nano::stat::dir::out)); @@ -493,7 +493,7 @@ TEST (socket, concurrent_writes) // We're expecting client_count*4 messages nano::test::counted_completion read_count_completion (total_message_count); - std::function const &)> reader = [&read_count_completion, &total_message_count, &reader] (std::shared_ptr const & socket_a) { + std::function const &)> reader = [&read_count_completion, &total_message_count, &reader] (std::shared_ptr const & socket_a) { auto buff (std::make_shared> ()); buff->resize (1); #ifndef _WIN32 @@ -525,14 +525,14 @@ TEST (socket, concurrent_writes) boost::asio::ip::tcp::endpoint endpoint (boost::asio::ip::address_v4::any (), 25000); - auto server_socket = std::make_shared (*node, endpoint, max_connections); + auto server_socket = std::make_shared (*node, endpoint, max_connections); boost::system::error_code ec; server_socket->start (ec); ASSERT_FALSE (ec); - std::vector> connections; + std::vector> connections; // On every new connection, start reading data - server_socket->on_connection ([&connections, &reader] (std::shared_ptr const & new_connection, boost::system::error_code const & ec_a) { + server_socket->on_connection ([&connections, &reader] (std::shared_ptr const & new_connection, boost::system::error_code const & ec_a) { if (ec_a) { std::cerr << "on_connection: " << ec_a.message () << std::endl; @@ -547,10 +547,10 @@ TEST (socket, concurrent_writes) }); nano::test::counted_completion connection_count_completion (client_count); - std::vector> clients; + std::vector> clients; for (unsigned i = 0; i < client_count; i++) { - auto client = std::make_shared (*node); + auto client = std::make_shared (*node); clients.push_back (client); client->async_connect (boost::asio::ip::tcp::endpoint (boost::asio::ip::address_v4::loopback (), 25000), [&connection_count_completion] (boost::system::error_code const & ec_a) { @@ -628,7 +628,7 @@ TEST (socket_timeout, connect) boost::asio::ip::tcp::endpoint endpoint (boost::asio::ip::make_address_v6 ("::ffff:10.255.254.253"), nano::test::get_available_port ()); // create a client socket and try to connect to the IP address that wil not respond - auto socket = std::make_shared (*node); + auto socket = std::make_shared (*node); std::atomic done = false; boost::system::error_code ec; socket->async_connect (endpoint, [&ec, &done] (boost::system::error_code const & ec_a) { @@ -669,7 +669,7 @@ TEST (socket_timeout, read) }); // create a client socket to connect and call async_read, which should time out - auto socket = std::make_shared (*node); + auto socket = std::make_shared (*node); std::atomic done = false; boost::system::error_code ec; socket->async_connect (endpoint, [&socket, &ec, &done] (boost::system::error_code const & ec_a) { @@ -716,7 +716,7 @@ TEST (socket_timeout, write) // create a client socket and send lots of data to fill the socket queue on the local and remote side // eventually, the all tcp queues should fill up and async_write will not be able to progress // and the timeout should kick in and close the socket, which will cause the async_write to return an error - auto socket = std::make_shared (*node); + auto socket = std::make_shared (*node); std::atomic done = false; boost::system::error_code ec; socket->async_connect (endpoint, [&socket, &ec, &done] (boost::system::error_code const & ec_a) { @@ -769,7 +769,7 @@ TEST (socket_timeout, read_overlapped) }); // create a client socket to connect and call async_read twice, the second call should time out - auto socket = std::make_shared (*node); + auto socket = std::make_shared (*node); std::atomic done = false; boost::system::error_code ec; socket->async_connect (endpoint, [&socket, &ec, &done] (boost::system::error_code const & ec_a) { @@ -826,7 +826,7 @@ TEST (socket_timeout, write_overlapped) // create a client socket and send lots of data to fill the socket queue on the local and remote side // eventually, the all tcp queues should fill up and async_write will not be able to progress // and the timeout should kick in and close the socket, which will cause the async_write to return an error - auto socket = std::make_shared (*node); + auto socket = std::make_shared (*node); std::atomic done = false; boost::system::error_code ec; socket->async_connect (endpoint, [&socket, &ec, &done] (boost::system::error_code const & ec_a) { diff --git a/nano/node/CMakeLists.txt b/nano/node/CMakeLists.txt index 29e6b12f6..9f55b8dd1 100644 --- a/nano/node/CMakeLists.txt +++ b/nano/node/CMakeLists.txt @@ -184,8 +184,6 @@ add_library( rocksdb/rocksdb_txn.cpp signatures.hpp signatures.cpp - socket.hpp - socket.cpp state_block_signature_verification.hpp state_block_signature_verification.cpp telemetry.hpp @@ -198,6 +196,8 @@ add_library( transport/inproc.cpp transport/message_deserializer.hpp transport/message_deserializer.cpp + transport/socket.hpp + transport/socket.cpp transport/tcp.hpp transport/tcp.cpp transport/tcp_server.hpp diff --git a/nano/node/blockprocessor.cpp b/nano/node/blockprocessor.cpp index 26dd7fcaa..0f73e7c58 100644 --- a/nano/node/blockprocessor.cpp +++ b/nano/node/blockprocessor.cpp @@ -313,7 +313,7 @@ void nano::block_processor::process_live (nano::transaction const & transaction_ } else if (!node.flags.disable_block_processor_republishing && node.block_arrival.recent (hash_a)) { - node.network.flood_block (block_a, nano::buffer_drop_policy::limiter); + node.network.flood_block (block_a, nano::transport::buffer_drop_policy::limiter); } if (node.websocket.server && node.websocket.server->any_subscriber (nano::websocket::topic::new_unconfirmed_block)) diff --git a/nano/node/bootstrap/block_deserializer.cpp b/nano/node/bootstrap/block_deserializer.cpp index 34b6370cf..6eaaf2904 100644 --- a/nano/node/bootstrap/block_deserializer.cpp +++ b/nano/node/bootstrap/block_deserializer.cpp @@ -1,6 +1,6 @@ #include #include -#include +#include #include nano::bootstrap::block_deserializer::block_deserializer () : @@ -8,7 +8,7 @@ nano::bootstrap::block_deserializer::block_deserializer () : { } -void nano::bootstrap::block_deserializer::read (nano::socket & socket, callback_type const && callback) +void nano::bootstrap::block_deserializer::read (nano::transport::socket & socket, callback_type const && callback) { debug_assert (callback); read_buffer->resize (1); @@ -27,7 +27,7 @@ void nano::bootstrap::block_deserializer::read (nano::socket & socket, callback_ }); } -void nano::bootstrap::block_deserializer::received_type (nano::socket & socket, callback_type const && callback) +void nano::bootstrap::block_deserializer::received_type (nano::transport::socket & socket, callback_type const && callback) { nano::block_type type = static_cast (read_buffer->data ()[0]); if (type == nano::block_type::not_a_block) diff --git a/nano/node/bootstrap/block_deserializer.hpp b/nano/node/bootstrap/block_deserializer.hpp index a7ce9e244..9e53aa790 100644 --- a/nano/node/bootstrap/block_deserializer.hpp +++ b/nano/node/bootstrap/block_deserializer.hpp @@ -8,7 +8,11 @@ namespace nano { class block; -class socket; +namespace transport +{ + class socket; +} + namespace bootstrap { /** @@ -25,14 +29,14 @@ namespace bootstrap * Read a type-prefixed block from 'socket' and pass the result, or an error, to 'callback' * A normal end to series of blocks is a marked by return no error and a nullptr for block. */ - void read (nano::socket & socket, callback_type const && callback); + void read (nano::transport::socket & socket, callback_type const && callback); private: /** * Called by read method on receipt of a block type byte. * The type byte will be in the read_buffer. */ - void received_type (nano::socket & socket, callback_type const && callback); + void received_type (nano::transport::socket & socket, callback_type const && callback); /** * Called by received_type when a block is received, it parses the block and calls the callback. diff --git a/nano/node/bootstrap/bootstrap_bulk_pull.cpp b/nano/node/bootstrap/bootstrap_bulk_pull.cpp index 10f04329d..ffcd38e85 100644 --- a/nano/node/bootstrap/bootstrap_bulk_pull.cpp +++ b/nano/node/bootstrap/bootstrap_bulk_pull.cpp @@ -96,7 +96,7 @@ void nano::bulk_pull_client::request () this_l->connection->node->stats.inc (nano::stat::type::bootstrap, nano::stat::detail::bulk_pull_request_failure, nano::stat::dir::in); } }, - nano::buffer_drop_policy::no_limiter_drop); + nano::transport::buffer_drop_policy::no_limiter_drop); } void nano::bulk_pull_client::throttled_receive_block () @@ -242,7 +242,7 @@ void nano::bulk_pull_account_client::request () this_l->connection->node->stats.inc (nano::stat::type::bootstrap, nano::stat::detail::bulk_pull_error_starting_request, nano::stat::dir::in); } }, - nano::buffer_drop_policy::no_limiter_drop); + nano::transport::buffer_drop_policy::no_limiter_drop); } void nano::bulk_pull_account_client::receive_pending () diff --git a/nano/node/bootstrap/bootstrap_bulk_pull.hpp b/nano/node/bootstrap/bootstrap_bulk_pull.hpp index 35a09f096..b84a18442 100644 --- a/nano/node/bootstrap/bootstrap_bulk_pull.hpp +++ b/nano/node/bootstrap/bootstrap_bulk_pull.hpp @@ -1,7 +1,7 @@ #pragma once #include -#include +#include #include diff --git a/nano/node/bootstrap/bootstrap_bulk_push.cpp b/nano/node/bootstrap/bootstrap_bulk_push.cpp index df52826c7..692a0dc06 100644 --- a/nano/node/bootstrap/bootstrap_bulk_push.cpp +++ b/nano/node/bootstrap/bootstrap_bulk_push.cpp @@ -34,7 +34,7 @@ void nano::bulk_push_client::start () } } }, - nano::buffer_drop_policy::no_limiter_drop); + nano::transport::buffer_drop_policy::no_limiter_drop); } void nano::bulk_push_client::push () diff --git a/nano/node/bootstrap/bootstrap_connections.cpp b/nano/node/bootstrap/bootstrap_connections.cpp index 029c1295a..d87d4bd91 100644 --- a/nano/node/bootstrap/bootstrap_connections.cpp +++ b/nano/node/bootstrap/bootstrap_connections.cpp @@ -16,7 +16,7 @@ constexpr double nano::bootstrap_limits::bootstrap_minimum_termination_time_sec; constexpr unsigned nano::bootstrap_limits::bootstrap_max_new_connections; constexpr unsigned nano::bootstrap_limits::requeued_pulls_processed_blocks_factor; -nano::bootstrap_client::bootstrap_client (std::shared_ptr const & node_a, nano::bootstrap_connections & connections_a, std::shared_ptr const & channel_a, std::shared_ptr const & socket_a) : +nano::bootstrap_client::bootstrap_client (std::shared_ptr const & node_a, nano::bootstrap_connections & connections_a, std::shared_ptr const & channel_a, std::shared_ptr const & socket_a) : node (node_a), connections (connections_a), channel (channel_a), @@ -147,7 +147,7 @@ std::shared_ptr nano::bootstrap_connections::find_connec void nano::bootstrap_connections::connect_client (nano::tcp_endpoint const & endpoint_a, bool push_front) { ++connections_count; - auto socket (std::make_shared (node)); + auto socket (std::make_shared (node)); auto this_l (shared_from_this ()); socket->async_connect (endpoint_a, [this_l, socket, endpoint_a, push_front] (boost::system::error_code const & ec) { diff --git a/nano/node/bootstrap/bootstrap_connections.hpp b/nano/node/bootstrap/bootstrap_connections.hpp index 7a007f968..b5d7e3a45 100644 --- a/nano/node/bootstrap/bootstrap_connections.hpp +++ b/nano/node/bootstrap/bootstrap_connections.hpp @@ -2,7 +2,7 @@ #include #include -#include +#include #include @@ -25,7 +25,7 @@ class pull_info; class bootstrap_client final : public std::enable_shared_from_this { public: - bootstrap_client (std::shared_ptr const & node_a, nano::bootstrap_connections & connections_a, std::shared_ptr const & channel_a, std::shared_ptr const & socket_a); + bootstrap_client (std::shared_ptr const & node_a, nano::bootstrap_connections & connections_a, std::shared_ptr const & channel_a, std::shared_ptr const & socket_a); ~bootstrap_client (); void stop (bool force); double sample_block_rate (); @@ -34,7 +34,7 @@ public: std::shared_ptr node; nano::bootstrap_connections & connections; std::shared_ptr channel; - std::shared_ptr socket; + std::shared_ptr socket; std::shared_ptr> receive_buffer; std::atomic block_count{ 0 }; std::atomic block_rate{ 0 }; diff --git a/nano/node/bootstrap/bootstrap_frontier.cpp b/nano/node/bootstrap/bootstrap_frontier.cpp index 6eba3be47..4066311f1 100644 --- a/nano/node/bootstrap/bootstrap_frontier.cpp +++ b/nano/node/bootstrap/bootstrap_frontier.cpp @@ -38,7 +38,7 @@ void nano::frontier_req_client::run (nano::account const & start_account_a, uint } } }, - nano::buffer_drop_policy::no_limiter_drop); + nano::transport::buffer_drop_policy::no_limiter_drop); } nano::frontier_req_client::frontier_req_client (std::shared_ptr const & connection_a, std::shared_ptr const & attempt_a) : diff --git a/nano/node/bootstrap/bootstrap_server.cpp b/nano/node/bootstrap/bootstrap_server.cpp index d9f60490f..3735a18b9 100644 --- a/nano/node/bootstrap/bootstrap_server.cpp +++ b/nano/node/bootstrap/bootstrap_server.cpp @@ -125,7 +125,7 @@ void nano::bootstrap_server::respond (nano::asc_pull_ack & response, std::shared stats.inc (nano::stat::type::bootstrap_server, nano::stat::detail::write_error, nano::stat::dir::out); } }, - nano::buffer_drop_policy::limiter, nano::bandwidth_limit_type::bootstrap); + nano::transport::buffer_drop_policy::limiter, nano::bandwidth_limit_type::bootstrap); } /* diff --git a/nano/node/confirmation_solicitor.cpp b/nano/node/confirmation_solicitor.cpp index 54e9f1dce..cece99c53 100644 --- a/nano/node/confirmation_solicitor.cpp +++ b/nano/node/confirmation_solicitor.cpp @@ -46,7 +46,7 @@ bool nano::confirmation_solicitor::broadcast (nano::election const & election_a) } } // Random flood for block propagation - network.flood_message (winner, nano::buffer_drop_policy::limiter, 0.5f); + network.flood_message (winner, nano::transport::buffer_drop_policy::limiter, 0.5f); error = false; } return error; diff --git a/nano/node/election.cpp b/nano/node/election.cpp index 20f9c83be..22c3f573b 100644 --- a/nano/node/election.cpp +++ b/nano/node/election.cpp @@ -467,7 +467,7 @@ bool nano::election::publish (std::shared_ptr const & block_a) if (status.winner->hash () == block_a->hash ()) { status.winner = block_a; - node.network.flood_block (block_a, nano::buffer_drop_policy::no_limiter_drop); + node.network.flood_block (block_a, nano::transport::buffer_drop_policy::no_limiter_drop); } } } diff --git a/nano/node/network.cpp b/nano/node/network.cpp index 63940171c..bd1d73f38 100644 --- a/nano/node/network.cpp +++ b/nano/node/network.cpp @@ -129,7 +129,7 @@ void nano::network::send_node_id_handshake (std::shared_ptrsend (message); } -void nano::network::flood_message (nano::message & message_a, nano::buffer_drop_policy const drop_policy_a, float const scale_a) +void nano::network::flood_message (nano::message & message_a, nano::transport::buffer_drop_policy const drop_policy_a, float const scale_a) { for (auto & i : list (fanout (scale_a))) { @@ -141,17 +141,17 @@ void nano::network::flood_keepalive (float const scale_a) { nano::keepalive message{ node.network_params.network }; random_fill (message.peers); - flood_message (message, nano::buffer_drop_policy::limiter, scale_a); + flood_message (message, nano::transport::buffer_drop_policy::limiter, scale_a); } void nano::network::flood_keepalive_self (float const scale_a) { nano::keepalive message{ node.network_params.network }; fill_keepalive_self (message.peers); - flood_message (message, nano::buffer_drop_policy::limiter, scale_a); + flood_message (message, nano::transport::buffer_drop_policy::limiter, scale_a); } -void nano::network::flood_block (std::shared_ptr const & block_a, nano::buffer_drop_policy const drop_policy_a) +void nano::network::flood_block (std::shared_ptr const & block_a, nano::transport::buffer_drop_policy const drop_policy_a) { nano::publish message (node.network_params.network, block_a); flood_message (message, drop_policy_a); @@ -162,11 +162,11 @@ void nano::network::flood_block_initial (std::shared_ptr const & bl nano::publish message (node.network_params.network, block_a); for (auto const & i : node.rep_crawler.principal_representatives ()) { - i.channel->send (message, nullptr, nano::buffer_drop_policy::no_limiter_drop); + i.channel->send (message, nullptr, nano::transport::buffer_drop_policy::no_limiter_drop); } for (auto & i : list_non_pr (fanout (1.0))) { - i->send (message, nullptr, nano::buffer_drop_policy::no_limiter_drop); + i->send (message, nullptr, nano::transport::buffer_drop_policy::no_limiter_drop); } } @@ -184,7 +184,7 @@ void nano::network::flood_vote_pr (std::shared_ptr const & vote_a) nano::confirm_ack message{ node.network_params.network, vote_a }; for (auto const & i : node.rep_crawler.principal_representatives ()) { - i.channel->send (message, nullptr, nano::buffer_drop_policy::no_limiter_drop); + i.channel->send (message, nullptr, nano::transport::buffer_drop_policy::no_limiter_drop); } } @@ -480,7 +480,7 @@ public: auto telemetry_data = node.local_telemetry (); telemetry_ack = nano::telemetry_ack{ node.network_params.network, telemetry_data }; } - channel->send (telemetry_ack, nullptr, nano::buffer_drop_policy::no_socket_drop); + channel->send (telemetry_ack, nullptr, nano::transport::buffer_drop_policy::no_socket_drop); } void telemetry_ack (nano::telemetry_ack const & message_a) override diff --git a/nano/node/network.hpp b/nano/node/network.hpp index dd5051a43..1e3ae65b9 100644 --- a/nano/node/network.hpp +++ b/nano/node/network.hpp @@ -73,7 +73,7 @@ public: nano::networks id; void start (); void stop (); - void flood_message (nano::message &, nano::buffer_drop_policy const = nano::buffer_drop_policy::limiter, float const = 1.0f); + void flood_message (nano::message &, nano::transport::buffer_drop_policy const = nano::transport::buffer_drop_policy::limiter, float const = 1.0f); void flood_keepalive (float const scale_a = 1.0f); void flood_keepalive_self (float const scale_a = 0.5f); void flood_vote (std::shared_ptr const &, float scale); @@ -81,7 +81,7 @@ public: // Flood block to all PRs and a random selection of non-PRs void flood_block_initial (std::shared_ptr const &); // Flood block to a random selection of peers - void flood_block (std::shared_ptr const &, nano::buffer_drop_policy const = nano::buffer_drop_policy::limiter); + void flood_block (std::shared_ptr const &, nano::transport::buffer_drop_policy const = nano::transport::buffer_drop_policy::limiter); void flood_block_many (std::deque>, std::function = nullptr, unsigned = broadcast_interval_ms); void merge_peers (std::array const &); void merge_peer (nano::endpoint const &); diff --git a/nano/node/node_observers.hpp b/nano/node/node_observers.hpp index d597cb990..5526c957c 100644 --- a/nano/node/node_observers.hpp +++ b/nano/node/node_observers.hpp @@ -23,8 +23,8 @@ public: nano::observer_set work_cancel; nano::observer_set const &> telemetry; - nano::observer_set socket_connected; - nano::observer_set socket_accepted; + nano::observer_set socket_connected; + nano::observer_set socket_accepted; }; std::unique_ptr collect_container_info (node_observers & node_observers, std::string const & name); diff --git a/nano/node/transport/channel.cpp b/nano/node/transport/channel.cpp index 82566208c..9d7dcf2da 100644 --- a/nano/node/transport/channel.cpp +++ b/nano/node/transport/channel.cpp @@ -14,11 +14,11 @@ nano::transport::channel::channel (nano::node & node_a) : set_network_version (node_a.network_params.network.protocol_version); } -void nano::transport::channel::send (nano::message & message_a, std::function const & callback_a, nano::buffer_drop_policy drop_policy_a, nano::bandwidth_limit_type limiter_type) +void nano::transport::channel::send (nano::message & message_a, std::function const & callback_a, nano::transport::buffer_drop_policy drop_policy_a, nano::bandwidth_limit_type limiter_type) { auto buffer (message_a.to_shared_const_buffer ()); auto detail = nano::to_stat_detail (message_a.header.type); - auto is_droppable_by_limiter = drop_policy_a == nano::buffer_drop_policy::limiter; + auto is_droppable_by_limiter = (drop_policy_a == nano::transport::buffer_drop_policy::limiter); auto should_pass (node.outbound_limiter.should_pass (buffer.size (), limiter_type)); if (!is_droppable_by_limiter || should_pass) { diff --git a/nano/node/transport/channel.hpp b/nano/node/transport/channel.hpp index 162870949..4973e6f8f 100644 --- a/nano/node/transport/channel.hpp +++ b/nano/node/transport/channel.hpp @@ -5,7 +5,7 @@ #include #include #include -#include +#include #include @@ -27,10 +27,10 @@ public: virtual std::size_t hash_code () const = 0; virtual bool operator== (nano::transport::channel const &) const = 0; - void send (nano::message & message_a, std::function const & callback_a = nullptr, nano::buffer_drop_policy policy_a = nano::buffer_drop_policy::limiter, nano::bandwidth_limit_type = nano::bandwidth_limit_type::standard); + void send (nano::message & message_a, std::function const & callback_a = nullptr, nano::transport::buffer_drop_policy policy_a = nano::transport::buffer_drop_policy::limiter, nano::bandwidth_limit_type = nano::bandwidth_limit_type::standard); // TODO: investigate clang-tidy warning about default parameters on virtual/override functions // - virtual void send_buffer (nano::shared_const_buffer const &, std::function const & = nullptr, nano::buffer_drop_policy = nano::buffer_drop_policy::limiter) = 0; + virtual void send_buffer (nano::shared_const_buffer const &, std::function const & = nullptr, nano::transport::buffer_drop_policy = nano::transport::buffer_drop_policy::limiter) = 0; virtual std::string to_string () const = 0; virtual nano::endpoint get_endpoint () const = 0; virtual nano::tcp_endpoint get_tcp_endpoint () const = 0; diff --git a/nano/node/transport/fake.cpp b/nano/node/transport/fake.cpp index f51a7de43..2e5cc67f0 100644 --- a/nano/node/transport/fake.cpp +++ b/nano/node/transport/fake.cpp @@ -14,7 +14,7 @@ nano::transport::fake::channel::channel (nano::node & node) : /** * The send function behaves like a null device, it throws the data away and returns success. */ -void nano::transport::fake::channel::send_buffer (nano::shared_const_buffer const & buffer_a, std::function const & callback_a, nano::buffer_drop_policy drop_policy_a) +void nano::transport::fake::channel::send_buffer (nano::shared_const_buffer const & buffer_a, std::function const & callback_a, nano::transport::buffer_drop_policy drop_policy_a) { //auto bytes = buffer_a.to_bytes (); auto size = buffer_a.size (); diff --git a/nano/node/transport/fake.hpp b/nano/node/transport/fake.hpp index 5ee6f929b..d03b14a46 100644 --- a/nano/node/transport/fake.hpp +++ b/nano/node/transport/fake.hpp @@ -24,7 +24,7 @@ namespace transport void send_buffer ( nano::shared_const_buffer const &, std::function const & = nullptr, - nano::buffer_drop_policy = nano::buffer_drop_policy::limiter + nano::transport::buffer_drop_policy = nano::transport::buffer_drop_policy::limiter ) override; // clang-format on diff --git a/nano/node/transport/inproc.cpp b/nano/node/transport/inproc.cpp index bd4c28670..346f4c9f7 100644 --- a/nano/node/transport/inproc.cpp +++ b/nano/node/transport/inproc.cpp @@ -51,7 +51,7 @@ public: * Send the buffer to the peer and call the callback function when done. The call never fails. * Note that the inbound message visitor will be called before the callback because it is called directly whereas the callback is spawned in the background. */ -void nano::transport::inproc::channel::send_buffer (nano::shared_const_buffer const & buffer_a, std::function const & callback_a, nano::buffer_drop_policy drop_policy_a) +void nano::transport::inproc::channel::send_buffer (nano::shared_const_buffer const & buffer_a, std::function const & callback_a, nano::transport::buffer_drop_policy drop_policy_a) { // we create a temporary channel for the reply path, in case the receiver of the message wants to reply auto remote_channel = std::make_shared (destination, node); diff --git a/nano/node/transport/inproc.hpp b/nano/node/transport/inproc.hpp index a64be0a64..443995ecb 100644 --- a/nano/node/transport/inproc.hpp +++ b/nano/node/transport/inproc.hpp @@ -20,7 +20,7 @@ namespace transport bool operator== (nano::transport::channel const &) const override; // TODO: investigate clang-tidy warning about default parameters on virtual/override functions // - void send_buffer (nano::shared_const_buffer const &, std::function const & = nullptr, nano::buffer_drop_policy = nano::buffer_drop_policy::limiter) override; + void send_buffer (nano::shared_const_buffer const &, std::function const & = nullptr, nano::transport::buffer_drop_policy = nano::transport::buffer_drop_policy::limiter) override; std::string to_string () const override; bool operator== (nano::transport::inproc::channel const & other_a) const { diff --git a/nano/node/transport/message_deserializer.cpp b/nano/node/transport/message_deserializer.cpp index 2874efe05..e465e89ad 100644 --- a/nano/node/transport/message_deserializer.cpp +++ b/nano/node/transport/message_deserializer.cpp @@ -11,7 +11,7 @@ nano::transport::message_deserializer::message_deserializer (nano::network_const read_buffer->resize (MAX_MESSAGE_SIZE); } -void nano::transport::message_deserializer::read (std::shared_ptr socket, const nano::transport::message_deserializer::callback_type && callback) +void nano::transport::message_deserializer::read (std::shared_ptr socket, const nano::transport::message_deserializer::callback_type && callback) { debug_assert (callback); @@ -40,7 +40,7 @@ void nano::transport::message_deserializer::read (std::shared_ptr }); } -void nano::transport::message_deserializer::received_header (std::shared_ptr socket, const nano::transport::message_deserializer::callback_type && callback) +void nano::transport::message_deserializer::received_header (std::shared_ptr socket, const nano::transport::message_deserializer::callback_type && callback) { nano::bufferstream stream{ read_buffer->data (), HEADER_SIZE }; auto error = false; diff --git a/nano/node/transport/message_deserializer.hpp b/nano/node/transport/message_deserializer.hpp index 0ca6f0a2c..331024b5f 100644 --- a/nano/node/transport/message_deserializer.hpp +++ b/nano/node/transport/message_deserializer.hpp @@ -2,7 +2,7 @@ #include #include -#include +#include #include #include @@ -54,10 +54,10 @@ namespace transport * If message is received successfully, error code won't be set and message will be non-null. `status` field will be set to `success`. * Should not be called until the previous invocation finishes and calls the callback. */ - void read (std::shared_ptr socket, callback_type const && callback); + void read (std::shared_ptr socket, callback_type const && callback); private: - void received_header (std::shared_ptr socket, callback_type const && callback); + void received_header (std::shared_ptr socket, callback_type const && callback); void received_message (nano::message_header header, std::size_t payload_size, callback_type const && callback); /* diff --git a/nano/node/socket.cpp b/nano/node/transport/socket.cpp similarity index 79% rename from nano/node/socket.cpp rename to nano/node/transport/socket.cpp index 5b0643ac1..9ebb1eb15 100644 --- a/nano/node/socket.cpp +++ b/nano/node/transport/socket.cpp @@ -2,7 +2,7 @@ #include #include #include -#include +#include #include #include @@ -32,7 +32,7 @@ bool is_temporary_error (boost::system::error_code const & ec_a) } } -nano::socket::socket (nano::node & node_a, endpoint_type_t endpoint_type_a) : +nano::transport::socket::socket (nano::node & node_a, endpoint_type_t endpoint_type_a) : strand{ node_a.io_ctx.get_executor () }, tcp_socket{ node_a.io_ctx }, node{ node_a }, @@ -45,12 +45,12 @@ nano::socket::socket (nano::node & node_a, endpoint_type_t endpoint_type_a) : { } -nano::socket::~socket () +nano::transport::socket::~socket () { close_internal (); } -void nano::socket::async_connect (nano::tcp_endpoint const & endpoint_a, std::function callback_a) +void nano::transport::socket::async_connect (nano::tcp_endpoint const & endpoint_a, std::function callback_a) { debug_assert (callback_a); debug_assert (endpoint_type () == endpoint_type_t::client); @@ -77,7 +77,7 @@ void nano::socket::async_connect (nano::tcp_endpoint const & endpoint_a, std::fu })); } -void nano::socket::async_read (std::shared_ptr> const & buffer_a, std::size_t size_a, std::function callback_a) +void nano::transport::socket::async_read (std::shared_ptr> const & buffer_a, std::size_t size_a, std::function callback_a) { debug_assert (callback_a); @@ -109,13 +109,13 @@ void nano::socket::async_read (std::shared_ptr> const & buf } else { - debug_assert (false && "nano::socket::async_read called with incorrect buffer size"); + debug_assert (false && "nano::transport::socket::async_read called with incorrect buffer size"); boost::system::error_code ec_buffer = boost::system::errc::make_error_code (boost::system::errc::no_buffer_space); callback_a (ec_buffer, 0); } } -void nano::socket::async_write (nano::shared_const_buffer const & buffer_a, std::function callback_a) +void nano::transport::socket::async_write (nano::shared_const_buffer const & buffer_a, std::function callback_a) { if (closed) { @@ -169,7 +169,7 @@ void nano::socket::async_write (nano::shared_const_buffer const & buffer_a, std: } /** Call set_timeout with default_timeout as parameter */ -void nano::socket::set_default_timeout () +void nano::transport::socket::set_default_timeout () { set_timeout (default_timeout); } @@ -180,24 +180,24 @@ void nano::socket::set_default_timeout () * to set infinite timeout, use std::numeric_limits::max () * the function checkup() checks for timeout on a regular interval */ -void nano::socket::set_timeout (std::chrono::seconds timeout_a) +void nano::transport::socket::set_timeout (std::chrono::seconds timeout_a) { timeout = timeout_a.count (); } -void nano::socket::set_last_completion () +void nano::transport::socket::set_last_completion () { last_completion_time_or_init = nano::seconds_since_epoch (); } -void nano::socket::set_last_receive_time () +void nano::transport::socket::set_last_receive_time () { last_receive_time_or_init = nano::seconds_since_epoch (); } -void nano::socket::checkup () +void nano::transport::socket::checkup () { - std::weak_ptr this_w (shared_from_this ()); + std::weak_ptr this_w (shared_from_this ()); node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (node.network_params.network.is_dev_network () ? 1 : 5), [this_w] () { if (auto this_l = this_w.lock ()) { @@ -243,22 +243,22 @@ void nano::socket::checkup () }); } -bool nano::socket::has_timed_out () const +bool nano::transport::socket::has_timed_out () const { return timed_out; } -void nano::socket::set_default_timeout_value (std::chrono::seconds timeout_a) +void nano::transport::socket::set_default_timeout_value (std::chrono::seconds timeout_a) { default_timeout = timeout_a; } -std::chrono::seconds nano::socket::get_default_timeout_value () const +std::chrono::seconds nano::transport::socket::get_default_timeout_value () const { return default_timeout; } -void nano::socket::set_silent_connection_tolerance_time (std::chrono::seconds tolerance_time_a) +void nano::transport::socket::set_silent_connection_tolerance_time (std::chrono::seconds tolerance_time_a) { auto this_l (shared_from_this ()); boost::asio::dispatch (strand, boost::asio::bind_executor (strand, [this_l, tolerance_time_a] () { @@ -266,7 +266,7 @@ void nano::socket::set_silent_connection_tolerance_time (std::chrono::seconds to })); } -void nano::socket::close () +void nano::transport::socket::close () { auto this_l (shared_from_this ()); boost::asio::dispatch (strand, boost::asio::bind_executor (strand, [this_l] { @@ -275,7 +275,7 @@ void nano::socket::close () } // This must be called from a strand or the destructor -void nano::socket::close_internal () +void nano::transport::socket::close_internal () { if (!closed.exchange (true)) { @@ -293,17 +293,17 @@ void nano::socket::close_internal () } } -nano::tcp_endpoint nano::socket::remote_endpoint () const +nano::tcp_endpoint nano::transport::socket::remote_endpoint () const { return remote; } -nano::tcp_endpoint nano::socket::local_endpoint () const +nano::tcp_endpoint nano::transport::socket::local_endpoint () const { return tcp_socket.local_endpoint (); } -nano::server_socket::server_socket (nano::node & node_a, boost::asio::ip::tcp::endpoint local_a, std::size_t max_connections_a) : +nano::transport::server_socket::server_socket (nano::node & node_a, boost::asio::ip::tcp::endpoint local_a, std::size_t max_connections_a) : socket{ node_a, endpoint_type_t::server }, acceptor{ node_a.io_ctx }, local{ std::move (local_a) }, @@ -312,7 +312,7 @@ nano::server_socket::server_socket (nano::node & node_a, boost::asio::ip::tcp::e default_timeout = std::chrono::seconds::max (); } -void nano::server_socket::start (boost::system::error_code & ec_a) +void nano::transport::server_socket::start (boost::system::error_code & ec_a) { acceptor.open (local.protocol ()); acceptor.set_option (boost::asio::ip::tcp::acceptor::reuse_address (true)); @@ -323,9 +323,9 @@ void nano::server_socket::start (boost::system::error_code & ec_a) } } -void nano::server_socket::close () +void nano::transport::server_socket::close () { - auto this_l (std::static_pointer_cast (shared_from_this ())); + auto this_l (std::static_pointer_cast (shared_from_this ())); boost::asio::dispatch (strand, boost::asio::bind_executor (strand, [this_l] () { this_l->close_internal (); @@ -341,27 +341,27 @@ void nano::server_socket::close () })); } -boost::asio::ip::network_v6 nano::socket_functions::get_ipv6_subnet_address (boost::asio::ip::address_v6 const & ip_address, size_t network_prefix) +boost::asio::ip::network_v6 nano::transport::socket_functions::get_ipv6_subnet_address (boost::asio::ip::address_v6 const & ip_address, size_t network_prefix) { return boost::asio::ip::make_network_v6 (ip_address, network_prefix); } -boost::asio::ip::address nano::socket_functions::first_ipv6_subnet_address (boost::asio::ip::address_v6 const & ip_address, size_t network_prefix) +boost::asio::ip::address nano::transport::socket_functions::first_ipv6_subnet_address (boost::asio::ip::address_v6 const & ip_address, size_t network_prefix) { auto range = get_ipv6_subnet_address (ip_address, network_prefix).hosts (); debug_assert (!range.empty ()); return *(range.begin ()); } -boost::asio::ip::address nano::socket_functions::last_ipv6_subnet_address (boost::asio::ip::address_v6 const & ip_address, size_t network_prefix) +boost::asio::ip::address nano::transport::socket_functions::last_ipv6_subnet_address (boost::asio::ip::address_v6 const & ip_address, size_t network_prefix) { auto range = get_ipv6_subnet_address (ip_address, network_prefix).hosts (); debug_assert (!range.empty ()); return *(--range.end ()); } -size_t nano::socket_functions::count_subnetwork_connections ( -nano::address_socket_mmap const & per_address_connections, +size_t nano::transport::socket_functions::count_subnetwork_connections ( +nano::transport::address_socket_mmap const & per_address_connections, boost::asio::ip::address_v6 const & remote_address, size_t network_prefix) { @@ -376,7 +376,7 @@ size_t network_prefix) return counted_connections; } -bool nano::server_socket::limit_reached_for_incoming_subnetwork_connections (std::shared_ptr const & new_connection) +bool nano::transport::server_socket::limit_reached_for_incoming_subnetwork_connections (std::shared_ptr const & new_connection) { debug_assert (strand.running_in_this_thread ()); if (node.flags.disable_max_peers_per_subnetwork || nano::transport::is_ipv4_or_v4_mapped_address (new_connection->remote.address ())) @@ -392,7 +392,7 @@ bool nano::server_socket::limit_reached_for_incoming_subnetwork_connections (std return counted_connections >= node.network_params.network.max_peers_per_subnetwork; } -bool nano::server_socket::limit_reached_for_incoming_ip_connections (std::shared_ptr const & new_connection) +bool nano::transport::server_socket::limit_reached_for_incoming_ip_connections (std::shared_ptr const & new_connection) { debug_assert (strand.running_in_this_thread ()); if (node.flags.disable_max_peers_per_ip) @@ -405,9 +405,9 @@ bool nano::server_socket::limit_reached_for_incoming_ip_connections (std::shared return counted_connections >= node.network_params.network.max_peers_per_ip; } -void nano::server_socket::on_connection (std::function const &, boost::system::error_code const &)> callback_a) +void nano::transport::server_socket::on_connection (std::function const &, boost::system::error_code const &)> callback_a) { - auto this_l (std::static_pointer_cast (shared_from_this ())); + auto this_l (std::static_pointer_cast (shared_from_this ())); boost::asio::post (strand, boost::asio::bind_executor (strand, [this_l, callback = std::move (callback_a)] () mutable { if (!this_l->acceptor.is_open ()) @@ -417,7 +417,7 @@ void nano::server_socket::on_connection (std::function (this_l->node, endpoint_type_t::server); + auto new_connection = std::make_shared (this_l->node, endpoint_type_t::server); this_l->acceptor.async_accept (new_connection->tcp_socket, new_connection->remote, boost::asio::bind_executor (this_l->strand, [this_l, new_connection, cbk = std::move (callback)] (boost::system::error_code const & ec_a) mutable { @@ -503,16 +503,16 @@ void nano::server_socket::on_connection (std::function const &, boost::system::error_code const &)> callback_a) +void nano::transport::server_socket::on_connection_requeue_delayed (std::function const &, boost::system::error_code const &)> callback_a) { - auto this_l (std::static_pointer_cast (shared_from_this ())); + auto this_l (std::static_pointer_cast (shared_from_this ())); node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::milliseconds (1), [this_l, callback = std::move (callback_a)] () mutable { this_l->on_connection (std::move (callback)); }); } // This must be called from a strand -void nano::server_socket::evict_dead_connections () +void nano::transport::server_socket::evict_dead_connections () { debug_assert (strand.running_in_this_thread ()); for (auto it = connections_per_address.begin (); it != connections_per_address.end ();) @@ -526,17 +526,17 @@ void nano::server_socket::evict_dead_connections () } } -std::string nano::socket_type_to_string (nano::socket::type_t type) +std::string nano::transport::socket_type_to_string (nano::transport::socket::type_t type) { switch (type) { - case nano::socket::type_t::undefined: + case nano::transport::socket::type_t::undefined: return "undefined"; - case nano::socket::type_t::bootstrap: + case nano::transport::socket::type_t::bootstrap: return "bootstrap"; - case nano::socket::type_t::realtime: + case nano::transport::socket::type_t::realtime: return "realtime"; - case nano::socket::type_t::realtime_response_server: + case nano::transport::socket::type_t::realtime_response_server: return "realtime_response_server"; } return "n/a"; diff --git a/nano/node/socket.hpp b/nano/node/transport/socket.hpp similarity index 89% rename from nano/node/socket.hpp rename to nano/node/transport/socket.hpp index 213b0ad6d..e2676d560 100644 --- a/nano/node/socket.hpp +++ b/nano/node/transport/socket.hpp @@ -16,6 +16,11 @@ class network_v6; namespace nano { +class node; +} + +namespace nano::transport +{ /** Policy to affect at which stage a buffer can be dropped */ enum class buffer_drop_policy { @@ -27,11 +32,10 @@ enum class buffer_drop_policy no_socket_drop }; -class node; class server_socket; /** Socket class for tcp clients and newly accepted connections */ -class socket : public std::enable_shared_from_this +class socket : public std::enable_shared_from_this { friend class server_socket; @@ -57,6 +61,7 @@ public: */ explicit socket (nano::node & node, endpoint_type_t endpoint_type_a); virtual ~socket (); + void async_connect (boost::asio::ip::tcp::endpoint const &, std::function); void async_read (std::shared_ptr> const &, std::size_t, std::function); void async_write (nano::shared_const_buffer const &, std::function = {}); @@ -93,11 +98,11 @@ public: } bool is_realtime_connection () const { - return type () == nano::socket::type_t::realtime || type () == nano::socket::type_t::realtime_response_server; + return type () == nano::transport::socket::type_t::realtime || type () == nano::transport::socket::type_t::realtime_response_server; } bool is_bootstrap_connection () const { - return type () == nano::socket::type_t::bootstrap; + return type () == nano::transport::socket::type_t::bootstrap; } bool is_closed () const { @@ -184,7 +189,7 @@ namespace socket_functions boost::asio::ip::network_v6 get_ipv6_subnet_address (boost::asio::ip::address_v6 const &, size_t); boost::asio::ip::address first_ipv6_subnet_address (boost::asio::ip::address_v6 const &, size_t); boost::asio::ip::address last_ipv6_subnet_address (boost::asio::ip::address_v6 const &, size_t); - size_t count_subnetwork_connections (nano::address_socket_mmap const &, boost::asio::ip::address_v6 const &, size_t); + size_t count_subnetwork_connections (nano::transport::address_socket_mmap const &, boost::asio::ip::address_v6 const &, size_t); } /** Socket class for TCP servers */ @@ -203,22 +208,22 @@ public: /** Stop accepting new connections */ void close () override; /** Register callback for new connections. The callback must return true to keep accepting new connections. */ - void on_connection (std::function const & new_connection, boost::system::error_code const &)>); + void on_connection (std::function const & new_connection, boost::system::error_code const &)>); uint16_t listening_port () { return acceptor.local_endpoint ().port (); } private: - nano::address_socket_mmap connections_per_address; + nano::transport::address_socket_mmap connections_per_address; boost::asio::ip::tcp::acceptor acceptor; boost::asio::ip::tcp::endpoint local; std::size_t max_inbound_connections; void evict_dead_connections (); - void on_connection_requeue_delayed (std::function const & new_connection, boost::system::error_code const &)>); + void on_connection_requeue_delayed (std::function const & new_connection, boost::system::error_code const &)>); /** Checks whether the maximum number of connections per IP was reached. If so, it returns true. */ - bool limit_reached_for_incoming_ip_connections (std::shared_ptr const & new_connection); - bool limit_reached_for_incoming_subnetwork_connections (std::shared_ptr const & new_connection); + bool limit_reached_for_incoming_ip_connections (std::shared_ptr const & new_connection); + bool limit_reached_for_incoming_subnetwork_connections (std::shared_ptr const & new_connection); }; /** Socket class for TCP clients */ diff --git a/nano/node/transport/tcp.cpp b/nano/node/transport/tcp.cpp index bb5ff3526..ae5ba5f10 100644 --- a/nano/node/transport/tcp.cpp +++ b/nano/node/transport/tcp.cpp @@ -8,7 +8,7 @@ * channel_tcp */ -nano::transport::channel_tcp::channel_tcp (nano::node & node_a, std::weak_ptr socket_a) : +nano::transport::channel_tcp::channel_tcp (nano::node & node_a, std::weak_ptr socket_a) : channel (node_a), socket (std::move (socket_a)) { @@ -44,11 +44,11 @@ bool nano::transport::channel_tcp::operator== (nano::transport::channel const & return result; } -void nano::transport::channel_tcp::send_buffer (nano::shared_const_buffer const & buffer_a, std::function const & callback_a, nano::buffer_drop_policy policy_a) +void nano::transport::channel_tcp::send_buffer (nano::shared_const_buffer const & buffer_a, std::function const & callback_a, nano::transport::buffer_drop_policy policy_a) { if (auto socket_l = socket.lock ()) { - if (!socket_l->max () || (policy_a == nano::buffer_drop_policy::no_socket_drop && !socket_l->full ())) + if (!socket_l->max () || (policy_a == nano::transport::buffer_drop_policy::no_socket_drop && !socket_l->full ())) { socket_l->async_write ( buffer_a, [endpoint_a = socket_l->remote_endpoint (), node = std::weak_ptr (node.shared ()), callback_a] (boost::system::error_code const & ec, std::size_t size_a) { @@ -71,7 +71,7 @@ void nano::transport::channel_tcp::send_buffer (nano::shared_const_buffer const } else { - if (policy_a == nano::buffer_drop_policy::no_socket_drop) + if (policy_a == nano::transport::buffer_drop_policy::no_socket_drop) { node.stats.inc (nano::stat::type::tcp, nano::stat::detail::tcp_write_no_socket_drop, nano::stat::dir::out); } @@ -119,7 +119,7 @@ nano::transport::tcp_channels::tcp_channels (nano::node & node, std::function const & channel_a, std::shared_ptr const & socket_a, std::shared_ptr const & server_a) +bool nano::transport::tcp_channels::insert (std::shared_ptr const & channel_a, std::shared_ptr const & socket_a, std::shared_ptr const & server_a) { auto endpoint (channel_a->get_tcp_endpoint ()); debug_assert (endpoint.address ().is_v6 ()); @@ -287,7 +287,7 @@ void nano::transport::tcp_channels::process_messages () } } -void nano::transport::tcp_channels::process_message (nano::message const & message_a, nano::tcp_endpoint const & endpoint_a, nano::account const & node_id_a, std::shared_ptr const & socket_a) +void nano::transport::tcp_channels::process_message (nano::message const & message_a, nano::tcp_endpoint const & endpoint_a, nano::account const & node_id_a, std::shared_ptr const & socket_a) { auto type_a = socket_a->type (); if (!stopped && message_a.header.version_using >= node.network_params.network.protocol_version_min) @@ -315,9 +315,9 @@ void nano::transport::tcp_channels::process_message (nano::message const & messa temporary_channel->set_node_id (node_id_a); temporary_channel->set_network_version (message_a.header.version_using); temporary_channel->temporary = true; - debug_assert (type_a == nano::socket::type_t::realtime || type_a == nano::socket::type_t::realtime_response_server); + debug_assert (type_a == nano::transport::socket::type_t::realtime || type_a == nano::transport::socket::type_t::realtime_response_server); // Don't insert temporary channels for response_server - if (type_a == nano::socket::type_t::realtime) + if (type_a == nano::transport::socket::type_t::realtime) { insert (temporary_channel, socket_a, nullptr); } @@ -534,8 +534,8 @@ void nano::transport::tcp_channels::update (nano::tcp_endpoint const & endpoint_ void nano::transport::tcp_channels::start_tcp (nano::endpoint const & endpoint_a) { - auto socket = std::make_shared (node); - std::weak_ptr socket_w (socket); + auto socket = std::make_shared (node); + std::weak_ptr socket_w (socket); auto channel (std::make_shared (node, socket_w)); std::weak_ptr node_w (node.shared ()); socket->async_connect (nano::transport::map_endpoint_to_tcp (endpoint_a), @@ -717,7 +717,7 @@ void nano::transport::tcp_channels::start_tcp_receive_node_id (std::shared_ptr (socket_l, node_l); node_l->network.tcp_channels.insert (channel_a, socket_l, response_server); // Listen for possible responses - response_server->socket->type_set (nano::socket::type_t::realtime_response_server); + response_server->socket->type_set (nano::transport::socket::type_t::realtime_response_server); response_server->remote_node_id = channel_a->get_node_id (); response_server->start (); }); diff --git a/nano/node/transport/tcp.hpp b/nano/node/transport/tcp.hpp index 11f703745..5d277a871 100644 --- a/nano/node/transport/tcp.hpp +++ b/nano/node/transport/tcp.hpp @@ -23,7 +23,7 @@ public: std::shared_ptr message; nano::tcp_endpoint endpoint; nano::account node_id; - std::shared_ptr socket; + std::shared_ptr socket; }; namespace transport { @@ -35,19 +35,19 @@ namespace transport friend class nano::transport::tcp_channels; public: - channel_tcp (nano::node &, std::weak_ptr); + channel_tcp (nano::node &, std::weak_ptr); ~channel_tcp () override; std::size_t hash_code () const override; bool operator== (nano::transport::channel const &) const override; // TODO: investigate clang-tidy warning about default parameters on virtual/override functions // - void send_buffer (nano::shared_const_buffer const &, std::function const & = nullptr, nano::buffer_drop_policy = nano::buffer_drop_policy::limiter) override; + void send_buffer (nano::shared_const_buffer const &, std::function const & = nullptr, nano::transport::buffer_drop_policy = nano::transport::buffer_drop_policy::limiter) override; std::string to_string () const override; bool operator== (nano::transport::channel_tcp const & other_a) const { return &node == &other_a.node && socket.lock () == other_a.socket.lock (); } - std::weak_ptr socket; + std::weak_ptr socket; /* Mark for temporary channels. Usually remote ports of these channels are ephemeral and received from incoming connections to server. If remote part has open listening port, temporary channel will be replaced with direct connection to listening port soon. But if other side is behing NAT or firewall this connection can be pemanent. */ std::atomic temporary{ false }; @@ -99,7 +99,7 @@ namespace transport public: explicit tcp_channels (nano::node &, std::function const &)> = nullptr); - bool insert (std::shared_ptr const &, std::shared_ptr const &, std::shared_ptr const &); + bool insert (std::shared_ptr const &, std::shared_ptr const &, std::shared_ptr const &); void erase (nano::tcp_endpoint const &); std::size_t size () const; std::shared_ptr find_channel (nano::tcp_endpoint const &) const; @@ -113,7 +113,7 @@ namespace transport void start (); void stop (); void process_messages (); - void process_message (nano::message const &, nano::tcp_endpoint const &, nano::account const &, std::shared_ptr const &); + void process_message (nano::message const &, nano::tcp_endpoint const &, nano::account const &, std::shared_ptr const &); bool max_ip_connections (nano::tcp_endpoint const & endpoint_a); bool max_subnetwork_connections (nano::tcp_endpoint const & endpoint_a); bool max_ip_or_subnetwork_connections (nano::tcp_endpoint const & endpoint_a); @@ -164,9 +164,9 @@ namespace transport { public: std::shared_ptr channel; - std::shared_ptr socket; + std::shared_ptr socket; std::shared_ptr response_server; - channel_tcp_wrapper (std::shared_ptr channel_a, std::shared_ptr socket_a, std::shared_ptr server_a) : + channel_tcp_wrapper (std::shared_ptr channel_a, std::shared_ptr socket_a, std::shared_ptr server_a) : channel (std::move (channel_a)), socket (std::move (socket_a)), response_server (std::move (server_a)) { } diff --git a/nano/node/transport/tcp_server.cpp b/nano/node/transport/tcp_server.cpp index bee85cc1f..fe1c06900 100644 --- a/nano/node/transport/tcp_server.cpp +++ b/nano/node/transport/tcp_server.cpp @@ -18,7 +18,7 @@ void nano::transport::tcp_listener::start () { nano::lock_guard lock{ mutex }; on = true; - listening_socket = std::make_shared (node, boost::asio::ip::tcp::endpoint (boost::asio::ip::address_v6::any (), port), node.config.tcp_incoming_connections_max); + listening_socket = std::make_shared (node, boost::asio::ip::tcp::endpoint (boost::asio::ip::address_v6::any (), port), node.config.tcp_incoming_connections_max); boost::system::error_code ec; listening_socket->start (ec); if (ec) @@ -50,7 +50,7 @@ void nano::transport::tcp_listener::start () } } - listening_socket->on_connection ([this] (std::shared_ptr const & new_connection, boost::system::error_code const & ec_a) { + listening_socket->on_connection ([this] (std::shared_ptr const & new_connection, boost::system::error_code const & ec_a) { if (!ec_a) { accept_action (ec_a, new_connection); @@ -81,7 +81,7 @@ std::size_t nano::transport::tcp_listener::connection_count () return connections.size (); } -void nano::transport::tcp_listener::accept_action (boost::system::error_code const & ec, std::shared_ptr const & socket_a) +void nano::transport::tcp_listener::accept_action (boost::system::error_code const & ec, std::shared_ptr const & socket_a) { if (!node.network.excluded_peers.check (socket_a->remote_endpoint ())) { @@ -121,7 +121,7 @@ std::unique_ptr nano::transport::collect_contain return composite; } -nano::transport::tcp_server::tcp_server (std::shared_ptr socket_a, std::shared_ptr node_a, bool allow_bootstrap_a) : +nano::transport::tcp_server::tcp_server (std::shared_ptr socket_a, std::shared_ptr node_a, bool allow_bootstrap_a) : socket{ std::move (socket_a) }, node{ std::move (node_a) }, allow_bootstrap{ allow_bootstrap_a }, @@ -137,11 +137,11 @@ nano::transport::tcp_server::~tcp_server () node->logger.try_log ("Exiting incoming TCP/bootstrap server"); } - if (socket->type () == nano::socket::type_t::bootstrap) + if (socket->type () == nano::transport::socket::type_t::bootstrap) { --node->tcp_listener.bootstrap_count; } - else if (socket->type () == nano::socket::type_t::realtime) + else if (socket->type () == nano::transport::socket::type_t::realtime) { --node->tcp_listener.realtime_count; @@ -570,23 +570,23 @@ bool nano::transport::tcp_server::to_bootstrap_connection () { return false; } - if (socket->type () != nano::socket::type_t::undefined) + if (socket->type () != nano::transport::socket::type_t::undefined) { return false; } ++node->tcp_listener.bootstrap_count; - socket->type_set (nano::socket::type_t::bootstrap); + socket->type_set (nano::transport::socket::type_t::bootstrap); return true; } bool nano::transport::tcp_server::to_realtime_connection (nano::account const & node_id) { - if (socket->type () == nano::socket::type_t::undefined && !node->flags.disable_tcp_realtime) + if (socket->type () == nano::transport::socket::type_t::undefined && !node->flags.disable_tcp_realtime) { remote_node_id = node_id; ++node->tcp_listener.realtime_count; - socket->type_set (nano::socket::type_t::realtime); + socket->type_set (nano::transport::socket::type_t::realtime); return true; } return false; @@ -594,7 +594,7 @@ bool nano::transport::tcp_server::to_realtime_connection (nano::account const & bool nano::transport::tcp_server::is_undefined_connection () const { - return socket->type () == nano::socket::type_t::undefined; + return socket->type () == nano::transport::socket::type_t::undefined; } bool nano::transport::tcp_server::is_bootstrap_connection () const diff --git a/nano/node/transport/tcp_server.hpp b/nano/node/transport/tcp_server.hpp index 834abe860..10f8ccec2 100644 --- a/nano/node/transport/tcp_server.hpp +++ b/nano/node/transport/tcp_server.hpp @@ -2,7 +2,7 @@ #include #include -#include +#include #include @@ -25,14 +25,14 @@ public: tcp_listener (uint16_t, nano::node &); void start (); void stop (); - void accept_action (boost::system::error_code const &, std::shared_ptr const &); + void accept_action (boost::system::error_code const &, std::shared_ptr const &); std::size_t connection_count (); nano::mutex mutex; std::unordered_map> connections; nano::tcp_endpoint endpoint (); nano::node & node; - std::shared_ptr listening_socket; + std::shared_ptr listening_socket; bool on{ false }; std::atomic bootstrap_count{ 0 }; std::atomic realtime_count{ 0 }; @@ -44,7 +44,7 @@ std::unique_ptr collect_container_info (tcp_listener & class tcp_server final : public std::enable_shared_from_this { public: - tcp_server (std::shared_ptr, std::shared_ptr, bool allow_bootstrap = true); + tcp_server (std::shared_ptr, std::shared_ptr, bool allow_bootstrap = true); ~tcp_server (); void start (); @@ -54,7 +54,7 @@ public: void send_handshake_response (nano::uint256_union query); - std::shared_ptr const socket; + std::shared_ptr const socket; std::shared_ptr const node; nano::mutex mutex; std::atomic stopped{ false }; diff --git a/nano/node/transport/transport.hpp b/nano/node/transport/transport.hpp index bc2fd0299..359adb0e3 100644 --- a/nano/node/transport/transport.hpp +++ b/nano/node/transport/transport.hpp @@ -5,7 +5,7 @@ #include #include #include -#include +#include #include diff --git a/nano/node/wallet.cpp b/nano/node/wallet.cpp index 73badcbcf..4abd8e09f 100644 --- a/nano/node/wallet.cpp +++ b/nano/node/wallet.cpp @@ -956,7 +956,7 @@ std::shared_ptr nano::wallet::send_action (nano::account const & so if (block != nullptr) { cached_block = true; - wallets.node.network.flood_block (block, nano::buffer_drop_policy::no_limiter_drop); + wallets.node.network.flood_block (block, nano::transport::buffer_drop_policy::no_limiter_drop); } } else if (status != MDB_NOTFOUND)