From b9b0e44db1b88ae184fd04d477063d77a3de14ec Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20Wo=CC=81jcik?= <3044353+pwojcikdev@users.noreply.github.com> Date: Mon, 17 Jun 2024 17:58:48 +0200 Subject: [PATCH] Rename `socket` to `tcp_socket` --- nano/core_test/bootstrap.cpp | 56 ++++++------- nano/core_test/network.cpp | 16 ++-- nano/core_test/peer_container.cpp | 2 +- nano/core_test/request_aggregator.cpp | 12 +-- nano/core_test/socket.cpp | 80 +++++++++---------- nano/node/CMakeLists.txt | 4 +- nano/node/bootstrap/block_deserializer.cpp | 6 +- nano/node/bootstrap/block_deserializer.hpp | 9 +-- nano/node/bootstrap/bootstrap_bulk_pull.hpp | 2 +- nano/node/bootstrap/bootstrap_connections.cpp | 4 +- nano/node/bootstrap/bootstrap_connections.hpp | 6 +- nano/node/node_observers.hpp | 2 +- nano/node/transport/channel.hpp | 2 +- nano/node/transport/fwd.hpp | 1 + nano/node/transport/tcp_channel.cpp | 2 +- nano/node/transport/tcp_channel.hpp | 4 +- nano/node/transport/tcp_channels.cpp | 2 +- nano/node/transport/tcp_channels.hpp | 6 +- nano/node/transport/tcp_listener.cpp | 4 +- nano/node/transport/tcp_listener.hpp | 10 +-- nano/node/transport/tcp_server.cpp | 2 +- nano/node/transport/tcp_server.hpp | 6 +- .../transport/{socket.cpp => tcp_socket.cpp} | 70 ++++++++-------- .../transport/{socket.hpp => tcp_socket.hpp} | 12 +-- nano/node/transport/transport.hpp | 2 +- 25 files changed, 160 insertions(+), 162 deletions(-) rename nano/node/transport/{socket.cpp => tcp_socket.cpp} (80%) rename nano/node/transport/{socket.hpp => tcp_socket.hpp} (95%) diff --git a/nano/core_test/bootstrap.cpp b/nano/core_test/bootstrap.cpp index 98c61c526..58836e367 100644 --- a/nano/core_test/bootstrap.cpp +++ b/nano/core_test/bootstrap.cpp @@ -18,7 +18,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::transport::socket_endpoint::server), system.nodes[0])); + auto connection (std::make_shared (std::make_shared (*system.nodes[0], nano::transport::socket_endpoint::server), system.nodes[0])); auto req = std::make_unique (nano::dev::network_params.network); req->start = 1; req->end = 2; @@ -30,7 +30,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::transport::socket_endpoint::server), system.nodes[0])); + auto connection (std::make_shared (std::make_shared (*system.nodes[0], nano::transport::socket_endpoint::server), system.nodes[0])); auto req = std::make_unique (nano::dev::network_params.network); req->start = nano::dev::genesis_key.pub; req->end.clear (); @@ -43,7 +43,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::transport::socket_endpoint::server), system.nodes[0])); + auto connection (std::make_shared (std::make_shared (*system.nodes[0], nano::transport::socket_endpoint::server), system.nodes[0])); auto req = std::make_unique (nano::dev::network_params.network); req->start = nano::dev::genesis_key.pub; req->end = 1; @@ -75,7 +75,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::block_status::progress, system.nodes[0]->process (open)); - auto connection (std::make_shared (std::make_shared (*system.nodes[0], nano::transport::socket_endpoint::server), system.nodes[0])); + auto connection (std::make_shared (std::make_shared (*system.nodes[0], nano::transport::socket_endpoint::server), system.nodes[0])); auto req = std::make_unique (nano::dev::network_params.network); req->start = key2.pub; req->end = nano::dev::genesis->hash (); @@ -86,7 +86,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::transport::socket_endpoint::server), system.nodes[0])); + auto connection (std::make_shared (std::make_shared (*system.nodes[0], nano::transport::socket_endpoint::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 (); @@ -98,7 +98,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::transport::socket_endpoint::server), system.nodes[0])); + auto connection (std::make_shared (std::make_shared (*system.nodes[0], nano::transport::socket_endpoint::server), system.nodes[0])); auto req = std::make_unique (nano::dev::network_params.network); req->start = nano::dev::genesis_key.pub; req->end.clear (); @@ -128,7 +128,7 @@ TEST (bulk_pull, ascending_one_hash) .build (); node.work_generate_blocking (*block1); ASSERT_EQ (nano::block_status::progress, node.process (block1)); - auto socket = std::make_shared (node, nano::transport::socket_endpoint::server); + auto socket = std::make_shared (node, nano::transport::socket_endpoint::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 (); @@ -160,7 +160,7 @@ TEST (bulk_pull, ascending_two_account) .build (); node.work_generate_blocking (*block1); ASSERT_EQ (nano::block_status::progress, node.process (block1)); - auto socket = std::make_shared (node, nano::transport::socket_endpoint::server); + auto socket = std::make_shared (node, nano::transport::socket_endpoint::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; @@ -195,7 +195,7 @@ TEST (bulk_pull, ascending_end) .build (); node.work_generate_blocking (*block1); ASSERT_EQ (nano::block_status::progress, node.process (block1)); - auto socket = std::make_shared (node, nano::transport::socket_endpoint::server); + auto socket = std::make_shared (node, nano::transport::socket_endpoint::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; @@ -211,7 +211,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::transport::socket_endpoint::server), system.nodes[0])); + auto connection (std::make_shared (std::make_shared (*system.nodes[0], nano::transport::socket_endpoint::server), system.nodes[0])); auto req = std::make_unique (nano::dev::network_params.network); req->start = nano::dev::genesis->hash (); req->end.clear (); @@ -227,7 +227,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::transport::socket_endpoint::server), system.nodes[0])); + auto connection (std::make_shared (std::make_shared (*system.nodes[0], nano::transport::socket_endpoint::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 (); @@ -264,7 +264,7 @@ TEST (bulk_pull, count_limit) .build (); ASSERT_EQ (nano::block_status::progress, node0->process (receive1)); - auto connection (std::make_shared (std::make_shared (*node0, nano::transport::socket_endpoint::server), node0)); + auto connection (std::make_shared (std::make_shared (*node0, nano::transport::socket_endpoint::server), node0)); auto req = std::make_unique (nano::dev::network_params.network); req->start = receive1->hash (); req->set_count_present (true); @@ -292,7 +292,7 @@ TEST (bootstrap_processor, process_none) auto node1 = system.make_disconnected_node (); std::atomic done = false; - node0->observers.socket_connected.add ([&] (nano::transport::socket & socket) { + node0->observers.socket_connected.add ([&] (nano::transport::tcp_socket & socket) { done = true; }); @@ -1678,7 +1678,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::transport::socket_endpoint::server), system.nodes[0])); + auto connection (std::make_shared (std::make_shared (*system.nodes[0], nano::transport::socket_endpoint::server), system.nodes[0])); auto req = std::make_unique (nano::dev::network_params.network); req->start.clear (); req->age = std::numeric_limitsage)>::max (); @@ -1691,7 +1691,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::transport::socket_endpoint::server), system.nodes[0])); + auto connection (std::make_shared (std::make_shared (*system.nodes[0], nano::transport::socket_endpoint::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 (); @@ -1732,7 +1732,7 @@ TEST (frontier_req, count) node1->work_generate_blocking (*receive1); ASSERT_EQ (nano::block_status::progress, node1->process (receive1)); - auto connection (std::make_shared (std::make_shared (*node1, nano::transport::socket_endpoint::server), node1)); + auto connection (std::make_shared (std::make_shared (*node1, nano::transport::socket_endpoint::server), node1)); auto req = std::make_unique (nano::dev::network_params.network); req->start.clear (); req->age = std::numeric_limitsage)>::max (); @@ -1745,7 +1745,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::transport::socket_endpoint::server), system.nodes[0])); + auto connection (std::make_shared (std::make_shared (*system.nodes[0], nano::transport::socket_endpoint::server), system.nodes[0])); auto req = std::make_unique (nano::dev::network_params.network); req->start.clear (); req->age = 1; @@ -1758,7 +1758,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::transport::socket_endpoint::server), system.nodes[0])); + auto connection2 (std::make_shared (std::make_shared (*system.nodes[0], nano::transport::socket_endpoint::server), system.nodes[0])); auto request2 (std::make_shared (connection, std::move (req2))); ASSERT_TRUE (request2->current.is_zero ()); } @@ -1766,7 +1766,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::transport::socket_endpoint::server), system.nodes[0])); + auto connection (std::make_shared (std::make_shared (*system.nodes[0], nano::transport::socket_endpoint::server), system.nodes[0])); auto req = std::make_unique (nano::dev::network_params.network); req->start.clear (); req->age = 3; @@ -1780,7 +1780,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::transport::socket_endpoint::server), system.nodes[0])); + auto connection2 (std::make_shared (std::make_shared (*system.nodes[0], nano::transport::socket_endpoint::server), system.nodes[0])); auto request2 (std::make_shared (connection, std::move (req2))); ASSERT_TRUE (request2->frontier.is_zero ()); } @@ -1852,7 +1852,7 @@ TEST (frontier_req, confirmed_frontier) ASSERT_EQ (nano::block_status::progress, node1->process (receive2)); // Request for all accounts (confirmed only) - auto connection (std::make_shared (std::make_shared (*node1, nano::transport::socket_endpoint::server), node1)); + auto connection (std::make_shared (std::make_shared (*node1, nano::transport::socket_endpoint::server), node1)); auto req = std::make_unique (nano::dev::network_params.network); req->start.clear (); req->age = std::numeric_limitsage)>::max (); @@ -1865,7 +1865,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::transport::socket_endpoint::server), node1)); + auto connection2 (std::make_shared (std::make_shared (*node1, nano::transport::socket_endpoint::server), node1)); auto req2 = std::make_unique (nano::dev::network_params.network); req2->start = key_before_genesis.pub; req2->age = std::numeric_limitsage)>::max (); @@ -1878,7 +1878,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::transport::socket_endpoint::server), node1)); + auto connection3 (std::make_shared (std::make_shared (*node1, nano::transport::socket_endpoint::server), node1)); auto req3 = std::make_unique (nano::dev::network_params.network); req3->start = key_after_genesis.pub; req3->age = std::numeric_limitsage)>::max (); @@ -1891,7 +1891,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::transport::socket_endpoint::server), node1)); + auto connection4 (std::make_shared (std::make_shared (*node1, nano::transport::socket_endpoint::server), node1)); auto req4 = std::make_unique (nano::dev::network_params.network); req4->start.clear (); req4->age = std::numeric_limitsage)>::max (); @@ -1902,7 +1902,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::transport::socket_endpoint::server), node1)); + auto connection5 (std::make_shared (std::make_shared (*node1, nano::transport::socket_endpoint::server), node1)); auto req5 = std::make_unique (nano::dev::network_params.network); req5->start = key_after_genesis.pub; req5->age = std::numeric_limitsage)>::max (); @@ -1914,7 +1914,7 @@ TEST (frontier_req, confirmed_frontier) // Confirm account before genesis (confirmed only) nano::test::confirm (node1->ledger, receive1); - auto connection6 (std::make_shared (std::make_shared (*node1, nano::transport::socket_endpoint::server), node1)); + auto connection6 (std::make_shared (std::make_shared (*node1, nano::transport::socket_endpoint::server), node1)); auto req6 = std::make_unique (nano::dev::network_params.network); req6->start = key_before_genesis.pub; req6->age = std::numeric_limitsage)>::max (); @@ -1928,7 +1928,7 @@ TEST (frontier_req, confirmed_frontier) // Confirm account after genesis (confirmed only) nano::test::confirm (node1->ledger, receive2); - auto connection7 (std::make_shared (std::make_shared (*node1, nano::transport::socket_endpoint::server), node1)); + auto connection7 (std::make_shared (std::make_shared (*node1, nano::transport::socket_endpoint::server), node1)); auto req7 = std::make_unique (nano::dev::network_params.network); req7->start = key_after_genesis.pub; req7->age = std::numeric_limitsage)>::max (); @@ -2072,7 +2072,7 @@ TEST (bulk_pull_account, basics) auto send2 (system.wallet (0)->send_action (nano::dev::genesis_key.pub, key1.pub, 10)); auto send3 (system.wallet (0)->send_action (nano::dev::genesis_key.pub, key1.pub, 2)); ASSERT_TIMELY_EQ (5s, system.nodes[0]->balance (key1.pub), 25); - auto connection (std::make_shared (std::make_shared (*system.nodes[0], nano::transport::socket_endpoint::server), system.nodes[0])); + auto connection (std::make_shared (std::make_shared (*system.nodes[0], nano::transport::socket_endpoint::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 a31ee9b6c..60efc32be 100644 --- a/nano/core_test/network.cpp +++ b/nano/core_test/network.cpp @@ -5,8 +5,8 @@ #include #include #include -#include #include +#include #include #include #include @@ -132,8 +132,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_EQ (sock0->local_endpoint (), sock1->remote_endpoint ()); ASSERT_EQ (sock1->local_endpoint (), sock0->remote_endpoint ()); } @@ -551,7 +551,7 @@ TEST (network, endpoint_bad_fd) 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))); ASSERT_TRUE (cookie); @@ -589,7 +589,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); @@ -609,7 +609,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 ()))); ASSERT_TRUE (cookie); nano::node_id_handshake::query_payload query{ *cookie }; @@ -1056,7 +1056,7 @@ TEST (network, purge_dead_channel) auto & node1 = *system.add_node (flags); - node1.observers.socket_connected.add ([&] (nano::transport::socket & sock) { + node1.observers.socket_connected.add ([&] (nano::transport::tcp_socket & sock) { system.logger.debug (nano::log::type::test, "Connected: {}", sock); }); @@ -1107,7 +1107,7 @@ TEST (network, purge_dead_channel_remote) auto & node1 = *system.add_node (flags); auto & node2 = *system.add_node (flags); - node2.observers.socket_connected.add ([&] (nano::transport::socket & sock) { + node2.observers.socket_connected.add ([&] (nano::transport::tcp_socket & sock) { system.logger.debug (nano::log::type::test, "Connected: {}", sock); }); diff --git a/nano/core_test/peer_container.cpp b/nano/core_test/peer_container.cpp index 0f98f663f..5418ba98c 100644 --- a/nano/core_test/peer_container.cpp +++ b/nano/core_test/peer_container.cpp @@ -1,5 +1,5 @@ -#include #include +#include #include #include #include diff --git a/nano/core_test/request_aggregator.cpp b/nano/core_test/request_aggregator.cpp index 8c13577a7..a6ec1c3ee 100644 --- a/nano/core_test/request_aggregator.cpp +++ b/nano/core_test/request_aggregator.cpp @@ -36,7 +36,7 @@ TEST (request_aggregator, one) .build (); 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.request (request, dummy_channel); ASSERT_TIMELY (3s, node.aggregator.empty ()); @@ -168,7 +168,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.request (request, dummy_channel); @@ -287,7 +287,7 @@ TEST (request_aggregator, split) node.ledger.confirm (node.ledger.tx_begin_write (), blocks.back ()->hash ()); ASSERT_TIMELY_EQ (5s, max_vbh + 2, node.ledger.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.request (request, dummy_channel); // In the ledger but no vote generated yet @@ -326,7 +326,7 @@ TEST (request_aggregator, channel_max_queue) ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.ledger.tx_begin_write (), send1)); 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.request (request, dummy_channel); node.aggregator.request (request, dummy_channel); @@ -355,7 +355,7 @@ TEST (request_aggregator, DISABLED_unique) ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.ledger.tx_begin_write (), send1)); 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.request (request, dummy_channel); node.aggregator.request (request, dummy_channel); @@ -400,7 +400,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.request (request, dummy_channel); ASSERT_TIMELY (3s, node.aggregator.empty ()); diff --git a/nano/core_test/socket.cpp b/nano/core_test/socket.cpp index 898d8c25a..fc19e2686 100644 --- a/nano/core_test/socket.cpp +++ b/nano/core_test/socket.cpp @@ -2,8 +2,8 @@ #include #include #include -#include #include +#include #include #include @@ -36,13 +36,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 (node->network.endpoint (), connect_handler); - auto client2 = std::make_shared (*node); + auto client2 = std::make_shared (*node); client2->async_connect (node->network.endpoint (), connect_handler); - auto client3 = std::make_shared (*node); + auto client3 = std::make_shared (*node); client3->async_connect (node->network.endpoint (), connect_handler); ASSERT_TIMELY_EQ (5s, node->stats.count (nano::stat::type::tcp_listener, nano::stat::detail::accept_success), 2); @@ -57,10 +57,10 @@ TEST (socket, max_connections) } ASSERT_TIMELY_EQ (10s, node->tcp_listener.sockets ().size (), 1); - auto client4 = std::make_shared (*node); + auto client4 = std::make_shared (*node); client4->async_connect (node->network.endpoint (), connect_handler); - auto client5 = std::make_shared (*node); + auto client5 = std::make_shared (*node); client5->async_connect (node->network.endpoint (), connect_handler); ASSERT_TIMELY_EQ (5s, node->stats.count (nano::stat::type::tcp_listener, nano::stat::detail::accept_success), 3); @@ -76,13 +76,13 @@ TEST (socket, max_connections) } ASSERT_TIMELY_EQ (10s, node->tcp_listener.sockets ().size (), 0); - auto client6 = std::make_shared (*node); + auto client6 = std::make_shared (*node); client6->async_connect (node->network.endpoint (), connect_handler); - auto client7 = std::make_shared (*node); + auto client7 = std::make_shared (*node); client7->async_connect (node->network.endpoint (), connect_handler); - auto client8 = std::make_shared (*node); + auto client8 = std::make_shared (*node); client8->async_connect (node->network.endpoint (), connect_handler); ASSERT_TIMELY_EQ (5s, node->stats.count (nano::stat::type::tcp_listener, nano::stat::detail::accept_success), 5); @@ -113,12 +113,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 (node->network.endpoint (), connect_handler); client_list.push_back (client); } @@ -163,13 +163,13 @@ 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::transport::address_socket_mmap connections_per_address; connections_per_address.emplace (address0, connection0); @@ -210,12 +210,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 (node->network.endpoint (), connect_handler); client_list.push_back (client); } @@ -250,12 +250,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 (node->network.endpoint (), connect_handler); client_list.push_back (client); } @@ -278,8 +278,8 @@ TEST (socket, disconnection_of_silent_connections) auto node = system.add_node (config); // On a connection, a server data socket is created. The shared pointer guarantees the object's lifecycle until the end of this test. - std::promise> server_data_socket_promise; - std::future> server_data_socket_future = server_data_socket_promise.get_future (); + std::promise> server_data_socket_promise; + std::future> server_data_socket_future = server_data_socket_promise.get_future (); node->tcp_listener.connection_accepted.add ([&server_data_socket_promise] (auto const & socket, auto const & server) { server_data_socket_promise.set_value (socket); }); @@ -287,7 +287,7 @@ TEST (socket, disconnection_of_silent_connections) boost::asio::ip::tcp::endpoint dst_endpoint{ boost::asio::ip::address_v6::loopback (), node->tcp_listener.endpoint ().port () }; // 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) { @@ -316,7 +316,7 @@ TEST (socket, drop_policy) nano::inactive_node inactivenode (nano::unique_path (), node_flags); auto node = inactivenode.node; - std::vector> connections; + std::vector> connections; auto func = [&] (size_t total_message_count, nano::transport::buffer_drop_policy drop_policy) { boost::asio::ip::tcp::endpoint endpoint (boost::asio::ip::address_v6::loopback (), system.get_available_port ()); @@ -330,7 +330,7 @@ TEST (socket, drop_policy) EXPECT_FALSE (ec); }); - auto client = std::make_shared (*node); + auto client = std::make_shared (*node); auto channel = std::make_shared (*node, client); std::atomic completed_writes{ 0 }; @@ -355,11 +355,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::transport::socket::default_max_queue_size * 2 + 1, nano::transport::buffer_drop_policy::no_socket_drop); + func (nano::transport::tcp_socket::default_max_queue_size * 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::transport::socket::default_max_queue_size + 1, nano::transport::buffer_drop_policy::limiter); + func (nano::transport::tcp_socket::default_max_queue_size + 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)); @@ -386,8 +386,8 @@ TEST (socket, concurrent_writes) // We're expecting client_count*4 messages std::atomic completed_reads{ 0 }; - using reader_callback_t = std::function const &)>; - reader_callback_t reader = [&completed_reads, &total_message_count, &reader] (std::shared_ptr const & socket_a) { + using reader_callback_t = std::function const &)>; + reader_callback_t reader = [&completed_reads, &total_message_count, &reader] (std::shared_ptr const & socket_a) { auto buff (std::make_shared> ()); buff->resize (1); socket_a->async_read (buff, 1, [&completed_reads, &reader, &total_message_count, socket_a, buff] (boost::system::error_code const & ec, size_t size_a) { @@ -405,7 +405,7 @@ TEST (socket, concurrent_writes) }); }; - std::vector> connections; + std::vector> connections; auto server_port (system.get_available_port ()); boost::asio::ip::tcp::endpoint endpoint (boost::asio::ip::address_v6::any (), server_port); @@ -418,7 +418,7 @@ TEST (socket, concurrent_writes) accept_callback_t accept_callback = [&] (boost::system::error_code const & ec, boost::asio::ip::tcp::socket socket) { if (!ec) { - auto new_connection = std::make_shared (*node, std::move (socket), socket.remote_endpoint (), socket.local_endpoint ()); + auto new_connection = std::make_shared (*node, std::move (socket), socket.remote_endpoint (), socket.local_endpoint ()); connections.push_back (new_connection); reader (new_connection); @@ -433,10 +433,10 @@ TEST (socket, concurrent_writes) std::atomic completed_connections{ 0 }; - 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 (), acceptor.local_endpoint ().port ()), [&completed_connections] (boost::system::error_code const & ec_a) { @@ -501,7 +501,7 @@ TEST (socket_timeout, connect) boost::asio::ip::tcp::endpoint endpoint (boost::asio::ip::make_address_v6 ("::ffff:10.255.254.253"), 1234); // 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) { @@ -544,7 +544,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 (acceptor.local_endpoint (), [&socket, &ec, &done] (boost::system::error_code const & ec_a) { @@ -592,7 +592,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, nano::transport::socket_endpoint::client, 1024 * 64); // socket with a max queue size much larger than OS buffers + auto socket = std::make_shared (*node, nano::transport::socket_endpoint::client, 1024 * 64); // socket with a max queue size much larger than OS buffers std::atomic done = false; boost::system::error_code ec; socket->async_connect (acceptor.local_endpoint (), [&socket, &ec, &done] (boost::system::error_code const & ec_a) { @@ -647,7 +647,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 (acceptor.local_endpoint (), [&socket, &ec, &done] (boost::system::error_code const & ec_a) { @@ -706,7 +706,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, nano::transport::socket_endpoint::client, 1024 * 64); // socket with a max queue size much larger than OS buffers + auto socket = std::make_shared (*node, nano::transport::socket_endpoint::client, 1024 * 64); // socket with a max queue size much larger than OS buffers std::atomic done = false; boost::system::error_code ec; socket->async_connect (acceptor.local_endpoint (), [&socket, &ec, &done] (boost::system::error_code const & ec_a) { diff --git a/nano/node/CMakeLists.txt b/nano/node/CMakeLists.txt index 378945a81..535f917b6 100644 --- a/nano/node/CMakeLists.txt +++ b/nano/node/CMakeLists.txt @@ -165,14 +165,14 @@ add_library( transport/inproc.cpp transport/message_deserializer.hpp transport/message_deserializer.cpp - transport/socket.hpp - transport/socket.cpp transport/tcp_channels.hpp transport/tcp_channels.cpp transport/tcp_listener.hpp transport/tcp_listener.cpp transport/tcp_server.hpp transport/tcp_server.cpp + transport/tcp_socket.hpp + transport/tcp_socket.cpp transport/transport.hpp transport/transport.cpp unchecked_map.cpp diff --git a/nano/node/bootstrap/block_deserializer.cpp b/nano/node/bootstrap/block_deserializer.cpp index 23a4d30d8..ef318b98f 100644 --- a/nano/node/bootstrap/block_deserializer.cpp +++ b/nano/node/bootstrap/block_deserializer.cpp @@ -1,14 +1,14 @@ #include #include #include -#include +#include nano::bootstrap::block_deserializer::block_deserializer () : read_buffer{ std::make_shared> () } { } -void nano::bootstrap::block_deserializer::read (nano::transport::socket & socket, callback_type const && callback) +void nano::bootstrap::block_deserializer::read (nano::transport::tcp_socket & socket, callback_type const && callback) { debug_assert (callback); read_buffer->resize (1); @@ -27,7 +27,7 @@ void nano::bootstrap::block_deserializer::read (nano::transport::socket & socket }); } -void nano::bootstrap::block_deserializer::received_type (nano::transport::socket & socket, callback_type const && callback) +void nano::bootstrap::block_deserializer::received_type (nano::transport::tcp_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 98499200d..55b484ea3 100644 --- a/nano/node/bootstrap/block_deserializer.hpp +++ b/nano/node/bootstrap/block_deserializer.hpp @@ -1,6 +1,7 @@ #pragma once #include +#include #include @@ -10,10 +11,6 @@ namespace nano { class block; -namespace transport -{ - class socket; -} namespace bootstrap { @@ -31,14 +28,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::transport::socket & socket, callback_type const && callback); + void read (nano::transport::tcp_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::transport::socket & socket, callback_type const && callback); + void received_type (nano::transport::tcp_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.hpp b/nano/node/bootstrap/bootstrap_bulk_pull.hpp index a3e901e66..a2e410db4 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 #include diff --git a/nano/node/bootstrap/bootstrap_connections.cpp b/nano/node/bootstrap/bootstrap_connections.cpp index 79243836e..dfbdff12f 100644 --- a/nano/node/bootstrap/bootstrap_connections.cpp +++ b/nano/node/bootstrap/bootstrap_connections.cpp @@ -15,7 +15,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, std::shared_ptr const & channel_a, std::shared_ptr const & socket_a) : +nano::bootstrap_client::bootstrap_client (std::shared_ptr const & node_a, std::shared_ptr const & channel_a, std::shared_ptr const & socket_a) : node (node_a), channel (channel_a), socket (socket_a), @@ -151,7 +151,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 a0d153f99..d246c23bb 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, std::shared_ptr const & channel_a, std::shared_ptr const & socket_a); + bootstrap_client (std::shared_ptr const & node_a, std::shared_ptr const & channel_a, std::shared_ptr const & socket_a); ~bootstrap_client (); void stop (bool force); double sample_block_rate (); @@ -33,7 +33,7 @@ public: void set_start_time (std::chrono::steady_clock::time_point start_time_a); std::weak_ptr node; 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/node_observers.hpp b/nano/node/node_observers.hpp index be18e25df..db09a45c6 100644 --- a/nano/node/node_observers.hpp +++ b/nano/node/node_observers.hpp @@ -33,7 +33,7 @@ public: nano::observer_set<> disconnect; nano::observer_set work_cancel; nano::observer_set const &> telemetry; - nano::observer_set socket_connected; + nano::observer_set socket_connected; }; std::unique_ptr collect_container_info (node_observers & node_observers, std::string const & name); diff --git a/nano/node/transport/channel.hpp b/nano/node/transport/channel.hpp index 996884a03..e01cc8c57 100644 --- a/nano/node/transport/channel.hpp +++ b/nano/node/transport/channel.hpp @@ -6,7 +6,7 @@ #include #include #include -#include +#include #include diff --git a/nano/node/transport/fwd.hpp b/nano/node/transport/fwd.hpp index b10e3dd3c..1300b13cd 100644 --- a/nano/node/transport/fwd.hpp +++ b/nano/node/transport/fwd.hpp @@ -5,4 +5,5 @@ namespace nano::transport class channel; class tcp_channel; class tcp_channels; +class tcp_socket; } \ No newline at end of file diff --git a/nano/node/transport/tcp_channel.cpp b/nano/node/transport/tcp_channel.cpp index 3c4bae842..57f8811ba 100644 --- a/nano/node/transport/tcp_channel.cpp +++ b/nano/node/transport/tcp_channel.cpp @@ -8,7 +8,7 @@ * tcp_channel */ -nano::transport::tcp_channel::tcp_channel (nano::node & node_a, std::weak_ptr socket_a) : +nano::transport::tcp_channel::tcp_channel (nano::node & node_a, std::weak_ptr socket_a) : channel (node_a), socket (std::move (socket_a)) { diff --git a/nano/node/transport/tcp_channel.hpp b/nano/node/transport/tcp_channel.hpp index 9ad9026cf..b72db5654 100644 --- a/nano/node/transport/tcp_channel.hpp +++ b/nano/node/transport/tcp_channel.hpp @@ -14,7 +14,7 @@ class tcp_channel : public nano::transport::channel, public std::enable_shared_f friend class nano::transport::tcp_channels; public: - tcp_channel (nano::node &, std::weak_ptr); + tcp_channel (nano::node &, std::weak_ptr); ~tcp_channel () override; void update_endpoints (); @@ -74,7 +74,7 @@ public: } public: - std::weak_ptr socket; + std::weak_ptr socket; private: nano::endpoint endpoint; diff --git a/nano/node/transport/tcp_channels.cpp b/nano/node/transport/tcp_channels.cpp index 15d94e610..014ef589f 100644 --- a/nano/node/transport/tcp_channels.cpp +++ b/nano/node/transport/tcp_channels.cpp @@ -91,7 +91,7 @@ bool nano::transport::tcp_channels::check (const nano::tcp_endpoint & endpoint, } // This should be the only place in node where channels are created -std::shared_ptr nano::transport::tcp_channels::create (const std::shared_ptr & socket, const std::shared_ptr & server, const nano::account & node_id) +std::shared_ptr nano::transport::tcp_channels::create (const std::shared_ptr & socket, const std::shared_ptr & server, const nano::account & node_id) { auto const endpoint = socket->remote_endpoint (); debug_assert (endpoint.address ().is_v6 ()); diff --git a/nano/node/transport/tcp_channels.hpp b/nano/node/transport/tcp_channels.hpp index ddd1abab3..913550887 100644 --- a/nano/node/transport/tcp_channels.hpp +++ b/nano/node/transport/tcp_channels.hpp @@ -34,7 +34,7 @@ public: void start (); void stop (); - std::shared_ptr create (std::shared_ptr const &, std::shared_ptr const &, nano::account const & node_id); + std::shared_ptr create (std::shared_ptr const &, std::shared_ptr const &, nano::account const & node_id); void erase (nano::tcp_endpoint const &); std::size_t size () const; std::shared_ptr find_channel (nano::tcp_endpoint const &) const; @@ -70,11 +70,11 @@ private: { public: std::shared_ptr channel; - std::shared_ptr socket; + std::shared_ptr socket; std::shared_ptr response_server; public: - channel_entry (std::shared_ptr channel_a, std::shared_ptr socket_a, std::shared_ptr server_a) : + channel_entry (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_listener.cpp b/nano/node/transport/tcp_listener.cpp index 7ee3bf62f..a63499727 100644 --- a/nano/node/transport/tcp_listener.cpp +++ b/nano/node/transport/tcp_listener.cpp @@ -395,7 +395,7 @@ auto nano::transport::tcp_listener::accept_one (asio::ip::tcp::socket raw_socket stats.inc (nano::stat::type::tcp_listener, nano::stat::detail::accept_success, to_stat_dir (type)); logger.debug (nano::log::type::tcp_listener, "Accepted connection: {} ({})", fmt::streamed (remote_endpoint), to_string (type)); - auto socket = std::make_shared (node, std::move (raw_socket), remote_endpoint, local_endpoint, to_socket_endpoint (type)); + auto socket = std::make_shared (node, std::move (raw_socket), remote_endpoint, local_endpoint, to_socket_endpoint (type)); auto server = std::make_shared (socket, node.shared (), true); connections.emplace_back (connection{ remote_endpoint, socket, server }); @@ -567,7 +567,7 @@ asio::ip::tcp::endpoint nano::transport::tcp_listener::endpoint () const return { asio::ip::address_v6::loopback (), local.port () }; } -auto nano::transport::tcp_listener::sockets () const -> std::vector> +auto nano::transport::tcp_listener::sockets () const -> std::vector> { nano::lock_guard lock{ mutex }; auto r = connections diff --git a/nano/node/transport/tcp_listener.hpp b/nano/node/transport/tcp_listener.hpp index 371399137..094560477 100644 --- a/nano/node/transport/tcp_listener.hpp +++ b/nano/node/transport/tcp_listener.hpp @@ -73,13 +73,13 @@ public: size_t realtime_count () const; size_t bootstrap_count () const; - std::vector> sockets () const; - std::vector> servers () const; + std::vector> sockets () const; + std::vector> servers () const; std::unique_ptr collect_container_info (std::string const & name); public: // Events - using connection_accepted_event_t = nano::observer_set const &, std::shared_ptr>; + using connection_accepted_event_t = nano::observer_set const &, std::shared_ptr>; connection_accepted_event_t connection_accepted; private: // Dependencies @@ -116,7 +116,7 @@ private: struct accept_return { accept_result result; - std::shared_ptr socket; + std::shared_ptr socket; std::shared_ptr server; }; @@ -133,7 +133,7 @@ private: struct connection { asio::ip::tcp::endpoint endpoint; - std::weak_ptr socket; + std::weak_ptr socket; std::weak_ptr server; asio::ip::address address () const diff --git a/nano/node/transport/tcp_server.cpp b/nano/node/transport/tcp_server.cpp index 27bc15084..9c03c7997 100644 --- a/nano/node/transport/tcp_server.cpp +++ b/nano/node/transport/tcp_server.cpp @@ -12,7 +12,7 @@ * tcp_server */ -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{ socket_a }, node{ node_a }, allow_bootstrap{ allow_bootstrap_a }, diff --git a/nano/node/transport/tcp_server.hpp b/nano/node/transport/tcp_server.hpp index 6301014e9..f0e93924e 100644 --- a/nano/node/transport/tcp_server.hpp +++ b/nano/node/transport/tcp_server.hpp @@ -3,7 +3,7 @@ #include #include #include -#include +#include #include @@ -20,7 +20,7 @@ class tcp_server; 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 (); @@ -31,7 +31,7 @@ public: void set_last_keepalive (nano::keepalive const & message); std::optional pop_last_keepalive (); - std::shared_ptr const socket; + std::shared_ptr const socket; std::weak_ptr const node; nano::mutex mutex; std::atomic stopped{ false }; diff --git a/nano/node/transport/socket.cpp b/nano/node/transport/tcp_socket.cpp similarity index 80% rename from nano/node/transport/socket.cpp rename to nano/node/transport/tcp_socket.cpp index 44f65bca1..0c0cad101 100644 --- a/nano/node/transport/socket.cpp +++ b/nano/node/transport/tcp_socket.cpp @@ -2,7 +2,7 @@ #include #include #include -#include +#include #include #include @@ -18,16 +18,16 @@ * socket */ -nano::transport::socket::socket (nano::node & node_a, nano::transport::socket_endpoint endpoint_type_a, std::size_t max_queue_size_a) : - socket{ node_a, boost::asio::ip::tcp::socket{ node_a.io_ctx }, {}, {}, endpoint_type_a, max_queue_size_a } +nano::transport::tcp_socket::tcp_socket (nano::node & node_a, nano::transport::socket_endpoint endpoint_type_a, std::size_t max_queue_size_a) : + tcp_socket{ node_a, boost::asio::ip::tcp::socket{ node_a.io_ctx }, {}, {}, endpoint_type_a, max_queue_size_a } { } -nano::transport::socket::socket (nano::node & node_a, boost::asio::ip::tcp::socket boost_socket_a, boost::asio::ip::tcp::endpoint remote_endpoint_a, boost::asio::ip::tcp::endpoint local_endpoint_a, nano::transport::socket_endpoint endpoint_type_a, std::size_t max_queue_size_a) : +nano::transport::tcp_socket::tcp_socket (nano::node & node_a, boost::asio::ip::tcp::socket raw_socket_a, boost::asio::ip::tcp::endpoint remote_endpoint_a, boost::asio::ip::tcp::endpoint local_endpoint_a, nano::transport::socket_endpoint endpoint_type_a, std::size_t max_queue_size_a) : send_queue{ max_queue_size_a }, node_w{ node_a.shared () }, strand{ node_a.io_ctx.get_executor () }, - tcp_socket{ std::move (boost_socket_a) }, + raw_socket{ std::move (raw_socket_a) }, remote{ remote_endpoint_a }, local{ local_endpoint_a }, endpoint_type_m{ endpoint_type_a }, @@ -40,18 +40,18 @@ nano::transport::socket::socket (nano::node & node_a, boost::asio::ip::tcp::sock { } -nano::transport::socket::~socket () +nano::transport::tcp_socket::~tcp_socket () { close_internal (); closed = true; } -void nano::transport::socket::start () +void nano::transport::tcp_socket::start () { ongoing_checkup (); } -void nano::transport::socket::async_connect (nano::tcp_endpoint const & endpoint_a, std::function callback_a) +void nano::transport::tcp_socket::async_connect (nano::tcp_endpoint const & endpoint_a, std::function callback_a) { debug_assert (callback_a); debug_assert (endpoint_type () == socket_endpoint::client); @@ -60,7 +60,7 @@ void nano::transport::socket::async_connect (nano::tcp_endpoint const & endpoint set_default_timeout (); boost::asio::post (strand, [this_l = shared_from_this (), endpoint_a, callback = std::move (callback_a)] () { - this_l->tcp_socket.async_connect (endpoint_a, + this_l->raw_socket.async_connect (endpoint_a, boost::asio::bind_executor (this_l->strand, [this_l, callback = std::move (callback), endpoint_a] (boost::system::error_code const & ec) { debug_assert (this_l->strand.running_in_this_thread ()); @@ -83,7 +83,7 @@ void nano::transport::socket::async_connect (nano::tcp_endpoint const & endpoint { // Best effort attempt to get endpoint address boost::system::error_code ec; - this_l->local = this_l->tcp_socket.local_endpoint (ec); + this_l->local = this_l->raw_socket.local_endpoint (ec); } node_l->observers.socket_connected.notify (*this_l); } @@ -92,7 +92,7 @@ void nano::transport::socket::async_connect (nano::tcp_endpoint const & endpoint }); } -void nano::transport::socket::async_read (std::shared_ptr> const & buffer_a, std::size_t size_a, std::function callback_a) +void nano::transport::tcp_socket::async_read (std::shared_ptr> const & buffer_a, std::size_t size_a, std::function callback_a) { debug_assert (callback_a); @@ -102,7 +102,7 @@ void nano::transport::socket::async_read (std::shared_ptr> { set_default_timeout (); boost::asio::post (strand, [this_l = shared_from_this (), buffer_a, callback = std::move (callback_a), size_a] () mutable { - boost::asio::async_read (this_l->tcp_socket, boost::asio::buffer (buffer_a->data (), size_a), + boost::asio::async_read (this_l->raw_socket, boost::asio::buffer (buffer_a->data (), size_a), boost::asio::bind_executor (this_l->strand, [this_l, buffer_a, cbk = std::move (callback)] (boost::system::error_code const & ec, std::size_t size_a) { debug_assert (this_l->strand.running_in_this_thread ()); @@ -131,13 +131,13 @@ void nano::transport::socket::async_read (std::shared_ptr> } else { - debug_assert (false && "nano::transport::socket::async_read called with incorrect buffer size"); + debug_assert (false && "nano::transport::tcp_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::transport::socket::async_write (nano::shared_const_buffer const & buffer_a, std::function callback_a, nano::transport::traffic_type traffic_type) +void nano::transport::tcp_socket::async_write (nano::shared_const_buffer const & buffer_a, std::function callback_a, nano::transport::traffic_type traffic_type) { auto node_l = node_w.lock (); if (!node_l) @@ -177,7 +177,7 @@ void nano::transport::socket::async_write (nano::shared_const_buffer const & buf } // Must be called from strand -void nano::transport::socket::write_queued_messages () +void nano::transport::tcp_socket::write_queued_messages () { debug_assert (strand.running_in_this_thread ()); @@ -195,7 +195,7 @@ void nano::transport::socket::write_queued_messages () set_default_timeout (); write_in_progress = true; - nano::async_write (tcp_socket, next->buffer, + nano::async_write (raw_socket, next->buffer, boost::asio::bind_executor (strand, [this_l = shared_from_this (), next /* `next` object keeps buffer in scope */] (boost::system::error_code ec, std::size_t size) { debug_assert (this_l->strand.running_in_this_thread ()); @@ -229,18 +229,18 @@ void nano::transport::socket::write_queued_messages () })); } -bool nano::transport::socket::max (nano::transport::traffic_type traffic_type) const +bool nano::transport::tcp_socket::max (nano::transport::traffic_type traffic_type) const { return send_queue.size (traffic_type) >= max_queue_size; } -bool nano::transport::socket::full (nano::transport::traffic_type traffic_type) const +bool nano::transport::tcp_socket::full (nano::transport::traffic_type traffic_type) const { return send_queue.size (traffic_type) >= 2 * max_queue_size; } /** Call set_timeout with default_timeout as parameter */ -void nano::transport::socket::set_default_timeout () +void nano::transport::tcp_socket::set_default_timeout () { set_timeout (default_timeout); } @@ -251,22 +251,22 @@ void nano::transport::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::transport::socket::set_timeout (std::chrono::seconds timeout_a) +void nano::transport::tcp_socket::set_timeout (std::chrono::seconds timeout_a) { timeout = timeout_a.count (); } -void nano::transport::socket::set_last_completion () +void nano::transport::tcp_socket::set_last_completion () { last_completion_time_or_init = nano::seconds_since_epoch (); } -void nano::transport::socket::set_last_receive_time () +void nano::transport::tcp_socket::set_last_receive_time () { last_receive_time_or_init = nano::seconds_since_epoch (); } -void nano::transport::socket::ongoing_checkup () +void nano::transport::tcp_socket::ongoing_checkup () { auto node_l = node_w.lock (); if (!node_l) @@ -288,7 +288,7 @@ void nano::transport::socket::ongoing_checkup () } boost::asio::post (this_l->strand, [this_l] { - if (!this_l->tcp_socket.is_open ()) + if (!this_l->raw_socket.is_open ()) { this_l->close (); } @@ -327,7 +327,7 @@ void nano::transport::socket::ongoing_checkup () }); } -void nano::transport::socket::read_impl (std::shared_ptr> const & data_a, std::size_t size_a, std::function callback_a) +void nano::transport::tcp_socket::read_impl (std::shared_ptr> const & data_a, std::size_t size_a, std::function callback_a) { auto node_l = node_w.lock (); if (!node_l) @@ -344,22 +344,22 @@ void nano::transport::socket::read_impl (std::shared_ptr> c }); } -bool nano::transport::socket::has_timed_out () const +bool nano::transport::tcp_socket::has_timed_out () const { return timed_out; } -void nano::transport::socket::set_default_timeout_value (std::chrono::seconds timeout_a) +void nano::transport::tcp_socket::set_default_timeout_value (std::chrono::seconds timeout_a) { default_timeout = timeout_a; } -std::chrono::seconds nano::transport::socket::get_default_timeout_value () const +std::chrono::seconds nano::transport::tcp_socket::get_default_timeout_value () const { return default_timeout; } -void nano::transport::socket::close () +void nano::transport::tcp_socket::close () { boost::asio::dispatch (strand, [this_l = shared_from_this ()] { this_l->close_internal (); @@ -367,7 +367,7 @@ void nano::transport::socket::close () } // This must be called from a strand or the destructor -void nano::transport::socket::close_internal () +void nano::transport::tcp_socket::close_internal () { auto node_l = node_w.lock (); if (!node_l) @@ -386,8 +386,8 @@ void nano::transport::socket::close_internal () // Ignore error code for shutdown as it is best-effort boost::system::error_code ec; - tcp_socket.shutdown (boost::asio::ip::tcp::socket::shutdown_both, ec); - tcp_socket.close (ec); + raw_socket.shutdown (boost::asio::ip::tcp::socket::shutdown_both, ec); + raw_socket.close (ec); if (ec) { @@ -396,19 +396,19 @@ void nano::transport::socket::close_internal () } } -nano::tcp_endpoint nano::transport::socket::remote_endpoint () const +nano::tcp_endpoint nano::transport::tcp_socket::remote_endpoint () const { // Using cached value to avoid calling tcp_socket.remote_endpoint() which may be invalid (throw) after closing the socket return remote; } -nano::tcp_endpoint nano::transport::socket::local_endpoint () const +nano::tcp_endpoint nano::transport::tcp_socket::local_endpoint () const { // Using cached value to avoid calling tcp_socket.local_endpoint() which may be invalid (throw) after closing the socket return local; } -void nano::transport::socket::operator() (nano::object_stream & obs) const +void nano::transport::tcp_socket::operator() (nano::object_stream & obs) const { obs.write ("remote_endpoint", remote_endpoint ()); obs.write ("local_endpoint", local_endpoint ()); diff --git a/nano/node/transport/socket.hpp b/nano/node/transport/tcp_socket.hpp similarity index 95% rename from nano/node/transport/socket.hpp rename to nano/node/transport/tcp_socket.hpp index fe271d066..5eadaa2e3 100644 --- a/nano/node/transport/socket.hpp +++ b/nano/node/transport/tcp_socket.hpp @@ -58,7 +58,7 @@ private: }; /** Socket class for tcp clients and newly accepted connections */ -class socket final : public std::enable_shared_from_this +class tcp_socket final : public std::enable_shared_from_this { friend class tcp_server; friend class tcp_channels; @@ -68,10 +68,10 @@ public: static std::size_t constexpr default_max_queue_size = 128; public: - explicit socket (nano::node &, nano::transport::socket_endpoint = socket_endpoint::client, std::size_t max_queue_size = default_max_queue_size); + explicit tcp_socket (nano::node &, nano::transport::socket_endpoint = socket_endpoint::client, std::size_t max_queue_size = default_max_queue_size); // TODO: Accepting remote/local endpoints as a parameter is unnecessary, but is needed for now to keep compatibility with the legacy code - socket ( + tcp_socket ( nano::node &, boost::asio::ip::tcp::socket, boost::asio::ip::tcp::endpoint remote_endpoint, @@ -79,7 +79,7 @@ public: nano::transport::socket_endpoint = socket_endpoint::server, std::size_t max_queue_size = default_max_queue_size); - ~socket (); + ~tcp_socket (); void start (); void close (); @@ -147,7 +147,7 @@ protected: std::weak_ptr node_w; boost::asio::strand strand; - boost::asio::ip::tcp::socket tcp_socket; + boost::asio::ip::tcp::socket raw_socket; /** The other end of the connection */ boost::asio::ip::tcp::endpoint remote; @@ -205,7 +205,7 @@ public: // Logging virtual void operator() (nano::object_stream &) const; }; -using address_socket_mmap = std::multimap>; +using address_socket_mmap = std::multimap>; namespace socket_functions { diff --git a/nano/node/transport/transport.hpp b/nano/node/transport/transport.hpp index efeb6260e..3065bbd04 100644 --- a/nano/node/transport/transport.hpp +++ b/nano/node/transport/transport.hpp @@ -5,7 +5,7 @@ #include #include #include -#include +#include #include