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

Rename socket to tcp_socket

Browse source
This commit is contained in:
Piotr Wójcik 2024-06-17 17:58:48 +02:00
commit b9b0e44db1
25 changed files with 160 additions and 162 deletions
Download patch file Download diff file Expand all files Collapse all files

56
nano/core_test/bootstrap.cpp
View file

@ -18,7 +18,7 @@ using namespace std::chrono_literals;
TEST (bulk_pull, no_address) TEST (bulk_pull, no_address)
{ {
nano::test::system system (1); nano::test::system system (1);
auto connection (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::socket> (*system.nodes[0], nano::transport::socket_endpoint::server), system.nodes[0])); auto connection (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::tcp_socket> (*system.nodes[0], nano::transport::socket_endpoint::server), system.nodes[0]));
auto req = std::make_unique<nano::bulk_pull> (nano::dev::network_params.network); auto req = std::make_unique<nano::bulk_pull> (nano::dev::network_params.network);
req->start = 1; req->start = 1;
req->end = 2; req->end = 2;
@ -30,7 +30,7 @@ TEST (bulk_pull, no_address)
TEST (bulk_pull, genesis_to_end) TEST (bulk_pull, genesis_to_end)
{ {
nano::test::system system (1); nano::test::system system (1);
auto connection (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::socket> (*system.nodes[0], nano::transport::socket_endpoint::server), system.nodes[0])); auto connection (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::tcp_socket> (*system.nodes[0], nano::transport::socket_endpoint::server), system.nodes[0]));
auto req = std::make_unique<nano::bulk_pull> (nano::dev::network_params.network); auto req = std::make_unique<nano::bulk_pull> (nano::dev::network_params.network);
req->start = nano::dev::genesis_key.pub; req->start = nano::dev::genesis_key.pub;
req->end.clear (); req->end.clear ();
@ -43,7 +43,7 @@ TEST (bulk_pull, genesis_to_end)
TEST (bulk_pull, no_end) TEST (bulk_pull, no_end)
{ {
nano::test::system system (1); nano::test::system system (1);
auto connection (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::socket> (*system.nodes[0], nano::transport::socket_endpoint::server), system.nodes[0])); auto connection (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::tcp_socket> (*system.nodes[0], nano::transport::socket_endpoint::server), system.nodes[0]));
auto req = std::make_unique<nano::bulk_pull> (nano::dev::network_params.network); auto req = std::make_unique<nano::bulk_pull> (nano::dev::network_params.network);
req->start = nano::dev::genesis_key.pub; req->start = nano::dev::genesis_key.pub;
req->end = 1; req->end = 1;
@ -75,7 +75,7 @@ TEST (bulk_pull, end_not_owned)
open->signature = nano::sign_message (key2.prv, key2.pub, open->hash ()); open->signature = nano::sign_message (key2.prv, key2.pub, open->hash ());
system.nodes[0]->work_generate_blocking (*open); system.nodes[0]->work_generate_blocking (*open);
ASSERT_EQ (nano::block_status::progress, system.nodes[0]->process (open)); ASSERT_EQ (nano::block_status::progress, system.nodes[0]->process (open));
auto connection (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::socket> (*system.nodes[0], nano::transport::socket_endpoint::server), system.nodes[0])); auto connection (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::tcp_socket> (*system.nodes[0], nano::transport::socket_endpoint::server), system.nodes[0]));
auto req = std::make_unique<nano::bulk_pull> (nano::dev::network_params.network); auto req = std::make_unique<nano::bulk_pull> (nano::dev::network_params.network);
req->start = key2.pub; req->start = key2.pub;
req->end = nano::dev::genesis->hash (); req->end = nano::dev::genesis->hash ();
@ -86,7 +86,7 @@ TEST (bulk_pull, end_not_owned)
TEST (bulk_pull, none) TEST (bulk_pull, none)
{ {
nano::test::system system (1); nano::test::system system (1);
auto connection (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::socket> (*system.nodes[0], nano::transport::socket_endpoint::server), system.nodes[0])); auto connection (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::tcp_socket> (*system.nodes[0], nano::transport::socket_endpoint::server), system.nodes[0]));
auto req = std::make_unique<nano::bulk_pull> (nano::dev::network_params.network); auto req = std::make_unique<nano::bulk_pull> (nano::dev::network_params.network);
req->start = nano::dev::genesis_key.pub; req->start = nano::dev::genesis_key.pub;
req->end = nano::dev::genesis->hash (); req->end = nano::dev::genesis->hash ();
@ -98,7 +98,7 @@ TEST (bulk_pull, none)
TEST (bulk_pull, get_next_on_open) TEST (bulk_pull, get_next_on_open)
{ {
nano::test::system system (1); nano::test::system system (1);
auto connection (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::socket> (*system.nodes[0], nano::transport::socket_endpoint::server), system.nodes[0])); auto connection (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::tcp_socket> (*system.nodes[0], nano::transport::socket_endpoint::server), system.nodes[0]));
auto req = std::make_unique<nano::bulk_pull> (nano::dev::network_params.network); auto req = std::make_unique<nano::bulk_pull> (nano::dev::network_params.network);
req->start = nano::dev::genesis_key.pub; req->start = nano::dev::genesis_key.pub;
req->end.clear (); req->end.clear ();
@ -128,7 +128,7 @@ TEST (bulk_pull, ascending_one_hash)
.build (); .build ();
node.work_generate_blocking (*block1); node.work_generate_blocking (*block1);
ASSERT_EQ (nano::block_status::progress, node.process (block1)); ASSERT_EQ (nano::block_status::progress, node.process (block1));
auto socket = std::make_shared<nano::transport::socket> (node, nano::transport::socket_endpoint::server); auto socket = std::make_shared<nano::transport::tcp_socket> (node, nano::transport::socket_endpoint::server);
auto connection = std::make_shared<nano::transport::tcp_server> (socket, system.nodes[0]); auto connection = std::make_shared<nano::transport::tcp_server> (socket, system.nodes[0]);
auto req = std::make_unique<nano::bulk_pull> (nano::dev::network_params.network); auto req = std::make_unique<nano::bulk_pull> (nano::dev::network_params.network);
req->start = nano::dev::genesis->hash (); req->start = nano::dev::genesis->hash ();
@ -160,7 +160,7 @@ TEST (bulk_pull, ascending_two_account)
.build (); .build ();
node.work_generate_blocking (*block1); node.work_generate_blocking (*block1);
ASSERT_EQ (nano::block_status::progress, node.process (block1)); ASSERT_EQ (nano::block_status::progress, node.process (block1));
auto socket = std::make_shared<nano::transport::socket> (node, nano::transport::socket_endpoint::server); auto socket = std::make_shared<nano::transport::tcp_socket> (node, nano::transport::socket_endpoint::server);
auto connection = std::make_shared<nano::transport::tcp_server> (socket, system.nodes[0]); auto connection = std::make_shared<nano::transport::tcp_server> (socket, system.nodes[0]);
auto req = std::make_unique<nano::bulk_pull> (nano::dev::network_params.network); auto req = std::make_unique<nano::bulk_pull> (nano::dev::network_params.network);
req->start = nano::dev::genesis_key.pub; req->start = nano::dev::genesis_key.pub;
@ -195,7 +195,7 @@ TEST (bulk_pull, ascending_end)
.build (); .build ();
node.work_generate_blocking (*block1); node.work_generate_blocking (*block1);
ASSERT_EQ (nano::block_status::progress, node.process (block1)); ASSERT_EQ (nano::block_status::progress, node.process (block1));
auto socket = std::make_shared<nano::transport::socket> (node, nano::transport::socket_endpoint::server); auto socket = std::make_shared<nano::transport::tcp_socket> (node, nano::transport::socket_endpoint::server);
auto connection = std::make_shared<nano::transport::tcp_server> (socket, system.nodes[0]); auto connection = std::make_shared<nano::transport::tcp_server> (socket, system.nodes[0]);
auto req = std::make_unique<nano::bulk_pull> (nano::dev::network_params.network); auto req = std::make_unique<nano::bulk_pull> (nano::dev::network_params.network);
req->start = nano::dev::genesis_key.pub; req->start = nano::dev::genesis_key.pub;
@ -211,7 +211,7 @@ TEST (bulk_pull, ascending_end)
TEST (bulk_pull, by_block) TEST (bulk_pull, by_block)
{ {
nano::test::system system (1); nano::test::system system (1);
auto connection (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::socket> (*system.nodes[0], nano::transport::socket_endpoint::server), system.nodes[0])); auto connection (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::tcp_socket> (*system.nodes[0], nano::transport::socket_endpoint::server), system.nodes[0]));
auto req = std::make_unique<nano::bulk_pull> (nano::dev::network_params.network); auto req = std::make_unique<nano::bulk_pull> (nano::dev::network_params.network);
req->start = nano::dev::genesis->hash (); req->start = nano::dev::genesis->hash ();
req->end.clear (); req->end.clear ();
@ -227,7 +227,7 @@ TEST (bulk_pull, by_block)
TEST (bulk_pull, by_block_single) TEST (bulk_pull, by_block_single)
{ {
nano::test::system system (1); nano::test::system system (1);
auto connection (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::socket> (*system.nodes[0], nano::transport::socket_endpoint::server), system.nodes[0])); auto connection (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::tcp_socket> (*system.nodes[0], nano::transport::socket_endpoint::server), system.nodes[0]));
auto req = std::make_unique<nano::bulk_pull> (nano::dev::network_params.network); auto req = std::make_unique<nano::bulk_pull> (nano::dev::network_params.network);
req->start = nano::dev::genesis->hash (); req->start = nano::dev::genesis->hash ();
req->end = nano::dev::genesis->hash (); req->end = nano::dev::genesis->hash ();
@ -264,7 +264,7 @@ TEST (bulk_pull, count_limit)
.build (); .build ();
ASSERT_EQ (nano::block_status::progress, node0->process (receive1)); ASSERT_EQ (nano::block_status::progress, node0->process (receive1));
auto connection (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::socket> (*node0, nano::transport::socket_endpoint::server), node0)); auto connection (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::tcp_socket> (*node0, nano::transport::socket_endpoint::server), node0));
auto req = std::make_unique<nano::bulk_pull> (nano::dev::network_params.network); auto req = std::make_unique<nano::bulk_pull> (nano::dev::network_params.network);
req->start = receive1->hash (); req->start = receive1->hash ();
req->set_count_present (true); req->set_count_present (true);
@ -292,7 +292,7 @@ TEST (bootstrap_processor, process_none)
auto node1 = system.make_disconnected_node (); auto node1 = system.make_disconnected_node ();
std::atomic<bool> done = false; std::atomic<bool> done = false;
node0->observers.socket_connected.add ([&] (nano::transport::socket & socket) { node0->observers.socket_connected.add ([&] (nano::transport::tcp_socket & socket) {
done = true; done = true;
}); });
@ -1678,7 +1678,7 @@ TEST (frontier_req_response, DISABLED_destruction)
TEST (frontier_req, begin) TEST (frontier_req, begin)
{ {
nano::test::system system (1); nano::test::system system (1);
auto connection (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::socket> (*system.nodes[0], nano::transport::socket_endpoint::server), system.nodes[0])); auto connection (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::tcp_socket> (*system.nodes[0], nano::transport::socket_endpoint::server), system.nodes[0]));
auto req = std::make_unique<nano::frontier_req> (nano::dev::network_params.network); auto req = std::make_unique<nano::frontier_req> (nano::dev::network_params.network);
req->start.clear (); req->start.clear ();
req->age = std::numeric_limits<decltype (req->age)>::max (); req->age = std::numeric_limits<decltype (req->age)>::max ();
@ -1691,7 +1691,7 @@ TEST (frontier_req, begin)
TEST (frontier_req, end) TEST (frontier_req, end)
{ {
nano::test::system system (1); nano::test::system system (1);
auto connection (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::socket> (*system.nodes[0], nano::transport::socket_endpoint::server), system.nodes[0])); auto connection (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::tcp_socket> (*system.nodes[0], nano::transport::socket_endpoint::server), system.nodes[0]));
auto req = std::make_unique<nano::frontier_req> (nano::dev::network_params.network); auto req = std::make_unique<nano::frontier_req> (nano::dev::network_params.network);
req->start = nano::dev::genesis_key.pub.number () + 1; req->start = nano::dev::genesis_key.pub.number () + 1;
req->age = std::numeric_limits<decltype (req->age)>::max (); req->age = std::numeric_limits<decltype (req->age)>::max ();
@ -1732,7 +1732,7 @@ TEST (frontier_req, count)
node1->work_generate_blocking (*receive1); node1->work_generate_blocking (*receive1);
ASSERT_EQ (nano::block_status::progress, node1->process (receive1)); ASSERT_EQ (nano::block_status::progress, node1->process (receive1));
auto connection (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::socket> (*node1, nano::transport::socket_endpoint::server), node1)); auto connection (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::tcp_socket> (*node1, nano::transport::socket_endpoint::server), node1));
auto req = std::make_unique<nano::frontier_req> (nano::dev::network_params.network); auto req = std::make_unique<nano::frontier_req> (nano::dev::network_params.network);
req->start.clear (); req->start.clear ();
req->age = std::numeric_limits<decltype (req->age)>::max (); req->age = std::numeric_limits<decltype (req->age)>::max ();
@ -1745,7 +1745,7 @@ TEST (frontier_req, count)
TEST (frontier_req, time_bound) TEST (frontier_req, time_bound)
{ {
nano::test::system system (1); nano::test::system system (1);
auto connection (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::socket> (*system.nodes[0], nano::transport::socket_endpoint::server), system.nodes[0])); auto connection (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::tcp_socket> (*system.nodes[0], nano::transport::socket_endpoint::server), system.nodes[0]));
auto req = std::make_unique<nano::frontier_req> (nano::dev::network_params.network); auto req = std::make_unique<nano::frontier_req> (nano::dev::network_params.network);
req->start.clear (); req->start.clear ();
req->age = 1; req->age = 1;
@ -1758,7 +1758,7 @@ TEST (frontier_req, time_bound)
req2->start.clear (); req2->start.clear ();
req2->age = 1; req2->age = 1;
req2->count = std::numeric_limits<decltype (req2->count)>::max (); req2->count = std::numeric_limits<decltype (req2->count)>::max ();
auto connection2 (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::socket> (*system.nodes[0], nano::transport::socket_endpoint::server), system.nodes[0])); auto connection2 (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::tcp_socket> (*system.nodes[0], nano::transport::socket_endpoint::server), system.nodes[0]));
auto request2 (std::make_shared<nano::frontier_req_server> (connection, std::move (req2))); auto request2 (std::make_shared<nano::frontier_req_server> (connection, std::move (req2)));
ASSERT_TRUE (request2->current.is_zero ()); ASSERT_TRUE (request2->current.is_zero ());
} }
@ -1766,7 +1766,7 @@ TEST (frontier_req, time_bound)
TEST (frontier_req, time_cutoff) TEST (frontier_req, time_cutoff)
{ {
nano::test::system system (1); nano::test::system system (1);
auto connection (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::socket> (*system.nodes[0], nano::transport::socket_endpoint::server), system.nodes[0])); auto connection (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::tcp_socket> (*system.nodes[0], nano::transport::socket_endpoint::server), system.nodes[0]));
auto req = std::make_unique<nano::frontier_req> (nano::dev::network_params.network); auto req = std::make_unique<nano::frontier_req> (nano::dev::network_params.network);
req->start.clear (); req->start.clear ();
req->age = 3; req->age = 3;
@ -1780,7 +1780,7 @@ TEST (frontier_req, time_cutoff)
req2->start.clear (); req2->start.clear ();
req2->age = 3; req2->age = 3;
req2->count = std::numeric_limits<decltype (req2->count)>::max (); req2->count = std::numeric_limits<decltype (req2->count)>::max ();
auto connection2 (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::socket> (*system.nodes[0], nano::transport::socket_endpoint::server), system.nodes[0])); auto connection2 (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::tcp_socket> (*system.nodes[0], nano::transport::socket_endpoint::server), system.nodes[0]));
auto request2 (std::make_shared<nano::frontier_req_server> (connection, std::move (req2))); auto request2 (std::make_shared<nano::frontier_req_server> (connection, std::move (req2)));
ASSERT_TRUE (request2->frontier.is_zero ()); ASSERT_TRUE (request2->frontier.is_zero ());
} }
@ -1852,7 +1852,7 @@ TEST (frontier_req, confirmed_frontier)
ASSERT_EQ (nano::block_status::progress, node1->process (receive2)); ASSERT_EQ (nano::block_status::progress, node1->process (receive2));
// Request for all accounts (confirmed only) // Request for all accounts (confirmed only)
auto connection (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::socket> (*node1, nano::transport::socket_endpoint::server), node1)); auto connection (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::tcp_socket> (*node1, nano::transport::socket_endpoint::server), node1));
auto req = std::make_unique<nano::frontier_req> (nano::dev::network_params.network); auto req = std::make_unique<nano::frontier_req> (nano::dev::network_params.network);
req->start.clear (); req->start.clear ();
req->age = std::numeric_limits<decltype (req->age)>::max (); req->age = std::numeric_limits<decltype (req->age)>::max ();
@ -1865,7 +1865,7 @@ TEST (frontier_req, confirmed_frontier)
ASSERT_EQ (nano::dev::genesis->hash (), request->frontier); ASSERT_EQ (nano::dev::genesis->hash (), request->frontier);
// Request starting with account before genesis (confirmed only) // Request starting with account before genesis (confirmed only)
auto connection2 (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::socket> (*node1, nano::transport::socket_endpoint::server), node1)); auto connection2 (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::tcp_socket> (*node1, nano::transport::socket_endpoint::server), node1));
auto req2 = std::make_unique<nano::frontier_req> (nano::dev::network_params.network); auto req2 = std::make_unique<nano::frontier_req> (nano::dev::network_params.network);
req2->start = key_before_genesis.pub; req2->start = key_before_genesis.pub;
req2->age = std::numeric_limits<decltype (req2->age)>::max (); req2->age = std::numeric_limits<decltype (req2->age)>::max ();
@ -1878,7 +1878,7 @@ TEST (frontier_req, confirmed_frontier)
ASSERT_EQ (nano::dev::genesis->hash (), request2->frontier); ASSERT_EQ (nano::dev::genesis->hash (), request2->frontier);
// Request starting with account after genesis (confirmed only) // Request starting with account after genesis (confirmed only)
auto connection3 (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::socket> (*node1, nano::transport::socket_endpoint::server), node1)); auto connection3 (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::tcp_socket> (*node1, nano::transport::socket_endpoint::server), node1));
auto req3 = std::make_unique<nano::frontier_req> (nano::dev::network_params.network); auto req3 = std::make_unique<nano::frontier_req> (nano::dev::network_params.network);
req3->start = key_after_genesis.pub; req3->start = key_after_genesis.pub;
req3->age = std::numeric_limits<decltype (req3->age)>::max (); req3->age = std::numeric_limits<decltype (req3->age)>::max ();
@ -1891,7 +1891,7 @@ TEST (frontier_req, confirmed_frontier)
ASSERT_TRUE (request3->frontier.is_zero ()); ASSERT_TRUE (request3->frontier.is_zero ());
// Request for all accounts (unconfirmed blocks) // Request for all accounts (unconfirmed blocks)
auto connection4 (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::socket> (*node1, nano::transport::socket_endpoint::server), node1)); auto connection4 (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::tcp_socket> (*node1, nano::transport::socket_endpoint::server), node1));
auto req4 = std::make_unique<nano::frontier_req> (nano::dev::network_params.network); auto req4 = std::make_unique<nano::frontier_req> (nano::dev::network_params.network);
req4->start.clear (); req4->start.clear ();
req4->age = std::numeric_limits<decltype (req4->age)>::max (); req4->age = std::numeric_limits<decltype (req4->age)>::max ();
@ -1902,7 +1902,7 @@ TEST (frontier_req, confirmed_frontier)
ASSERT_EQ (receive1->hash (), request4->frontier); ASSERT_EQ (receive1->hash (), request4->frontier);
// Request starting with account after genesis (unconfirmed blocks) // Request starting with account after genesis (unconfirmed blocks)
auto connection5 (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::socket> (*node1, nano::transport::socket_endpoint::server), node1)); auto connection5 (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::tcp_socket> (*node1, nano::transport::socket_endpoint::server), node1));
auto req5 = std::make_unique<nano::frontier_req> (nano::dev::network_params.network); auto req5 = std::make_unique<nano::frontier_req> (nano::dev::network_params.network);
req5->start = key_after_genesis.pub; req5->start = key_after_genesis.pub;
req5->age = std::numeric_limits<decltype (req5->age)>::max (); req5->age = std::numeric_limits<decltype (req5->age)>::max ();
@ -1914,7 +1914,7 @@ TEST (frontier_req, confirmed_frontier)
// Confirm account before genesis (confirmed only) // Confirm account before genesis (confirmed only)
nano::test::confirm (node1->ledger, receive1); nano::test::confirm (node1->ledger, receive1);
auto connection6 (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::socket> (*node1, nano::transport::socket_endpoint::server), node1)); auto connection6 (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::tcp_socket> (*node1, nano::transport::socket_endpoint::server), node1));
auto req6 = std::make_unique<nano::frontier_req> (nano::dev::network_params.network); auto req6 = std::make_unique<nano::frontier_req> (nano::dev::network_params.network);
req6->start = key_before_genesis.pub; req6->start = key_before_genesis.pub;
req6->age = std::numeric_limits<decltype (req6->age)>::max (); req6->age = std::numeric_limits<decltype (req6->age)>::max ();
@ -1928,7 +1928,7 @@ TEST (frontier_req, confirmed_frontier)
// Confirm account after genesis (confirmed only) // Confirm account after genesis (confirmed only)
nano::test::confirm (node1->ledger, receive2); nano::test::confirm (node1->ledger, receive2);
auto connection7 (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::socket> (*node1, nano::transport::socket_endpoint::server), node1)); auto connection7 (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::tcp_socket> (*node1, nano::transport::socket_endpoint::server), node1));
auto req7 = std::make_unique<nano::frontier_req> (nano::dev::network_params.network); auto req7 = std::make_unique<nano::frontier_req> (nano::dev::network_params.network);
req7->start = key_after_genesis.pub; req7->start = key_after_genesis.pub;
req7->age = std::numeric_limits<decltype (req7->age)>::max (); req7->age = std::numeric_limits<decltype (req7->age)>::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 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)); 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); ASSERT_TIMELY_EQ (5s, system.nodes[0]->balance (key1.pub), 25);
auto connection (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::socket> (*system.nodes[0], nano::transport::socket_endpoint::server), system.nodes[0])); auto connection (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::tcp_socket> (*system.nodes[0], nano::transport::socket_endpoint::server), system.nodes[0]));
{ {
auto req = std::make_unique<nano::bulk_pull_account> (nano::dev::network_params.network); auto req = std::make_unique<nano::bulk_pull_account> (nano::dev::network_params.network);

16
nano/core_test/network.cpp
View file

@ -5,8 +5,8 @@
#include <nano/node/scheduler/component.hpp> #include <nano/node/scheduler/component.hpp>
#include <nano/node/scheduler/priority.hpp> #include <nano/node/scheduler/priority.hpp>
#include <nano/node/transport/inproc.hpp> #include <nano/node/transport/inproc.hpp>
#include <nano/node/transport/socket.hpp>
#include <nano/node/transport/tcp_listener.hpp> #include <nano/node/transport/tcp_listener.hpp>
#include <nano/node/transport/tcp_socket.hpp>
#include <nano/secure/ledger.hpp> #include <nano/secure/ledger.hpp>
#include <nano/secure/ledger_set_any.hpp> #include <nano/secure/ledger_set_any.hpp>
#include <nano/test_common/network.hpp> #include <nano/test_common/network.hpp>
@ -132,8 +132,8 @@ TEST (network, last_contacted)
{ {
// check that the endpoints are part of the same connection // check that the endpoints are part of the same connection
std::shared_ptr<nano::transport::socket> sock0 = channel0->socket.lock (); std::shared_ptr<nano::transport::tcp_socket> sock0 = channel0->socket.lock ();
std::shared_ptr<nano::transport::socket> sock1 = channel1->socket.lock (); std::shared_ptr<nano::transport::tcp_socket> sock1 = channel1->socket.lock ();
ASSERT_EQ (sock0->local_endpoint (), sock1->remote_endpoint ()); ASSERT_EQ (sock0->local_endpoint (), sock1->remote_endpoint ());
ASSERT_EQ (sock1->local_endpoint (), sock0->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) TEST (tcp_listener, tcp_node_id_handshake)
{ {
nano::test::system system (1); nano::test::system system (1);
auto socket (std::make_shared<nano::transport::socket> (*system.nodes[0])); auto socket (std::make_shared<nano::transport::tcp_socket> (*system.nodes[0]));
auto bootstrap_endpoint (system.nodes[0]->tcp_listener.endpoint ()); 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))); auto cookie (system.nodes[0]->network.syn_cookies.assign (nano::transport::map_tcp_to_endpoint (bootstrap_endpoint)));
ASSERT_TRUE (cookie); ASSERT_TRUE (cookie);
@ -589,7 +589,7 @@ TEST (tcp_listener, DISABLED_tcp_listener_timeout_empty)
{ {
nano::test::system system (1); nano::test::system system (1);
auto node0 (system.nodes[0]); auto node0 (system.nodes[0]);
auto socket (std::make_shared<nano::transport::socket> (*node0)); auto socket (std::make_shared<nano::transport::tcp_socket> (*node0));
std::atomic<bool> connected (false); std::atomic<bool> connected (false);
socket->async_connect (node0->tcp_listener.endpoint (), [&connected] (boost::system::error_code const & ec) { socket->async_connect (node0->tcp_listener.endpoint (), [&connected] (boost::system::error_code const & ec) {
ASSERT_FALSE (ec); ASSERT_FALSE (ec);
@ -609,7 +609,7 @@ TEST (tcp_listener, tcp_listener_timeout_node_id_handshake)
{ {
nano::test::system system (1); nano::test::system system (1);
auto node0 (system.nodes[0]); auto node0 (system.nodes[0]);
auto socket (std::make_shared<nano::transport::socket> (*node0)); auto socket (std::make_shared<nano::transport::tcp_socket> (*node0));
auto cookie (node0->network.syn_cookies.assign (nano::transport::map_tcp_to_endpoint (node0->tcp_listener.endpoint ()))); auto cookie (node0->network.syn_cookies.assign (nano::transport::map_tcp_to_endpoint (node0->tcp_listener.endpoint ())));
ASSERT_TRUE (cookie); ASSERT_TRUE (cookie);
nano::node_id_handshake::query_payload query{ *cookie }; nano::node_id_handshake::query_payload query{ *cookie };
@ -1056,7 +1056,7 @@ TEST (network, purge_dead_channel)
auto & node1 = *system.add_node (flags); 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); 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 & node1 = *system.add_node (flags);
auto & node2 = *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); system.logger.debug (nano::log::type::test, "Connected: {}", sock);
}); });

2
nano/core_test/peer_container.cpp
View file

@ -1,5 +1,5 @@
#include <nano/node/transport/socket.hpp>
#include <nano/node/transport/tcp_server.hpp> #include <nano/node/transport/tcp_server.hpp>
#include <nano/node/transport/tcp_socket.hpp>
#include <nano/test_common/network.hpp> #include <nano/test_common/network.hpp>
#include <nano/test_common/system.hpp> #include <nano/test_common/system.hpp>
#include <nano/test_common/testutil.hpp> #include <nano/test_common/testutil.hpp>

12
nano/core_test/request_aggregator.cpp
View file

@ -36,7 +36,7 @@ TEST (request_aggregator, one)
.build (); .build ();
std::vector<std::pair<nano::block_hash, nano::root>> request; std::vector<std::pair<nano::block_hash, nano::root>> request;
request.emplace_back (send1->hash (), send1->root ()); request.emplace_back (send1->hash (), send1->root ());
auto client = std::make_shared<nano::transport::socket> (node); auto client = std::make_shared<nano::transport::tcp_socket> (node);
std::shared_ptr<nano::transport::channel> dummy_channel = std::make_shared<nano::transport::tcp_channel> (node, client); std::shared_ptr<nano::transport::channel> dummy_channel = std::make_shared<nano::transport::tcp_channel> (node, client);
node.aggregator.request (request, dummy_channel); node.aggregator.request (request, dummy_channel);
ASSERT_TIMELY (3s, node.aggregator.empty ()); ASSERT_TIMELY (3s, node.aggregator.empty ());
@ -168,7 +168,7 @@ TEST (request_aggregator, two)
std::vector<std::pair<nano::block_hash, nano::root>> request; std::vector<std::pair<nano::block_hash, nano::root>> request;
request.emplace_back (send2->hash (), send2->root ()); request.emplace_back (send2->hash (), send2->root ());
request.emplace_back (receive1->hash (), receive1->root ()); request.emplace_back (receive1->hash (), receive1->root ());
auto client = std::make_shared<nano::transport::socket> (node); auto client = std::make_shared<nano::transport::tcp_socket> (node);
std::shared_ptr<nano::transport::channel> dummy_channel = std::make_shared<nano::transport::tcp_channel> (node, client); std::shared_ptr<nano::transport::channel> dummy_channel = std::make_shared<nano::transport::tcp_channel> (node, client);
// Process both blocks // Process both blocks
node.aggregator.request (request, dummy_channel); 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 ()); node.ledger.confirm (node.ledger.tx_begin_write (), blocks.back ()->hash ());
ASSERT_TIMELY_EQ (5s, max_vbh + 2, node.ledger.cemented_count ()); ASSERT_TIMELY_EQ (5s, max_vbh + 2, node.ledger.cemented_count ());
ASSERT_EQ (max_vbh + 1, request.size ()); ASSERT_EQ (max_vbh + 1, request.size ());
auto client = std::make_shared<nano::transport::socket> (node); auto client = std::make_shared<nano::transport::tcp_socket> (node);
std::shared_ptr<nano::transport::channel> dummy_channel = std::make_shared<nano::transport::tcp_channel> (node, client); std::shared_ptr<nano::transport::channel> dummy_channel = std::make_shared<nano::transport::tcp_channel> (node, client);
node.aggregator.request (request, dummy_channel); node.aggregator.request (request, dummy_channel);
// In the ledger but no vote generated yet // 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)); ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.ledger.tx_begin_write (), send1));
std::vector<std::pair<nano::block_hash, nano::root>> request; std::vector<std::pair<nano::block_hash, nano::root>> request;
request.emplace_back (send1->hash (), send1->root ()); request.emplace_back (send1->hash (), send1->root ());
auto client = std::make_shared<nano::transport::socket> (node); auto client = std::make_shared<nano::transport::tcp_socket> (node);
std::shared_ptr<nano::transport::channel> dummy_channel = std::make_shared<nano::transport::tcp_channel> (node, client); std::shared_ptr<nano::transport::channel> dummy_channel = std::make_shared<nano::transport::tcp_channel> (node, client);
node.aggregator.request (request, dummy_channel); node.aggregator.request (request, dummy_channel);
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)); ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.ledger.tx_begin_write (), send1));
std::vector<std::pair<nano::block_hash, nano::root>> request; std::vector<std::pair<nano::block_hash, nano::root>> request;
request.emplace_back (send1->hash (), send1->root ()); request.emplace_back (send1->hash (), send1->root ());
auto client = std::make_shared<nano::transport::socket> (node); auto client = std::make_shared<nano::transport::tcp_socket> (node);
std::shared_ptr<nano::transport::channel> dummy_channel = std::make_shared<nano::transport::tcp_channel> (node, client); std::shared_ptr<nano::transport::channel> dummy_channel = std::make_shared<nano::transport::tcp_channel> (node, client);
node.aggregator.request (request, dummy_channel); node.aggregator.request (request, dummy_channel);
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 ()); request.emplace_back (send2->hash (), send2->root ());
// Incorrect hash, correct root // Incorrect hash, correct root
request.emplace_back (1, send2->root ()); request.emplace_back (1, send2->root ());
auto client = std::make_shared<nano::transport::socket> (node); auto client = std::make_shared<nano::transport::tcp_socket> (node);
std::shared_ptr<nano::transport::channel> dummy_channel = std::make_shared<nano::transport::tcp_channel> (node, client); std::shared_ptr<nano::transport::channel> dummy_channel = std::make_shared<nano::transport::tcp_channel> (node, client);
node.aggregator.request (request, dummy_channel); node.aggregator.request (request, dummy_channel);
ASSERT_TIMELY (3s, node.aggregator.empty ()); ASSERT_TIMELY (3s, node.aggregator.empty ());

80
nano/core_test/socket.cpp
View file

@ -2,8 +2,8 @@
#include <nano/boost/asio/ip/network_v6.hpp> #include <nano/boost/asio/ip/network_v6.hpp>
#include <nano/lib/thread_runner.hpp> #include <nano/lib/thread_runner.hpp>
#include <nano/node/inactive_node.hpp> #include <nano/node/inactive_node.hpp>
#include <nano/node/transport/socket.hpp>
#include <nano/node/transport/tcp_listener.hpp> #include <nano/node/transport/tcp_listener.hpp>
#include <nano/node/transport/tcp_socket.hpp>
#include <nano/test_common/system.hpp> #include <nano/test_common/system.hpp>
#include <nano/test_common/testutil.hpp> #include <nano/test_common/testutil.hpp>
@ -36,13 +36,13 @@ TEST (socket, max_connections)
}; };
// start 3 clients, 2 will persist but 1 will be dropped // start 3 clients, 2 will persist but 1 will be dropped
auto client1 = std::make_shared<nano::transport::socket> (*node); auto client1 = std::make_shared<nano::transport::tcp_socket> (*node);
client1->async_connect (node->network.endpoint (), connect_handler); client1->async_connect (node->network.endpoint (), connect_handler);
auto client2 = std::make_shared<nano::transport::socket> (*node); auto client2 = std::make_shared<nano::transport::tcp_socket> (*node);
client2->async_connect (node->network.endpoint (), connect_handler); client2->async_connect (node->network.endpoint (), connect_handler);
auto client3 = std::make_shared<nano::transport::socket> (*node); auto client3 = std::make_shared<nano::transport::tcp_socket> (*node);
client3->async_connect (node->network.endpoint (), connect_handler); 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); 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); ASSERT_TIMELY_EQ (10s, node->tcp_listener.sockets ().size (), 1);
auto client4 = std::make_shared<nano::transport::socket> (*node); auto client4 = std::make_shared<nano::transport::tcp_socket> (*node);
client4->async_connect (node->network.endpoint (), connect_handler); client4->async_connect (node->network.endpoint (), connect_handler);
auto client5 = std::make_shared<nano::transport::socket> (*node); auto client5 = std::make_shared<nano::transport::tcp_socket> (*node);
client5->async_connect (node->network.endpoint (), connect_handler); 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); 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); ASSERT_TIMELY_EQ (10s, node->tcp_listener.sockets ().size (), 0);
auto client6 = std::make_shared<nano::transport::socket> (*node); auto client6 = std::make_shared<nano::transport::tcp_socket> (*node);
client6->async_connect (node->network.endpoint (), connect_handler); client6->async_connect (node->network.endpoint (), connect_handler);
auto client7 = std::make_shared<nano::transport::socket> (*node); auto client7 = std::make_shared<nano::transport::tcp_socket> (*node);
client7->async_connect (node->network.endpoint (), connect_handler); client7->async_connect (node->network.endpoint (), connect_handler);
auto client8 = std::make_shared<nano::transport::socket> (*node); auto client8 = std::make_shared<nano::transport::tcp_socket> (*node);
client8->async_connect (node->network.endpoint (), connect_handler); 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); 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 // start n clients, n-1 will persist but 1 will be dropped, where n == max_ip_connections
std::vector<std::shared_ptr<nano::transport::socket>> client_list; std::vector<std::shared_ptr<nano::transport::tcp_socket>> client_list;
client_list.reserve (max_ip_connections + 1); client_list.reserve (max_ip_connections + 1);
for (auto idx = 0; idx < max_ip_connections + 1; ++idx) for (auto idx = 0; idx < max_ip_connections + 1; ++idx)
{ {
auto client = std::make_shared<nano::transport::socket> (*node); auto client = std::make_shared<nano::transport::tcp_socket> (*node);
client->async_connect (node->network.endpoint (), connect_handler); client->async_connect (node->network.endpoint (), connect_handler);
client_list.push_back (client); 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 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 address6 = boost::asio::ip::make_address ("a41d:b7b3::1"); // out of the network prefix
auto connection0 = std::make_shared<nano::transport::socket> (*node); auto connection0 = std::make_shared<nano::transport::tcp_socket> (*node);
auto connection1 = std::make_shared<nano::transport::socket> (*node); auto connection1 = std::make_shared<nano::transport::tcp_socket> (*node);
auto connection2 = std::make_shared<nano::transport::socket> (*node); auto connection2 = std::make_shared<nano::transport::tcp_socket> (*node);
auto connection3 = std::make_shared<nano::transport::socket> (*node); auto connection3 = std::make_shared<nano::transport::tcp_socket> (*node);
auto connection4 = std::make_shared<nano::transport::socket> (*node); auto connection4 = std::make_shared<nano::transport::tcp_socket> (*node);
auto connection5 = std::make_shared<nano::transport::socket> (*node); auto connection5 = std::make_shared<nano::transport::tcp_socket> (*node);
auto connection6 = std::make_shared<nano::transport::socket> (*node); auto connection6 = std::make_shared<nano::transport::tcp_socket> (*node);
nano::transport::address_socket_mmap connections_per_address; nano::transport::address_socket_mmap connections_per_address;
connections_per_address.emplace (address0, connection0); 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 // start n clients, n-1 will persist but 1 will be dropped, where n == max_subnetwork_connections
std::vector<std::shared_ptr<nano::transport::socket>> client_list; std::vector<std::shared_ptr<nano::transport::tcp_socket>> client_list;
client_list.reserve (max_subnetwork_connections + 1); client_list.reserve (max_subnetwork_connections + 1);
for (auto idx = 0; idx < max_subnetwork_connections + 1; ++idx) for (auto idx = 0; idx < max_subnetwork_connections + 1; ++idx)
{ {
auto client = std::make_shared<nano::transport::socket> (*node); auto client = std::make_shared<nano::transport::tcp_socket> (*node);
client->async_connect (node->network.endpoint (), connect_handler); client->async_connect (node->network.endpoint (), connect_handler);
client_list.push_back (client); 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 // start n clients, n-1 will persist but 1 will be dropped, where n == max_ip_connections
std::vector<std::shared_ptr<nano::transport::socket>> client_list; std::vector<std::shared_ptr<nano::transport::tcp_socket>> client_list;
client_list.reserve (max_ip_connections + 1); client_list.reserve (max_ip_connections + 1);
for (auto idx = 0; idx < max_ip_connections + 1; ++idx) for (auto idx = 0; idx < max_ip_connections + 1; ++idx)
{ {
auto client = std::make_shared<nano::transport::socket> (*node); auto client = std::make_shared<nano::transport::tcp_socket> (*node);
client->async_connect (node->network.endpoint (), connect_handler); client->async_connect (node->network.endpoint (), connect_handler);
client_list.push_back (client); client_list.push_back (client);
} }
@ -278,8 +278,8 @@ TEST (socket, disconnection_of_silent_connections)
auto node = system.add_node (config); 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. // 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<std::shared_ptr<nano::transport::socket>> server_data_socket_promise; std::promise<std::shared_ptr<nano::transport::tcp_socket>> server_data_socket_promise;
std::future<std::shared_ptr<nano::transport::socket>> server_data_socket_future = server_data_socket_promise.get_future (); std::future<std::shared_ptr<nano::transport::tcp_socket>> 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) { node->tcp_listener.connection_accepted.add ([&server_data_socket_promise] (auto const & socket, auto const & server) {
server_data_socket_promise.set_value (socket); 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 () }; 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. // Instantiates a client to simulate an incoming connection.
auto client_socket = std::make_shared<nano::transport::socket> (*node); auto client_socket = std::make_shared<nano::transport::tcp_socket> (*node);
std::atomic<bool> connected{ false }; std::atomic<bool> connected{ false };
// Opening a connection that will be closed because it remains silent during the tolerance time. // 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) { 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); nano::inactive_node inactivenode (nano::unique_path (), node_flags);
auto node = inactivenode.node; auto node = inactivenode.node;
std::vector<std::shared_ptr<nano::transport::socket>> connections; std::vector<std::shared_ptr<nano::transport::tcp_socket>> connections;
auto func = [&] (size_t total_message_count, nano::transport::buffer_drop_policy drop_policy) { 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 ()); 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); EXPECT_FALSE (ec);
}); });
auto client = std::make_shared<nano::transport::socket> (*node); auto client = std::make_shared<nano::transport::tcp_socket> (*node);
auto channel = std::make_shared<nano::transport::tcp_channel> (*node, client); auto channel = std::make_shared<nano::transport::tcp_channel> (*node, client);
std::atomic completed_writes{ 0 }; 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 // 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) // 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 (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)); 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 // 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_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)); 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 // We're expecting client_count*4 messages
std::atomic completed_reads{ 0 }; std::atomic completed_reads{ 0 };
using reader_callback_t = std::function<void (std::shared_ptr<nano::transport::socket> const &)>; using reader_callback_t = std::function<void (std::shared_ptr<nano::transport::tcp_socket> const &)>;
reader_callback_t reader = [&completed_reads, &total_message_count, &reader] (std::shared_ptr<nano::transport::socket> const & socket_a) { reader_callback_t reader = [&completed_reads, &total_message_count, &reader] (std::shared_ptr<nano::transport::tcp_socket> const & socket_a) {
auto buff (std::make_shared<std::vector<uint8_t>> ()); auto buff (std::make_shared<std::vector<uint8_t>> ());
buff->resize (1); 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) { 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<std::shared_ptr<nano::transport::socket>> connections; std::vector<std::shared_ptr<nano::transport::tcp_socket>> connections;
auto server_port (system.get_available_port ()); auto server_port (system.get_available_port ());
boost::asio::ip::tcp::endpoint endpoint (boost::asio::ip::address_v6::any (), server_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) { accept_callback_t accept_callback = [&] (boost::system::error_code const & ec, boost::asio::ip::tcp::socket socket) {
if (!ec) if (!ec)
{ {
auto new_connection = std::make_shared<nano::transport::socket> (*node, std::move (socket), socket.remote_endpoint (), socket.local_endpoint ()); auto new_connection = std::make_shared<nano::transport::tcp_socket> (*node, std::move (socket), socket.remote_endpoint (), socket.local_endpoint ());
connections.push_back (new_connection); connections.push_back (new_connection);
reader (new_connection); reader (new_connection);
@ -433,10 +433,10 @@ TEST (socket, concurrent_writes)
std::atomic completed_connections{ 0 }; std::atomic completed_connections{ 0 };
std::vector<std::shared_ptr<nano::transport::socket>> clients; std::vector<std::shared_ptr<nano::transport::tcp_socket>> clients;
for (unsigned i = 0; i < client_count; i++) for (unsigned i = 0; i < client_count; i++)
{ {
auto client = std::make_shared<nano::transport::socket> (*node); auto client = std::make_shared<nano::transport::tcp_socket> (*node);
clients.push_back (client); clients.push_back (client);
client->async_connect (boost::asio::ip::tcp::endpoint (boost::asio::ip::address_v4::loopback (), acceptor.local_endpoint ().port ()), 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) { [&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); 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 // create a client socket and try to connect to the IP address that wil not respond
auto socket = std::make_shared<nano::transport::socket> (*node); auto socket = std::make_shared<nano::transport::tcp_socket> (*node);
std::atomic<bool> done = false; std::atomic<bool> done = false;
boost::system::error_code ec; boost::system::error_code ec;
socket->async_connect (endpoint, [&ec, &done] (boost::system::error_code const & ec_a) { 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 // create a client socket to connect and call async_read, which should time out
auto socket = std::make_shared<nano::transport::socket> (*node); auto socket = std::make_shared<nano::transport::tcp_socket> (*node);
std::atomic<bool> done = false; std::atomic<bool> done = false;
boost::system::error_code ec; boost::system::error_code ec;
socket->async_connect (acceptor.local_endpoint (), [&socket, &ec, &done] (boost::system::error_code const & ec_a) { 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 // 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 // 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 // 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<nano::transport::socket> (*node, nano::transport::socket_endpoint::client, 1024 * 64); // socket with a max queue size much larger than OS buffers auto socket = std::make_shared<nano::transport::tcp_socket> (*node, nano::transport::socket_endpoint::client, 1024 * 64); // socket with a max queue size much larger than OS buffers
std::atomic<bool> done = false; std::atomic<bool> done = false;
boost::system::error_code ec; boost::system::error_code ec;
socket->async_connect (acceptor.local_endpoint (), [&socket, &ec, &done] (boost::system::error_code const & ec_a) { 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 // create a client socket to connect and call async_read twice, the second call should time out
auto socket = std::make_shared<nano::transport::socket> (*node); auto socket = std::make_shared<nano::transport::tcp_socket> (*node);
std::atomic<bool> done = false; std::atomic<bool> done = false;
boost::system::error_code ec; boost::system::error_code ec;
socket->async_connect (acceptor.local_endpoint (), [&socket, &ec, &done] (boost::system::error_code const & ec_a) { 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 // 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 // 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 // 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<nano::transport::socket> (*node, nano::transport::socket_endpoint::client, 1024 * 64); // socket with a max queue size much larger than OS buffers auto socket = std::make_shared<nano::transport::tcp_socket> (*node, nano::transport::socket_endpoint::client, 1024 * 64); // socket with a max queue size much larger than OS buffers
std::atomic<bool> done = false; std::atomic<bool> done = false;
boost::system::error_code ec; boost::system::error_code ec;
socket->async_connect (acceptor.local_endpoint (), [&socket, &ec, &done] (boost::system::error_code const & ec_a) { socket->async_connect (acceptor.local_endpoint (), [&socket, &ec, &done] (boost::system::error_code const & ec_a) {

4
nano/node/CMakeLists.txt
View file

@ -165,14 +165,14 @@ add_library(
transport/inproc.cpp transport/inproc.cpp
transport/message_deserializer.hpp transport/message_deserializer.hpp
transport/message_deserializer.cpp transport/message_deserializer.cpp
transport/socket.hpp
transport/socket.cpp
transport/tcp_channels.hpp transport/tcp_channels.hpp
transport/tcp_channels.cpp transport/tcp_channels.cpp
transport/tcp_listener.hpp transport/tcp_listener.hpp
transport/tcp_listener.cpp transport/tcp_listener.cpp
transport/tcp_server.hpp transport/tcp_server.hpp
transport/tcp_server.cpp transport/tcp_server.cpp
transport/tcp_socket.hpp
transport/tcp_socket.cpp
transport/transport.hpp transport/transport.hpp
transport/transport.cpp transport/transport.cpp
unchecked_map.cpp unchecked_map.cpp

6
nano/node/bootstrap/block_deserializer.cpp
View file

@ -1,14 +1,14 @@
#include <nano/lib/blocks.hpp> #include <nano/lib/blocks.hpp>
#include <nano/lib/stream.hpp> #include <nano/lib/stream.hpp>
#include <nano/node/bootstrap/block_deserializer.hpp> #include <nano/node/bootstrap/block_deserializer.hpp>
#include <nano/node/transport/socket.hpp> #include <nano/node/transport/tcp_socket.hpp>
nano::bootstrap::block_deserializer::block_deserializer () : nano::bootstrap::block_deserializer::block_deserializer () :
read_buffer{ std::make_shared<std::vector<uint8_t>> () } read_buffer{ std::make_shared<std::vector<uint8_t>> () }
{ {
} }
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); debug_assert (callback);
read_buffer->resize (1); 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<nano::block_type> (read_buffer->data ()[0]); nano::block_type type = static_cast<nano::block_type> (read_buffer->data ()[0]);
if (type == nano::block_type::not_a_block) if (type == nano::block_type::not_a_block)

9
nano/node/bootstrap/block_deserializer.hpp
View file

@ -1,6 +1,7 @@
#pragma once #pragma once
#include <nano/lib/block_type.hpp> #include <nano/lib/block_type.hpp>
#include <nano/node/transport/fwd.hpp>
#include <boost/system/error_code.hpp> #include <boost/system/error_code.hpp>
@ -10,10 +11,6 @@
namespace nano namespace nano
{ {
class block; class block;
namespace transport
{
class socket;
}
namespace bootstrap namespace bootstrap
{ {
@ -31,14 +28,14 @@ namespace bootstrap
* Read a type-prefixed block from 'socket' and pass the result, or an error, to 'callback' * 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. * 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: private:
/** /**
* Called by read method on receipt of a block type byte. * Called by read method on receipt of a block type byte.
* The type byte will be in the read_buffer. * 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. * Called by received_type when a block is received, it parses the block and calls the callback.

2
nano/node/bootstrap/bootstrap_bulk_pull.hpp
View file

@ -1,7 +1,7 @@
#pragma once #pragma once
#include <nano/node/messages.hpp> #include <nano/node/messages.hpp>
#include <nano/node/transport/socket.hpp> #include <nano/node/transport/tcp_socket.hpp>
#include <nano/secure/pending_info.hpp> #include <nano/secure/pending_info.hpp>
#include <unordered_set> #include <unordered_set>

4
nano/node/bootstrap/bootstrap_connections.cpp
View file

@ -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::bootstrap_max_new_connections;
constexpr unsigned nano::bootstrap_limits::requeued_pulls_processed_blocks_factor; constexpr unsigned nano::bootstrap_limits::requeued_pulls_processed_blocks_factor;
nano::bootstrap_client::bootstrap_client (std::shared_ptr<nano::node> const & node_a, std::shared_ptr<nano::transport::tcp_channel> const & channel_a, std::shared_ptr<nano::transport::socket> const & socket_a) : nano::bootstrap_client::bootstrap_client (std::shared_ptr<nano::node> const & node_a, std::shared_ptr<nano::transport::tcp_channel> const & channel_a, std::shared_ptr<nano::transport::tcp_socket> const & socket_a) :
node (node_a), node (node_a),
channel (channel_a), channel (channel_a),
socket (socket_a), socket (socket_a),
@ -151,7 +151,7 @@ std::shared_ptr<nano::bootstrap_client> nano::bootstrap_connections::find_connec
void nano::bootstrap_connections::connect_client (nano::tcp_endpoint const & endpoint_a, bool push_front) void nano::bootstrap_connections::connect_client (nano::tcp_endpoint const & endpoint_a, bool push_front)
{ {
++connections_count; ++connections_count;
auto socket (std::make_shared<nano::transport::socket> (node)); auto socket (std::make_shared<nano::transport::tcp_socket> (node));
auto this_l (shared_from_this ()); auto this_l (shared_from_this ());
socket->async_connect (endpoint_a, socket->async_connect (endpoint_a,
[this_l, socket, endpoint_a, push_front] (boost::system::error_code const & ec) { [this_l, socket, endpoint_a, push_front] (boost::system::error_code const & ec) {

6
nano/node/bootstrap/bootstrap_connections.hpp
View file

@ -2,7 +2,7 @@
#include <nano/node/bootstrap/bootstrap_bulk_pull.hpp> #include <nano/node/bootstrap/bootstrap_bulk_pull.hpp>
#include <nano/node/common.hpp> #include <nano/node/common.hpp>
#include <nano/node/transport/socket.hpp> #include <nano/node/transport/tcp_socket.hpp>
#include <atomic> #include <atomic>
@ -25,7 +25,7 @@ class pull_info;
class bootstrap_client final : public std::enable_shared_from_this<bootstrap_client> class bootstrap_client final : public std::enable_shared_from_this<bootstrap_client>
{ {
public: public:
bootstrap_client (std::shared_ptr<nano::node> const & node_a, std::shared_ptr<nano::transport::tcp_channel> const & channel_a, std::shared_ptr<nano::transport::socket> const & socket_a); bootstrap_client (std::shared_ptr<nano::node> const & node_a, std::shared_ptr<nano::transport::tcp_channel> const & channel_a, std::shared_ptr<nano::transport::tcp_socket> const & socket_a);
~bootstrap_client (); ~bootstrap_client ();
void stop (bool force); void stop (bool force);
double sample_block_rate (); double sample_block_rate ();
@ -33,7 +33,7 @@ public:
void set_start_time (std::chrono::steady_clock::time_point start_time_a); void set_start_time (std::chrono::steady_clock::time_point start_time_a);
std::weak_ptr<nano::node> node; std::weak_ptr<nano::node> node;
std::shared_ptr<nano::transport::tcp_channel> channel; std::shared_ptr<nano::transport::tcp_channel> channel;
std::shared_ptr<nano::transport::socket> socket; std::shared_ptr<nano::transport::tcp_socket> socket;
std::shared_ptr<std::vector<uint8_t>> receive_buffer; std::shared_ptr<std::vector<uint8_t>> receive_buffer;
std::atomic<uint64_t> block_count{ 0 }; std::atomic<uint64_t> block_count{ 0 };
std::atomic<double> block_rate{ 0 }; std::atomic<double> block_rate{ 0 };

2
nano/node/node_observers.hpp
View file

@ -33,7 +33,7 @@ public:
nano::observer_set<> disconnect; nano::observer_set<> disconnect;
nano::observer_set<nano::root const &> work_cancel; nano::observer_set<nano::root const &> work_cancel;
nano::observer_set<nano::telemetry_data const &, std::shared_ptr<nano::transport::channel> const &> telemetry; nano::observer_set<nano::telemetry_data const &, std::shared_ptr<nano::transport::channel> const &> telemetry;
nano::observer_set<nano::transport::socket &> socket_connected; nano::observer_set<nano::transport::tcp_socket &> socket_connected;
}; };
std::unique_ptr<container_info_component> collect_container_info (node_observers & node_observers, std::string const & name); std::unique_ptr<container_info_component> collect_container_info (node_observers & node_observers, std::string const & name);

2
nano/node/transport/channel.hpp
View file

@ -6,7 +6,7 @@
#include <nano/node/bandwidth_limiter.hpp> #include <nano/node/bandwidth_limiter.hpp>
#include <nano/node/common.hpp> #include <nano/node/common.hpp>
#include <nano/node/messages.hpp> #include <nano/node/messages.hpp>
#include <nano/node/transport/socket.hpp> #include <nano/node/transport/tcp_socket.hpp>
#include <boost/asio/ip/network_v6.hpp> #include <boost/asio/ip/network_v6.hpp>

1
nano/node/transport/fwd.hpp
View file

@ -5,4 +5,5 @@ namespace nano::transport
class channel; class channel;
class tcp_channel; class tcp_channel;
class tcp_channels; class tcp_channels;
class tcp_socket;
} }

2
nano/node/transport/tcp_channel.cpp
View file

@ -8,7 +8,7 @@
* tcp_channel * tcp_channel
*/ */
nano::transport::tcp_channel::tcp_channel (nano::node & node_a, std::weak_ptr<nano::transport::socket> socket_a) : nano::transport::tcp_channel::tcp_channel (nano::node & node_a, std::weak_ptr<nano::transport::tcp_socket> socket_a) :
channel (node_a), channel (node_a),
socket (std::move (socket_a)) socket (std::move (socket_a))
{ {

4
nano/node/transport/tcp_channel.hpp
View file

@ -14,7 +14,7 @@ class tcp_channel : public nano::transport::channel, public std::enable_shared_f
friend class nano::transport::tcp_channels; friend class nano::transport::tcp_channels;
public: public:
tcp_channel (nano::node &, std::weak_ptr<nano::transport::socket>); tcp_channel (nano::node &, std::weak_ptr<nano::transport::tcp_socket>);
~tcp_channel () override; ~tcp_channel () override;
void update_endpoints (); void update_endpoints ();
@ -74,7 +74,7 @@ public:
} }
public: public:
std::weak_ptr<nano::transport::socket> socket; std::weak_ptr<nano::transport::tcp_socket> socket;
private: private:
nano::endpoint endpoint; nano::endpoint endpoint;

2
nano/node/transport/tcp_channels.cpp
View file

@ -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 // This should be the only place in node where channels are created
std::shared_ptr<nano::transport::tcp_channel> nano::transport::tcp_channels::create (const std::shared_ptr<nano::transport::socket> & socket, const std::shared_ptr<nano::transport::tcp_server> & server, const nano::account & node_id) std::shared_ptr<nano::transport::tcp_channel> nano::transport::tcp_channels::create (const std::shared_ptr<nano::transport::tcp_socket> & socket, const std::shared_ptr<nano::transport::tcp_server> & server, const nano::account & node_id)
{ {
auto const endpoint = socket->remote_endpoint (); auto const endpoint = socket->remote_endpoint ();
debug_assert (endpoint.address ().is_v6 ()); debug_assert (endpoint.address ().is_v6 ());

6
nano/node/transport/tcp_channels.hpp
View file

@ -34,7 +34,7 @@ public:
void start (); void start ();
void stop (); void stop ();
std::shared_ptr<nano::transport::tcp_channel> create (std::shared_ptr<nano::transport::socket> const &, std::shared_ptr<nano::transport::tcp_server> const &, nano::account const & node_id); std::shared_ptr<nano::transport::tcp_channel> create (std::shared_ptr<nano::transport::tcp_socket> const &, std::shared_ptr<nano::transport::tcp_server> const &, nano::account const & node_id);
void erase (nano::tcp_endpoint const &); void erase (nano::tcp_endpoint const &);
std::size_t size () const; std::size_t size () const;
std::shared_ptr<nano::transport::tcp_channel> find_channel (nano::tcp_endpoint const &) const; std::shared_ptr<nano::transport::tcp_channel> find_channel (nano::tcp_endpoint const &) const;
@ -70,11 +70,11 @@ private:
{ {
public: public:
std::shared_ptr<nano::transport::tcp_channel> channel; std::shared_ptr<nano::transport::tcp_channel> channel;
std::shared_ptr<nano::transport::socket> socket; std::shared_ptr<nano::transport::tcp_socket> socket;
std::shared_ptr<nano::transport::tcp_server> response_server; std::shared_ptr<nano::transport::tcp_server> response_server;
public: public:
channel_entry (std::shared_ptr<nano::transport::tcp_channel> channel_a, std::shared_ptr<nano::transport::socket> socket_a, std::shared_ptr<nano::transport::tcp_server> server_a) : channel_entry (std::shared_ptr<nano::transport::tcp_channel> channel_a, std::shared_ptr<nano::transport::tcp_socket> socket_a, std::shared_ptr<nano::transport::tcp_server> server_a) :
channel (std::move (channel_a)), socket (std::move (socket_a)), response_server (std::move (server_a)) channel (std::move (channel_a)), socket (std::move (socket_a)), response_server (std::move (server_a))
{ {
} }

4
nano/node/transport/tcp_listener.cpp
View file

@ -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)); 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)); logger.debug (nano::log::type::tcp_listener, "Accepted connection: {} ({})", fmt::streamed (remote_endpoint), to_string (type));
auto socket = std::make_shared<nano::transport::socket> (node, std::move (raw_socket), remote_endpoint, local_endpoint, to_socket_endpoint (type)); auto socket = std::make_shared<nano::transport::tcp_socket> (node, std::move (raw_socket), remote_endpoint, local_endpoint, to_socket_endpoint (type));
auto server = std::make_shared<nano::transport::tcp_server> (socket, node.shared (), true); auto server = std::make_shared<nano::transport::tcp_server> (socket, node.shared (), true);
connections.emplace_back (connection{ remote_endpoint, socket, server }); 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 () }; return { asio::ip::address_v6::loopback (), local.port () };
} }
auto nano::transport::tcp_listener::sockets () const -> std::vector<std::shared_ptr<socket>> auto nano::transport::tcp_listener::sockets () const -> std::vector<std::shared_ptr<tcp_socket>>
{ {
nano::lock_guard<nano::mutex> lock{ mutex }; nano::lock_guard<nano::mutex> lock{ mutex };
auto r = connections auto r = connections

10
nano/node/transport/tcp_listener.hpp
View file

@ -73,13 +73,13 @@ public:
size_t realtime_count () const; size_t realtime_count () const;
size_t bootstrap_count () const; size_t bootstrap_count () const;
std::vector<std::shared_ptr<socket>> sockets () const; std::vector<std::shared_ptr<nano::transport::tcp_socket>> sockets () const;
std::vector<std::shared_ptr<tcp_server>> servers () const; std::vector<std::shared_ptr<nano::transport::tcp_server>> servers () const;
std::unique_ptr<nano::container_info_component> collect_container_info (std::string const & name); std::unique_ptr<nano::container_info_component> collect_container_info (std::string const & name);
public: // Events public: // Events
using connection_accepted_event_t = nano::observer_set<std::shared_ptr<nano::transport::socket> const &, std::shared_ptr<nano::transport::tcp_server>>; using connection_accepted_event_t = nano::observer_set<std::shared_ptr<nano::transport::tcp_socket> const &, std::shared_ptr<nano::transport::tcp_server>>;
connection_accepted_event_t connection_accepted; connection_accepted_event_t connection_accepted;
private: // Dependencies private: // Dependencies
@ -116,7 +116,7 @@ private:
struct accept_return struct accept_return
{ {
accept_result result; accept_result result;
std::shared_ptr<nano::transport::socket> socket; std::shared_ptr<nano::transport::tcp_socket> socket;
std::shared_ptr<nano::transport::tcp_server> server; std::shared_ptr<nano::transport::tcp_server> server;
}; };
@ -133,7 +133,7 @@ private:
struct connection struct connection
{ {
asio::ip::tcp::endpoint endpoint; asio::ip::tcp::endpoint endpoint;
std::weak_ptr<nano::transport::socket> socket; std::weak_ptr<nano::transport::tcp_socket> socket;
std::weak_ptr<nano::transport::tcp_server> server; std::weak_ptr<nano::transport::tcp_server> server;
asio::ip::address address () const asio::ip::address address () const

2
nano/node/transport/tcp_server.cpp
View file

@ -12,7 +12,7 @@
* tcp_server * tcp_server
*/ */
nano::transport::tcp_server::tcp_server (std::shared_ptr<nano::transport::socket> socket_a, std::shared_ptr<nano::node> node_a, bool allow_bootstrap_a) : nano::transport::tcp_server::tcp_server (std::shared_ptr<nano::transport::tcp_socket> socket_a, std::shared_ptr<nano::node> node_a, bool allow_bootstrap_a) :
socket{ socket_a }, socket{ socket_a },
node{ node_a }, node{ node_a },
allow_bootstrap{ allow_bootstrap_a }, allow_bootstrap{ allow_bootstrap_a },

6
nano/node/transport/tcp_server.hpp
View file

@ -3,7 +3,7 @@
#include <nano/node/common.hpp> #include <nano/node/common.hpp>
#include <nano/node/messages.hpp> #include <nano/node/messages.hpp>
#include <nano/node/transport/fwd.hpp> #include <nano/node/transport/fwd.hpp>
#include <nano/node/transport/socket.hpp> #include <nano/node/transport/tcp_socket.hpp>
#include <atomic> #include <atomic>
@ -20,7 +20,7 @@ class tcp_server;
class tcp_server final : public std::enable_shared_from_this<tcp_server> class tcp_server final : public std::enable_shared_from_this<tcp_server>
{ {
public: public:
tcp_server (std::shared_ptr<nano::transport::socket>, std::shared_ptr<nano::node>, bool allow_bootstrap = true); tcp_server (std::shared_ptr<nano::transport::tcp_socket>, std::shared_ptr<nano::node>, bool allow_bootstrap = true);
~tcp_server (); ~tcp_server ();
void start (); void start ();
@ -31,7 +31,7 @@ public:
void set_last_keepalive (nano::keepalive const & message); void set_last_keepalive (nano::keepalive const & message);
std::optional<nano::keepalive> pop_last_keepalive (); std::optional<nano::keepalive> pop_last_keepalive ();
std::shared_ptr<nano::transport::socket> const socket; std::shared_ptr<nano::transport::tcp_socket> const socket;
std::weak_ptr<nano::node> const node; std::weak_ptr<nano::node> const node;
nano::mutex mutex; nano::mutex mutex;
std::atomic<bool> stopped{ false }; std::atomic<bool> stopped{ false };

70
nano/node/transport/socket.cpp → nano/node/transport/tcp_socket.cpp
View file

@ -2,7 +2,7 @@
#include <nano/boost/asio/read.hpp> #include <nano/boost/asio/read.hpp>
#include <nano/lib/enum_util.hpp> #include <nano/lib/enum_util.hpp>
#include <nano/node/node.hpp> #include <nano/node/node.hpp>
#include <nano/node/transport/socket.hpp> #include <nano/node/transport/tcp_socket.hpp>
#include <nano/node/transport/transport.hpp> #include <nano/node/transport/transport.hpp>
#include <boost/format.hpp> #include <boost/format.hpp>
@ -18,16 +18,16 @@
* socket * socket
*/ */
nano::transport::socket::socket (nano::node & node_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, 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 } 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 }, send_queue{ max_queue_size_a },
node_w{ node_a.shared () }, node_w{ node_a.shared () },
strand{ node_a.io_ctx.get_executor () }, 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 }, remote{ remote_endpoint_a },
local{ local_endpoint_a }, local{ local_endpoint_a },
endpoint_type_m{ endpoint_type_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 (); close_internal ();
closed = true; closed = true;
} }
void nano::transport::socket::start () void nano::transport::tcp_socket::start ()
{ {
ongoing_checkup (); ongoing_checkup ();
} }
void nano::transport::socket::async_connect (nano::tcp_endpoint const & endpoint_a, std::function<void (boost::system::error_code const &)> callback_a) void nano::transport::tcp_socket::async_connect (nano::tcp_endpoint const & endpoint_a, std::function<void (boost::system::error_code const &)> callback_a)
{ {
debug_assert (callback_a); debug_assert (callback_a);
debug_assert (endpoint_type () == socket_endpoint::client); 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 (); set_default_timeout ();
boost::asio::post (strand, [this_l = shared_from_this (), endpoint_a, callback = std::move (callback_a)] () { 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, boost::asio::bind_executor (this_l->strand,
[this_l, callback = std::move (callback), endpoint_a] (boost::system::error_code const & ec) { [this_l, callback = std::move (callback), endpoint_a] (boost::system::error_code const & ec) {
debug_assert (this_l->strand.running_in_this_thread ()); 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 // Best effort attempt to get endpoint address
boost::system::error_code ec; 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); 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<std::vector<uint8_t>> const & buffer_a, std::size_t size_a, std::function<void (boost::system::error_code const &, std::size_t)> callback_a) void nano::transport::tcp_socket::async_read (std::shared_ptr<std::vector<uint8_t>> const & buffer_a, std::size_t size_a, std::function<void (boost::system::error_code const &, std::size_t)> callback_a)
{ {
debug_assert (callback_a); debug_assert (callback_a);
@ -102,7 +102,7 @@ void nano::transport::socket::async_read (std::shared_ptr<std::vector<uint8_t>>
{ {
set_default_timeout (); set_default_timeout ();
boost::asio::post (strand, [this_l = shared_from_this (), buffer_a, callback = std::move (callback_a), size_a] () mutable { 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, 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) { [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 ()); debug_assert (this_l->strand.running_in_this_thread ());
@ -131,13 +131,13 @@ void nano::transport::socket::async_read (std::shared_ptr<std::vector<uint8_t>>
} }
else 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); boost::system::error_code ec_buffer = boost::system::errc::make_error_code (boost::system::errc::no_buffer_space);
callback_a (ec_buffer, 0); callback_a (ec_buffer, 0);
} }
} }
void nano::transport::socket::async_write (nano::shared_const_buffer const & buffer_a, std::function<void (boost::system::error_code const &, std::size_t)> callback_a, nano::transport::traffic_type traffic_type) void nano::transport::tcp_socket::async_write (nano::shared_const_buffer const & buffer_a, std::function<void (boost::system::error_code const &, std::size_t)> callback_a, nano::transport::traffic_type traffic_type)
{ {
auto node_l = node_w.lock (); auto node_l = node_w.lock ();
if (!node_l) if (!node_l)
@ -177,7 +177,7 @@ void nano::transport::socket::async_write (nano::shared_const_buffer const & buf
} }
// Must be called from strand // 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 ()); debug_assert (strand.running_in_this_thread ());
@ -195,7 +195,7 @@ void nano::transport::socket::write_queued_messages ()
set_default_timeout (); set_default_timeout ();
write_in_progress = true; 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) { 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 ()); 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; 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; return send_queue.size (traffic_type) >= 2 * max_queue_size;
} }
/** Call set_timeout with default_timeout as parameter */ /** 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); set_timeout (default_timeout);
} }
@ -251,22 +251,22 @@ void nano::transport::socket::set_default_timeout ()
* to set infinite timeout, use std::numeric_limits<uint64_t>::max () * to set infinite timeout, use std::numeric_limits<uint64_t>::max ()
* the function checkup() checks for timeout on a regular interval * 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 (); 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 (); 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 (); 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 (); auto node_l = node_w.lock ();
if (!node_l) if (!node_l)
@ -288,7 +288,7 @@ void nano::transport::socket::ongoing_checkup ()
} }
boost::asio::post (this_l->strand, [this_l] { 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 (); this_l->close ();
} }
@ -327,7 +327,7 @@ void nano::transport::socket::ongoing_checkup ()
}); });
} }
void nano::transport::socket::read_impl (std::shared_ptr<std::vector<uint8_t>> const & data_a, std::size_t size_a, std::function<void (boost::system::error_code const &, std::size_t)> callback_a) void nano::transport::tcp_socket::read_impl (std::shared_ptr<std::vector<uint8_t>> const & data_a, std::size_t size_a, std::function<void (boost::system::error_code const &, std::size_t)> callback_a)
{ {
auto node_l = node_w.lock (); auto node_l = node_w.lock ();
if (!node_l) if (!node_l)
@ -344,22 +344,22 @@ void nano::transport::socket::read_impl (std::shared_ptr<std::vector<uint8_t>> c
}); });
} }
bool nano::transport::socket::has_timed_out () const bool nano::transport::tcp_socket::has_timed_out () const
{ {
return timed_out; 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; 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; return default_timeout;
} }
void nano::transport::socket::close () void nano::transport::tcp_socket::close ()
{ {
boost::asio::dispatch (strand, [this_l = shared_from_this ()] { boost::asio::dispatch (strand, [this_l = shared_from_this ()] {
this_l->close_internal (); this_l->close_internal ();
@ -367,7 +367,7 @@ void nano::transport::socket::close ()
} }
// This must be called from a strand or the destructor // 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 (); auto node_l = node_w.lock ();
if (!node_l) if (!node_l)
@ -386,8 +386,8 @@ void nano::transport::socket::close_internal ()
// Ignore error code for shutdown as it is best-effort // Ignore error code for shutdown as it is best-effort
boost::system::error_code ec; boost::system::error_code ec;
tcp_socket.shutdown (boost::asio::ip::tcp::socket::shutdown_both, ec); raw_socket.shutdown (boost::asio::ip::tcp::socket::shutdown_both, ec);
tcp_socket.close (ec); raw_socket.close (ec);
if (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 // Using cached value to avoid calling tcp_socket.remote_endpoint() which may be invalid (throw) after closing the socket
return remote; 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 // Using cached value to avoid calling tcp_socket.local_endpoint() which may be invalid (throw) after closing the socket
return local; 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 ("remote_endpoint", remote_endpoint ());
obs.write ("local_endpoint", local_endpoint ()); obs.write ("local_endpoint", local_endpoint ());

12
nano/node/transport/socket.hpp → nano/node/transport/tcp_socket.hpp
View file

@ -58,7 +58,7 @@ private:
}; };
/** Socket class for tcp clients and newly accepted connections */ /** Socket class for tcp clients and newly accepted connections */
class socket final : public std::enable_shared_from_this<socket> class tcp_socket final : public std::enable_shared_from_this<tcp_socket>
{ {
friend class tcp_server; friend class tcp_server;
friend class tcp_channels; friend class tcp_channels;
@ -68,10 +68,10 @@ public:
static std::size_t constexpr default_max_queue_size = 128; static std::size_t constexpr default_max_queue_size = 128;
public: 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 // 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 &, nano::node &,
boost::asio::ip::tcp::socket, boost::asio::ip::tcp::socket,
boost::asio::ip::tcp::endpoint remote_endpoint, boost::asio::ip::tcp::endpoint remote_endpoint,
@ -79,7 +79,7 @@ public:
nano::transport::socket_endpoint = socket_endpoint::server, nano::transport::socket_endpoint = socket_endpoint::server,
std::size_t max_queue_size = default_max_queue_size); std::size_t max_queue_size = default_max_queue_size);
~socket (); ~tcp_socket ();
void start (); void start ();
void close (); void close ();
@ -147,7 +147,7 @@ protected:
std::weak_ptr<nano::node> node_w; std::weak_ptr<nano::node> node_w;
boost::asio::strand<boost::asio::io_context::executor_type> strand; boost::asio::strand<boost::asio::io_context::executor_type> strand;
boost::asio::ip::tcp::socket tcp_socket; boost::asio::ip::tcp::socket raw_socket;
/** The other end of the connection */ /** The other end of the connection */
boost::asio::ip::tcp::endpoint remote; boost::asio::ip::tcp::endpoint remote;
@ -205,7 +205,7 @@ public: // Logging
virtual void operator() (nano::object_stream &) const; virtual void operator() (nano::object_stream &) const;
}; };
using address_socket_mmap = std::multimap<boost::asio::ip::address, std::weak_ptr<socket>>; using address_socket_mmap = std::multimap<boost::asio::ip::address, std::weak_ptr<tcp_socket>>;
namespace socket_functions namespace socket_functions
{ {

2
nano/node/transport/transport.hpp
View file

@ -5,7 +5,7 @@
#include <nano/node/bandwidth_limiter.hpp> #include <nano/node/bandwidth_limiter.hpp>
#include <nano/node/common.hpp> #include <nano/node/common.hpp>
#include <nano/node/messages.hpp> #include <nano/node/messages.hpp>
#include <nano/node/transport/socket.hpp> #include <nano/node/transport/tcp_socket.hpp>
#include <boost/asio/ip/network_v6.hpp> #include <boost/asio/ip/network_v6.hpp>