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

Move socket to nano::transport namespace (#4156)

Browse source
This commit is contained in:
Piotr Wójcik 2023-02-25 19:45:37 +01:00 • committed by GitHub
commit 0526a8b62b
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
38 changed files with 262 additions and 253 deletions
Download patch file Download diff file Expand all files Collapse all files

54
nano/core_test/bootstrap.cpp
View file

@ -13,7 +13,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::socket> (*system.nodes[0], nano::socket::endpoint_type_t::server), system.nodes[0])); auto connection (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::socket> (*system.nodes[0], nano::transport::socket::endpoint_type_t::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;
@ -25,7 +25,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::socket> (*system.nodes[0], nano::socket::endpoint_type_t::server), system.nodes[0])); auto connection (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::socket> (*system.nodes[0], nano::transport::socket::endpoint_type_t::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 ();
@ -38,7 +38,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::socket> (*system.nodes[0], nano::socket::endpoint_type_t::server), system.nodes[0])); auto connection (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::socket> (*system.nodes[0], nano::transport::socket::endpoint_type_t::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;
@ -70,7 +70,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::process_result::progress, system.nodes[0]->process (*open).code); ASSERT_EQ (nano::process_result::progress, system.nodes[0]->process (*open).code);
auto connection (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::socket> (*system.nodes[0], nano::socket::endpoint_type_t::server), system.nodes[0])); auto connection (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::socket> (*system.nodes[0], nano::transport::socket::endpoint_type_t::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 ();
@ -81,7 +81,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::socket> (*system.nodes[0], nano::socket::endpoint_type_t::server), system.nodes[0])); auto connection (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::socket> (*system.nodes[0], nano::transport::socket::endpoint_type_t::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 ();
@ -93,7 +93,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::socket> (*system.nodes[0], nano::socket::endpoint_type_t::server), system.nodes[0])); auto connection (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::socket> (*system.nodes[0], nano::transport::socket::endpoint_type_t::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 ();
@ -123,7 +123,7 @@ TEST (bulk_pull, ascending_one_hash)
.build_shared (); .build_shared ();
node.work_generate_blocking (*block1); node.work_generate_blocking (*block1);
ASSERT_EQ (nano::process_result::progress, node.process (*block1).code); ASSERT_EQ (nano::process_result::progress, node.process (*block1).code);
auto socket = std::make_shared<nano::socket> (node, nano::socket::endpoint_type_t::server); auto socket = std::make_shared<nano::transport::socket> (node, nano::transport::socket::endpoint_type_t::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 ();
@ -155,7 +155,7 @@ TEST (bulk_pull, ascending_two_account)
.build_shared (); .build_shared ();
node.work_generate_blocking (*block1); node.work_generate_blocking (*block1);
ASSERT_EQ (nano::process_result::progress, node.process (*block1).code); ASSERT_EQ (nano::process_result::progress, node.process (*block1).code);
auto socket = std::make_shared<nano::socket> (node, nano::socket::endpoint_type_t::server); auto socket = std::make_shared<nano::transport::socket> (node, nano::transport::socket::endpoint_type_t::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 ();
@ -190,7 +190,7 @@ TEST (bulk_pull, ascending_end)
.build_shared (); .build_shared ();
node.work_generate_blocking (*block1); node.work_generate_blocking (*block1);
ASSERT_EQ (nano::process_result::progress, node.process (*block1).code); ASSERT_EQ (nano::process_result::progress, node.process (*block1).code);
auto socket = std::make_shared<nano::socket> (node, nano::socket::endpoint_type_t::server); auto socket = std::make_shared<nano::transport::socket> (node, nano::transport::socket::endpoint_type_t::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;
@ -206,7 +206,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::socket> (*system.nodes[0], nano::socket::endpoint_type_t::server), system.nodes[0])); auto connection (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::socket> (*system.nodes[0], nano::transport::socket::endpoint_type_t::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 ();
@ -222,7 +222,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::socket> (*system.nodes[0], nano::socket::endpoint_type_t::server), system.nodes[0])); auto connection (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::socket> (*system.nodes[0], nano::transport::socket::endpoint_type_t::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 ();
@ -259,7 +259,7 @@ TEST (bulk_pull, count_limit)
.build_shared (); .build_shared ();
ASSERT_EQ (nano::process_result::progress, node0->process (*receive1).code); ASSERT_EQ (nano::process_result::progress, node0->process (*receive1).code);
auto connection (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::socket> (*node0, nano::socket::endpoint_type_t::server), node0)); auto connection (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::socket> (*node0, nano::transport::socket::endpoint_type_t::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);
@ -1643,7 +1643,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::socket> (*system.nodes[0], nano::socket::endpoint_type_t::server), system.nodes[0])); auto connection (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::socket> (*system.nodes[0], nano::transport::socket::endpoint_type_t::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 ();
@ -1656,7 +1656,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::socket> (*system.nodes[0], nano::socket::endpoint_type_t::server), system.nodes[0])); auto connection (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::socket> (*system.nodes[0], nano::transport::socket::endpoint_type_t::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 ();
@ -1697,7 +1697,7 @@ TEST (frontier_req, count)
node1->work_generate_blocking (*receive1); node1->work_generate_blocking (*receive1);
ASSERT_EQ (nano::process_result::progress, node1->process (*receive1).code); ASSERT_EQ (nano::process_result::progress, node1->process (*receive1).code);
auto connection (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::socket> (*node1, nano::socket::endpoint_type_t::server), node1)); auto connection (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::socket> (*node1, nano::transport::socket::endpoint_type_t::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 ();
@ -1710,7 +1710,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::socket> (*system.nodes[0], nano::socket::endpoint_type_t::server), system.nodes[0])); auto connection (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::socket> (*system.nodes[0], nano::transport::socket::endpoint_type_t::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;
@ -1723,7 +1723,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::socket> (*system.nodes[0], nano::socket::endpoint_type_t::server), system.nodes[0])); auto connection2 (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::socket> (*system.nodes[0], nano::transport::socket::endpoint_type_t::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 ());
} }
@ -1731,7 +1731,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::socket> (*system.nodes[0], nano::socket::endpoint_type_t::server), system.nodes[0])); auto connection (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::socket> (*system.nodes[0], nano::transport::socket::endpoint_type_t::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;
@ -1745,7 +1745,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::socket> (*system.nodes[0], nano::socket::endpoint_type_t::server), system.nodes[0])); auto connection2 (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::socket> (*system.nodes[0], nano::transport::socket::endpoint_type_t::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 ());
} }
@ -1817,7 +1817,7 @@ TEST (frontier_req, confirmed_frontier)
ASSERT_EQ (nano::process_result::progress, node1->process (*receive2).code); ASSERT_EQ (nano::process_result::progress, node1->process (*receive2).code);
// 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::socket> (*node1, nano::socket::endpoint_type_t::server), node1)); auto connection (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::socket> (*node1, nano::transport::socket::endpoint_type_t::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 ();
@ -1830,7 +1830,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::socket> (*node1, nano::socket::endpoint_type_t::server), node1)); auto connection2 (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::socket> (*node1, nano::transport::socket::endpoint_type_t::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 ();
@ -1843,7 +1843,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::socket> (*node1, nano::socket::endpoint_type_t::server), node1)); auto connection3 (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::socket> (*node1, nano::transport::socket::endpoint_type_t::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 ();
@ -1856,7 +1856,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::socket> (*node1, nano::socket::endpoint_type_t::server), node1)); auto connection4 (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::socket> (*node1, nano::transport::socket::endpoint_type_t::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 ();
@ -1867,7 +1867,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::socket> (*node1, nano::socket::endpoint_type_t::server), node1)); auto connection5 (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::socket> (*node1, nano::transport::socket::endpoint_type_t::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 ();
@ -1880,7 +1880,7 @@ TEST (frontier_req, confirmed_frontier)
// Confirm account before genesis (confirmed only) // Confirm account before genesis (confirmed only)
nano::test::start_elections (system, *node1, { send1, receive1 }, true); nano::test::start_elections (system, *node1, { send1, receive1 }, true);
ASSERT_TIMELY (5s, node1->block_confirmed (send1->hash ()) && node1->block_confirmed (receive1->hash ())); ASSERT_TIMELY (5s, node1->block_confirmed (send1->hash ()) && node1->block_confirmed (receive1->hash ()));
auto connection6 (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::socket> (*node1, nano::socket::endpoint_type_t::server), node1)); auto connection6 (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::socket> (*node1, nano::transport::socket::endpoint_type_t::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 ();
@ -1895,7 +1895,7 @@ TEST (frontier_req, confirmed_frontier)
// Confirm account after genesis (confirmed only) // Confirm account after genesis (confirmed only)
nano::test::start_elections (system, *node1, { send2, receive2 }, true); nano::test::start_elections (system, *node1, { send2, receive2 }, true);
ASSERT_TIMELY (5s, node1->block_confirmed (send2->hash ()) && node1->block_confirmed (receive2->hash ())); ASSERT_TIMELY (5s, node1->block_confirmed (send2->hash ()) && node1->block_confirmed (receive2->hash ()));
auto connection7 (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::socket> (*node1, nano::socket::endpoint_type_t::server), node1)); auto connection7 (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::socket> (*node1, nano::transport::socket::endpoint_type_t::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 ();
@ -2071,7 +2071,7 @@ TEST (bulk_pull_account, basics)
auto send2 (system.wallet (0)->send_action (nano::dev::genesis->account (), key1.pub, 10)); auto send2 (system.wallet (0)->send_action (nano::dev::genesis->account (), key1.pub, 10));
auto send3 (system.wallet (0)->send_action (nano::dev::genesis->account (), key1.pub, 2)); auto send3 (system.wallet (0)->send_action (nano::dev::genesis->account (), key1.pub, 2));
ASSERT_TIMELY (5s, system.nodes[0]->balance (key1.pub) == 25); ASSERT_TIMELY (5s, system.nodes[0]->balance (key1.pub) == 25);
auto connection (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::socket> (*system.nodes[0], nano::socket::endpoint_type_t::server), system.nodes[0])); auto connection (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::socket> (*system.nodes[0], nano::transport::socket::endpoint_type_t::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);

30
nano/core_test/network.cpp
View file

@ -1,7 +1,7 @@
#include <nano/node/network.hpp> #include <nano/node/network.hpp>
#include <nano/node/nodeconfig.hpp> #include <nano/node/nodeconfig.hpp>
#include <nano/node/socket.hpp>
#include <nano/node/transport/inproc.hpp> #include <nano/node/transport/inproc.hpp>
#include <nano/node/transport/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>
@ -177,8 +177,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::socket> sock0 = channel0->socket.lock (); std::shared_ptr<nano::transport::socket> sock0 = channel0->socket.lock ();
std::shared_ptr<nano::socket> sock1 = channel1->socket.lock (); std::shared_ptr<nano::transport::socket> sock1 = channel1->socket.lock ();
ASSERT_TRUE (sock0->local_endpoint () == sock1->remote_endpoint ()); ASSERT_TRUE (sock0->local_endpoint () == sock1->remote_endpoint ());
ASSERT_TRUE (sock1->local_endpoint () == sock0->remote_endpoint ()); ASSERT_TRUE (sock1->local_endpoint () == sock0->remote_endpoint ());
} }
@ -703,7 +703,7 @@ TEST (node, port_mapping)
TEST (tcp_listener, tcp_node_id_handshake) TEST (tcp_listener, tcp_node_id_handshake)
{ {
nano::test::system system (1); nano::test::system system (1);
auto socket (std::make_shared<nano::client_socket> (*system.nodes[0])); auto socket (std::make_shared<nano::transport::client_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)));
nano::node_id_handshake node_id_handshake{ nano::dev::network_params.network, cookie, boost::none }; nano::node_id_handshake node_id_handshake{ nano::dev::network_params.network, cookie, boost::none };
@ -739,7 +739,7 @@ TEST (tcp_listener, DISABLED_tcp_listener_timeout_empty)
{ {
nano::test::system system (1); nano::test::system system (1);
auto node0 (system.nodes[0]); auto node0 (system.nodes[0]);
auto socket (std::make_shared<nano::client_socket> (*node0)); auto socket (std::make_shared<nano::transport::client_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);
@ -762,7 +762,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::client_socket> (*node0)); auto socket (std::make_shared<nano::transport::client_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 ())));
nano::node_id_handshake node_id_handshake{ nano::dev::network_params.network, cookie, boost::none }; nano::node_id_handshake node_id_handshake{ nano::dev::network_params.network, cookie, boost::none };
auto channel = std::make_shared<nano::transport::channel_tcp> (*node0, socket); auto channel = std::make_shared<nano::transport::channel_tcp> (*node0, socket);
@ -919,7 +919,7 @@ TEST (network, bandwidth_limiter)
ASSERT_TIMELY (1s, 1 == node.stats.count (nano::stat::type::drop, nano::stat::detail::publish, nano::stat::dir::out)); ASSERT_TIMELY (1s, 1 == node.stats.count (nano::stat::type::drop, nano::stat::detail::publish, nano::stat::dir::out));
// Send non-droppable message, i.e. drop stats should not increase // Send non-droppable message, i.e. drop stats should not increase
channel2.send (message, nullptr, nano::buffer_drop_policy::no_limiter_drop); channel2.send (message, nullptr, nano::transport::buffer_drop_policy::no_limiter_drop);
ASSERT_TIMELY (1s, 1 == node.stats.count (nano::stat::type::drop, nano::stat::detail::publish, nano::stat::dir::out)); ASSERT_TIMELY (1s, 1 == node.stats.count (nano::stat::type::drop, nano::stat::detail::publish, nano::stat::dir::out));
// change the bandwidth settings, 2 packets will be dropped // change the bandwidth settings, 2 packets will be dropped
@ -1195,11 +1195,11 @@ TEST (network, purge_dead_channel_outgoing)
auto & node1 = *system.add_node (flags); auto & node1 = *system.add_node (flags);
// We expect one incoming and one outgoing connection // We expect one incoming and one outgoing connection
std::shared_ptr<nano::socket> outgoing; std::shared_ptr<nano::transport::socket> outgoing;
std::shared_ptr<nano::socket> incoming; std::shared_ptr<nano::transport::socket> incoming;
std::atomic<int> connected_count{ 0 }; std::atomic<int> connected_count{ 0 };
node1.observers.socket_connected.add ([&] (nano::socket & socket) { node1.observers.socket_connected.add ([&] (nano::transport::socket & socket) {
connected_count++; connected_count++;
outgoing = socket.shared_from_this (); outgoing = socket.shared_from_this ();
@ -1207,7 +1207,7 @@ TEST (network, purge_dead_channel_outgoing)
}); });
std::atomic<int> accepted_count{ 0 }; std::atomic<int> accepted_count{ 0 };
node1.observers.socket_accepted.add ([&] (nano::socket & socket) { node1.observers.socket_accepted.add ([&] (nano::transport::socket & socket) {
accepted_count++; accepted_count++;
incoming = socket.shared_from_this (); incoming = socket.shared_from_this ();
@ -1267,11 +1267,11 @@ TEST (network, purge_dead_channel_incoming)
auto & node1 = *system.add_node (flags); auto & node1 = *system.add_node (flags);
// We expect one incoming and one outgoing connection // We expect one incoming and one outgoing connection
std::shared_ptr<nano::socket> outgoing; std::shared_ptr<nano::transport::socket> outgoing;
std::shared_ptr<nano::socket> incoming; std::shared_ptr<nano::transport::socket> incoming;
std::atomic<int> connected_count{ 0 }; std::atomic<int> connected_count{ 0 };
node1.observers.socket_connected.add ([&] (nano::socket & socket) { node1.observers.socket_connected.add ([&] (nano::transport::socket & socket) {
connected_count++; connected_count++;
outgoing = socket.shared_from_this (); outgoing = socket.shared_from_this ();
@ -1279,7 +1279,7 @@ TEST (network, purge_dead_channel_incoming)
}); });
std::atomic<int> accepted_count{ 0 }; std::atomic<int> accepted_count{ 0 };
node1.observers.socket_accepted.add ([&] (nano::socket & socket) { node1.observers.socket_accepted.add ([&] (nano::transport::socket & socket) {
accepted_count++; accepted_count++;
incoming = socket.shared_from_this (); incoming = socket.shared_from_this ();

2
nano/core_test/node.cpp
View file

@ -743,7 +743,7 @@ TEST (node, fork_flip)
.work (*system.work.generate (nano::dev::genesis->hash ())) .work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared (); .build_shared ();
nano::publish publish2{ nano::dev::network_params.network, send2 }; nano::publish publish2{ nano::dev::network_params.network, send2 };
auto ignored_channel{ std::make_shared<nano::transport::channel_tcp> (node1, std::weak_ptr<nano::socket> ()) }; auto ignored_channel{ std::make_shared<nano::transport::channel_tcp> (node1, std::weak_ptr<nano::transport::socket> ()) };
node1.network.inbound (publish1, ignored_channel); node1.network.inbound (publish1, ignored_channel);
node1.block_processor.flush (); node1.block_processor.flush ();

2
nano/core_test/peer_container.cpp
View file

@ -1,4 +1,4 @@
#include <nano/node/socket.hpp> #include <nano/node/transport/socket.hpp>
#include <nano/node/transport/tcp.hpp> #include <nano/node/transport/tcp.hpp>
#include <nano/node/transport/tcp_server.hpp> #include <nano/node/transport/tcp_server.hpp>
#include <nano/test_common/network.hpp> #include <nano/test_common/network.hpp>

20
nano/core_test/request_aggregator.cpp
View file

@ -29,7 +29,7 @@ TEST (request_aggregator, one)
.build_shared (); .build_shared ();
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::client_socket> (node); auto client = std::make_shared<nano::transport::client_socket> (node);
std::shared_ptr<nano::transport::channel> dummy_channel = std::make_shared<nano::transport::channel_tcp> (node, client); std::shared_ptr<nano::transport::channel> dummy_channel = std::make_shared<nano::transport::channel_tcp> (node, client);
node.aggregator.add (dummy_channel, request); node.aggregator.add (dummy_channel, request);
ASSERT_EQ (1, node.aggregator.size ()); ASSERT_EQ (1, node.aggregator.size ());
@ -98,7 +98,7 @@ TEST (request_aggregator, one_update)
ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *receive1).code); ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *receive1).code);
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 ());
auto client = std::make_shared<nano::client_socket> (node); auto client = std::make_shared<nano::transport::client_socket> (node);
std::shared_ptr<nano::transport::channel> dummy_channel = std::make_shared<nano::transport::channel_tcp> (node, client); std::shared_ptr<nano::transport::channel> dummy_channel = std::make_shared<nano::transport::channel_tcp> (node, client);
node.aggregator.add (dummy_channel, request); node.aggregator.add (dummy_channel, request);
request.clear (); request.clear ();
@ -165,7 +165,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::client_socket> (node); auto client = std::make_shared<nano::transport::client_socket> (node);
std::shared_ptr<nano::transport::channel> dummy_channel = std::make_shared<nano::transport::channel_tcp> (node, client); std::shared_ptr<nano::transport::channel> dummy_channel = std::make_shared<nano::transport::channel_tcp> (node, client);
// Process both blocks // Process both blocks
node.aggregator.add (dummy_channel, request); node.aggregator.add (dummy_channel, request);
@ -289,7 +289,7 @@ TEST (request_aggregator, split)
election->force_confirm (); election->force_confirm ();
ASSERT_TIMELY (5s, max_vbh + 2 == node.ledger.cache.cemented_count); ASSERT_TIMELY (5s, max_vbh + 2 == node.ledger.cache.cemented_count);
ASSERT_EQ (max_vbh + 1, request.size ()); ASSERT_EQ (max_vbh + 1, request.size ());
auto client = std::make_shared<nano::client_socket> (node); auto client = std::make_shared<nano::transport::client_socket> (node);
std::shared_ptr<nano::transport::channel> dummy_channel = std::make_shared<nano::transport::channel_tcp> (node, client); std::shared_ptr<nano::transport::channel> dummy_channel = std::make_shared<nano::transport::channel_tcp> (node, client);
node.aggregator.add (dummy_channel, request); node.aggregator.add (dummy_channel, request);
ASSERT_EQ (1, node.aggregator.size ()); ASSERT_EQ (1, node.aggregator.size ());
@ -330,7 +330,7 @@ TEST (request_aggregator, channel_lifetime)
request.emplace_back (send1->hash (), send1->root ()); request.emplace_back (send1->hash (), send1->root ());
{ {
// The aggregator should extend the lifetime of the channel // The aggregator should extend the lifetime of the channel
auto client = std::make_shared<nano::client_socket> (node); auto client = std::make_shared<nano::transport::client_socket> (node);
std::shared_ptr<nano::transport::channel> dummy_channel = std::make_shared<nano::transport::channel_tcp> (node, client); std::shared_ptr<nano::transport::channel> dummy_channel = std::make_shared<nano::transport::channel_tcp> (node, client);
node.aggregator.add (dummy_channel, request); node.aggregator.add (dummy_channel, request);
} }
@ -361,11 +361,11 @@ TEST (request_aggregator, channel_update)
request.emplace_back (send1->hash (), send1->root ()); request.emplace_back (send1->hash (), send1->root ());
std::weak_ptr<nano::transport::channel> channel1_w; std::weak_ptr<nano::transport::channel> channel1_w;
{ {
auto client1 = std::make_shared<nano::client_socket> (node); auto client1 = std::make_shared<nano::transport::client_socket> (node);
std::shared_ptr<nano::transport::channel> dummy_channel1 = std::make_shared<nano::transport::channel_tcp> (node, client1); std::shared_ptr<nano::transport::channel> dummy_channel1 = std::make_shared<nano::transport::channel_tcp> (node, client1);
channel1_w = dummy_channel1; channel1_w = dummy_channel1;
node.aggregator.add (dummy_channel1, request); node.aggregator.add (dummy_channel1, request);
auto client2 = std::make_shared<nano::client_socket> (node); auto client2 = std::make_shared<nano::transport::client_socket> (node);
std::shared_ptr<nano::transport::channel> dummy_channel2 = std::make_shared<nano::transport::channel_tcp> (node, client2); std::shared_ptr<nano::transport::channel> dummy_channel2 = std::make_shared<nano::transport::channel_tcp> (node, client2);
// The aggregator then hold channel2 and drop channel1 // The aggregator then hold channel2 and drop channel1
node.aggregator.add (dummy_channel2, request); node.aggregator.add (dummy_channel2, request);
@ -399,7 +399,7 @@ TEST (request_aggregator, channel_max_queue)
ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send1).code); ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send1).code);
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::client_socket> (node); auto client = std::make_shared<nano::transport::client_socket> (node);
std::shared_ptr<nano::transport::channel> dummy_channel = std::make_shared<nano::transport::channel_tcp> (node, client); std::shared_ptr<nano::transport::channel> dummy_channel = std::make_shared<nano::transport::channel_tcp> (node, client);
node.aggregator.add (dummy_channel, request); node.aggregator.add (dummy_channel, request);
node.aggregator.add (dummy_channel, request); node.aggregator.add (dummy_channel, request);
@ -427,7 +427,7 @@ TEST (request_aggregator, unique)
ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send1).code); ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send1).code);
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::client_socket> (node); auto client = std::make_shared<nano::transport::client_socket> (node);
std::shared_ptr<nano::transport::channel> dummy_channel = std::make_shared<nano::transport::channel_tcp> (node, client); std::shared_ptr<nano::transport::channel> dummy_channel = std::make_shared<nano::transport::channel_tcp> (node, client);
node.aggregator.add (dummy_channel, request); node.aggregator.add (dummy_channel, request);
node.aggregator.add (dummy_channel, request); node.aggregator.add (dummy_channel, request);
@ -474,7 +474,7 @@ TEST (request_aggregator, cannot_vote)
request.emplace_back (send2->hash (), send2->root ()); 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::client_socket> (node); auto client = std::make_shared<nano::transport::client_socket> (node);
std::shared_ptr<nano::transport::channel> dummy_channel = std::make_shared<nano::transport::channel_tcp> (node, client); std::shared_ptr<nano::transport::channel> dummy_channel = std::make_shared<nano::transport::channel_tcp> (node, client);
node.aggregator.add (dummy_channel, request); node.aggregator.add (dummy_channel, request);
ASSERT_EQ (1, node.aggregator.size ()); ASSERT_EQ (1, node.aggregator.size ());

122
nano/core_test/socket.cpp
View file

@ -1,7 +1,7 @@
#include <nano/boost/asio/ip/address_v6.hpp> #include <nano/boost/asio/ip/address_v6.hpp>
#include <nano/boost/asio/ip/network_v6.hpp> #include <nano/boost/asio/ip/network_v6.hpp>
#include <nano/lib/threading.hpp> #include <nano/lib/threading.hpp>
#include <nano/node/socket.hpp> #include <nano/node/transport/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>
@ -27,14 +27,14 @@ TEST (socket, max_connections)
boost::asio::ip::tcp::endpoint dst_endpoint{ boost::asio::ip::address_v6::loopback (), server_port }; boost::asio::ip::tcp::endpoint dst_endpoint{ boost::asio::ip::address_v6::loopback (), server_port };
// start a server socket that allows max 2 live connections // start a server socket that allows max 2 live connections
auto server_socket = std::make_shared<nano::server_socket> (*node, listen_endpoint, 2); auto server_socket = std::make_shared<nano::transport::server_socket> (*node, listen_endpoint, 2);
boost::system::error_code ec; boost::system::error_code ec;
server_socket->start (ec); server_socket->start (ec);
ASSERT_FALSE (ec); ASSERT_FALSE (ec);
// successful incoming connections are stored in server_sockets to keep them alive (server side) // successful incoming connections are stored in server_sockets to keep them alive (server side)
std::vector<std::shared_ptr<nano::socket>> server_sockets; std::vector<std::shared_ptr<nano::transport::socket>> server_sockets;
server_socket->on_connection ([&server_sockets] (std::shared_ptr<nano::socket> const & new_connection, boost::system::error_code const & ec_a) { server_socket->on_connection ([&server_sockets] (std::shared_ptr<nano::transport::socket> const & new_connection, boost::system::error_code const & ec_a) {
server_sockets.push_back (new_connection); server_sockets.push_back (new_connection);
return true; return true;
}); });
@ -48,13 +48,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::client_socket> (*node); auto client1 = std::make_shared<nano::transport::client_socket> (*node);
client1->async_connect (dst_endpoint, connect_handler); client1->async_connect (dst_endpoint, connect_handler);
auto client2 = std::make_shared<nano::client_socket> (*node); auto client2 = std::make_shared<nano::transport::client_socket> (*node);
client2->async_connect (dst_endpoint, connect_handler); client2->async_connect (dst_endpoint, connect_handler);
auto client3 = std::make_shared<nano::client_socket> (*node); auto client3 = std::make_shared<nano::transport::client_socket> (*node);
client3->async_connect (dst_endpoint, connect_handler); client3->async_connect (dst_endpoint, connect_handler);
auto get_tcp_accept_failures = [&node] () { auto get_tcp_accept_failures = [&node] () {
@ -73,10 +73,10 @@ TEST (socket, max_connections)
server_sockets[0].reset (); server_sockets[0].reset ();
auto client4 = std::make_shared<nano::client_socket> (*node); auto client4 = std::make_shared<nano::transport::client_socket> (*node);
client4->async_connect (dst_endpoint, connect_handler); client4->async_connect (dst_endpoint, connect_handler);
auto client5 = std::make_shared<nano::client_socket> (*node); auto client5 = std::make_shared<nano::transport::client_socket> (*node);
client5->async_connect (dst_endpoint, connect_handler); client5->async_connect (dst_endpoint, connect_handler);
ASSERT_TIMELY (5s, get_tcp_accept_failures () == 2); ASSERT_TIMELY (5s, get_tcp_accept_failures () == 2);
@ -90,13 +90,13 @@ TEST (socket, max_connections)
server_sockets[2].reset (); server_sockets[2].reset ();
ASSERT_EQ (server_sockets.size (), 3); ASSERT_EQ (server_sockets.size (), 3);
auto client6 = std::make_shared<nano::client_socket> (*node); auto client6 = std::make_shared<nano::transport::client_socket> (*node);
client6->async_connect (dst_endpoint, connect_handler); client6->async_connect (dst_endpoint, connect_handler);
auto client7 = std::make_shared<nano::client_socket> (*node); auto client7 = std::make_shared<nano::transport::client_socket> (*node);
client7->async_connect (dst_endpoint, connect_handler); client7->async_connect (dst_endpoint, connect_handler);
auto client8 = std::make_shared<nano::client_socket> (*node); auto client8 = std::make_shared<nano::transport::client_socket> (*node);
client8->async_connect (dst_endpoint, connect_handler); client8->async_connect (dst_endpoint, connect_handler);
ASSERT_TIMELY (5s, get_tcp_accept_failures () == 3); ASSERT_TIMELY (5s, get_tcp_accept_failures () == 3);
@ -123,14 +123,14 @@ TEST (socket, max_connections_per_ip)
const auto max_global_connections = 1000; const auto max_global_connections = 1000;
auto server_socket = std::make_shared<nano::server_socket> (*node, listen_endpoint, max_global_connections); auto server_socket = std::make_shared<nano::transport::server_socket> (*node, listen_endpoint, max_global_connections);
boost::system::error_code ec; boost::system::error_code ec;
server_socket->start (ec); server_socket->start (ec);
ASSERT_FALSE (ec); ASSERT_FALSE (ec);
// successful incoming connections are stored in server_sockets to keep them alive (server side) // successful incoming connections are stored in server_sockets to keep them alive (server side)
std::vector<std::shared_ptr<nano::socket>> server_sockets; std::vector<std::shared_ptr<nano::transport::socket>> server_sockets;
server_socket->on_connection ([&server_sockets] (std::shared_ptr<nano::socket> const & new_connection, boost::system::error_code const & ec_a) { server_socket->on_connection ([&server_sockets] (std::shared_ptr<nano::transport::socket> const & new_connection, boost::system::error_code const & ec_a) {
server_sockets.push_back (new_connection); server_sockets.push_back (new_connection);
return true; return true;
}); });
@ -143,12 +143,12 @@ TEST (socket, max_connections_per_ip)
}; };
// start n clients, n-1 will persist but 1 will be dropped, where n == max_ip_connections // start n clients, n-1 will persist but 1 will be dropped, where n == max_ip_connections
std::vector<std::shared_ptr<nano::socket>> client_list; std::vector<std::shared_ptr<nano::transport::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::client_socket> (*node); auto client = std::make_shared<nano::transport::client_socket> (*node);
client->async_connect (dst_endpoint, connect_handler); client->async_connect (dst_endpoint, connect_handler);
client_list.push_back (client); client_list.push_back (client);
} }
@ -171,7 +171,7 @@ TEST (socket, max_connections_per_ip)
TEST (socket, limited_subnet_address) TEST (socket, limited_subnet_address)
{ {
auto address = boost::asio::ip::make_address ("a41d:b7b2:8298:cf45:672e:bd1a:e7fb:f713"); auto address = boost::asio::ip::make_address ("a41d:b7b2:8298:cf45:672e:bd1a:e7fb:f713");
auto network = nano::socket_functions::get_ipv6_subnet_address (address.to_v6 (), 32); // network prefix = 32. auto network = nano::transport::socket_functions::get_ipv6_subnet_address (address.to_v6 (), 32); // network prefix = 32.
ASSERT_EQ ("a41d:b7b2:8298:cf45:672e:bd1a:e7fb:f713/32", network.to_string ()); ASSERT_EQ ("a41d:b7b2:8298:cf45:672e:bd1a:e7fb:f713/32", network.to_string ());
ASSERT_EQ ("a41d:b7b2::/32", network.canonical ().to_string ()); ASSERT_EQ ("a41d:b7b2::/32", network.canonical ().to_string ());
} }
@ -179,14 +179,14 @@ TEST (socket, limited_subnet_address)
TEST (socket, first_ipv6_subnet_address) TEST (socket, first_ipv6_subnet_address)
{ {
auto address = boost::asio::ip::make_address ("a41d:b7b2:8298:cf45:672e:bd1a:e7fb:f713"); auto address = boost::asio::ip::make_address ("a41d:b7b2:8298:cf45:672e:bd1a:e7fb:f713");
auto first_address = nano::socket_functions::first_ipv6_subnet_address (address.to_v6 (), 32); // network prefix = 32. auto first_address = nano::transport::socket_functions::first_ipv6_subnet_address (address.to_v6 (), 32); // network prefix = 32.
ASSERT_EQ ("a41d:b7b2::", first_address.to_string ()); ASSERT_EQ ("a41d:b7b2::", first_address.to_string ());
} }
TEST (socket, last_ipv6_subnet_address) TEST (socket, last_ipv6_subnet_address)
{ {
auto address = boost::asio::ip::make_address ("a41d:b7b2:8298:cf45:672e:bd1a:e7fb:f713"); auto address = boost::asio::ip::make_address ("a41d:b7b2:8298:cf45:672e:bd1a:e7fb:f713");
auto last_address = nano::socket_functions::last_ipv6_subnet_address (address.to_v6 (), 32); // network prefix = 32. auto last_address = nano::transport::socket_functions::last_ipv6_subnet_address (address.to_v6 (), 32); // network prefix = 32.
ASSERT_EQ ("a41d:b7b2:ffff:ffff:ffff:ffff:ffff:ffff", last_address.to_string ()); ASSERT_EQ ("a41d:b7b2:ffff:ffff:ffff:ffff:ffff:ffff", last_address.to_string ());
} }
@ -203,15 +203,15 @@ TEST (socket, count_subnetwork_connections)
auto address5 = boost::asio::ip::make_address ("a41d:b7b3::"); // out of the network prefix auto 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::client_socket> (*node); auto connection0 = std::make_shared<nano::transport::client_socket> (*node);
auto connection1 = std::make_shared<nano::client_socket> (*node); auto connection1 = std::make_shared<nano::transport::client_socket> (*node);
auto connection2 = std::make_shared<nano::client_socket> (*node); auto connection2 = std::make_shared<nano::transport::client_socket> (*node);
auto connection3 = std::make_shared<nano::client_socket> (*node); auto connection3 = std::make_shared<nano::transport::client_socket> (*node);
auto connection4 = std::make_shared<nano::client_socket> (*node); auto connection4 = std::make_shared<nano::transport::client_socket> (*node);
auto connection5 = std::make_shared<nano::client_socket> (*node); auto connection5 = std::make_shared<nano::transport::client_socket> (*node);
auto connection6 = std::make_shared<nano::client_socket> (*node); auto connection6 = std::make_shared<nano::transport::client_socket> (*node);
nano::address_socket_mmap connections_per_address; nano::transport::address_socket_mmap connections_per_address;
connections_per_address.emplace (address0, connection0); connections_per_address.emplace (address0, connection0);
connections_per_address.emplace (address1, connection1); connections_per_address.emplace (address1, connection1);
connections_per_address.emplace (address2, connection2); connections_per_address.emplace (address2, connection2);
@ -221,7 +221,7 @@ TEST (socket, count_subnetwork_connections)
connections_per_address.emplace (address6, connection6); connections_per_address.emplace (address6, connection6);
// Asserts it counts only the connections for the specified address and its network prefix. // Asserts it counts only the connections for the specified address and its network prefix.
ASSERT_EQ (4, nano::socket_functions::count_subnetwork_connections (connections_per_address, address1.to_v6 (), 32)); ASSERT_EQ (4, nano::transport::socket_functions::count_subnetwork_connections (connections_per_address, address1.to_v6 (), 32));
} }
TEST (socket, max_connections_per_subnetwork) TEST (socket, max_connections_per_subnetwork)
@ -245,14 +245,14 @@ TEST (socket, max_connections_per_subnetwork)
const auto max_global_connections = 1000; const auto max_global_connections = 1000;
auto server_socket = std::make_shared<nano::server_socket> (*node, listen_endpoint, max_global_connections); auto server_socket = std::make_shared<nano::transport::server_socket> (*node, listen_endpoint, max_global_connections);
boost::system::error_code ec; boost::system::error_code ec;
server_socket->start (ec); server_socket->start (ec);
ASSERT_FALSE (ec); ASSERT_FALSE (ec);
// successful incoming connections are stored in server_sockets to keep them alive (server side) // successful incoming connections are stored in server_sockets to keep them alive (server side)
std::vector<std::shared_ptr<nano::socket>> server_sockets; std::vector<std::shared_ptr<nano::transport::socket>> server_sockets;
server_socket->on_connection ([&server_sockets] (std::shared_ptr<nano::socket> const & new_connection, boost::system::error_code const & ec_a) { server_socket->on_connection ([&server_sockets] (std::shared_ptr<nano::transport::socket> const & new_connection, boost::system::error_code const & ec_a) {
server_sockets.push_back (new_connection); server_sockets.push_back (new_connection);
return true; return true;
}); });
@ -265,12 +265,12 @@ TEST (socket, max_connections_per_subnetwork)
}; };
// start n clients, n-1 will persist but 1 will be dropped, where n == max_subnetwork_connections // start n clients, n-1 will persist but 1 will be dropped, where n == max_subnetwork_connections
std::vector<std::shared_ptr<nano::socket>> client_list; std::vector<std::shared_ptr<nano::transport::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::client_socket> (*node); auto client = std::make_shared<nano::transport::client_socket> (*node);
client->async_connect (dst_endpoint, connect_handler); client->async_connect (dst_endpoint, connect_handler);
client_list.push_back (client); client_list.push_back (client);
} }
@ -308,14 +308,14 @@ TEST (socket, disabled_max_peers_per_ip)
const auto max_global_connections = 1000; const auto max_global_connections = 1000;
auto server_socket = std::make_shared<nano::server_socket> (*node, listen_endpoint, max_global_connections); auto server_socket = std::make_shared<nano::transport::server_socket> (*node, listen_endpoint, max_global_connections);
boost::system::error_code ec; boost::system::error_code ec;
server_socket->start (ec); server_socket->start (ec);
ASSERT_FALSE (ec); ASSERT_FALSE (ec);
// successful incoming connections are stored in server_sockets to keep them alive (server side) // successful incoming connections are stored in server_sockets to keep them alive (server side)
std::vector<std::shared_ptr<nano::socket>> server_sockets; std::vector<std::shared_ptr<nano::transport::socket>> server_sockets;
server_socket->on_connection ([&server_sockets] (std::shared_ptr<nano::socket> const & new_connection, boost::system::error_code const & ec_a) { server_socket->on_connection ([&server_sockets] (std::shared_ptr<nano::transport::socket> const & new_connection, boost::system::error_code const & ec_a) {
server_sockets.push_back (new_connection); server_sockets.push_back (new_connection);
return true; return true;
}); });
@ -328,12 +328,12 @@ TEST (socket, disabled_max_peers_per_ip)
}; };
// start n clients, n-1 will persist but 1 will be dropped, where n == max_ip_connections // start n clients, n-1 will persist but 1 will be dropped, where n == max_ip_connections
std::vector<std::shared_ptr<nano::socket>> client_list; std::vector<std::shared_ptr<nano::transport::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::client_socket> (*node); auto client = std::make_shared<nano::transport::client_socket> (*node);
client->async_connect (dst_endpoint, connect_handler); client->async_connect (dst_endpoint, connect_handler);
client_list.push_back (client); client_list.push_back (client);
} }
@ -371,20 +371,20 @@ TEST (socket, disconnection_of_silent_connections)
boost::asio::ip::tcp::endpoint dst_endpoint{ boost::asio::ip::address_v6::loopback (), server_port }; boost::asio::ip::tcp::endpoint dst_endpoint{ boost::asio::ip::address_v6::loopback (), server_port };
// start a server listening socket // start a server listening socket
auto server_socket = std::make_shared<nano::server_socket> (*node, listen_endpoint, 1); auto server_socket = std::make_shared<nano::transport::server_socket> (*node, listen_endpoint, 1);
boost::system::error_code ec; boost::system::error_code ec;
server_socket->start (ec); server_socket->start (ec);
ASSERT_FALSE (ec); ASSERT_FALSE (ec);
// on a connection, a server data socket is created. The shared pointer guarantees the object's lifecycle until the end of this test. // on a connection, a server data socket is created. The shared pointer guarantees the object's lifecycle until the end of this test.
std::shared_ptr<nano::socket> server_data_socket; std::shared_ptr<nano::transport::socket> server_data_socket;
server_socket->on_connection ([&server_data_socket] (std::shared_ptr<nano::socket> const & new_connection, boost::system::error_code const & ec_a) { server_socket->on_connection ([&server_data_socket] (std::shared_ptr<nano::transport::socket> const & new_connection, boost::system::error_code const & ec_a) {
server_data_socket = new_connection; server_data_socket = new_connection;
return true; return true;
}); });
// Instantiates a client to simulate an incoming connection. // Instantiates a client to simulate an incoming connection.
auto client_socket = std::make_shared<nano::client_socket> (*node); auto client_socket = std::make_shared<nano::transport::client_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) {
@ -419,24 +419,24 @@ TEST (socket, drop_policy)
nano::thread_runner runner (node->io_ctx, 1); nano::thread_runner runner (node->io_ctx, 1);
std::vector<std::shared_ptr<nano::socket>> connections; std::vector<std::shared_ptr<nano::transport::socket>> connections;
auto func = [&] (size_t total_message_count, nano::buffer_drop_policy drop_policy) { auto func = [&] (size_t total_message_count, nano::transport::buffer_drop_policy drop_policy) {
auto server_port (nano::test::get_available_port ()); auto server_port (nano::test::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);
auto server_socket = std::make_shared<nano::server_socket> (*node, endpoint, 1); auto server_socket = std::make_shared<nano::transport::server_socket> (*node, endpoint, 1);
boost::system::error_code ec; boost::system::error_code ec;
server_socket->start (ec); server_socket->start (ec);
ASSERT_FALSE (ec); ASSERT_FALSE (ec);
// Accept connection, but don't read so the writer will drop. // Accept connection, but don't read so the writer will drop.
server_socket->on_connection ([&connections] (std::shared_ptr<nano::socket> const & new_connection, boost::system::error_code const & ec_a) { server_socket->on_connection ([&connections] (std::shared_ptr<nano::transport::socket> const & new_connection, boost::system::error_code const & ec_a) {
connections.push_back (new_connection); connections.push_back (new_connection);
return true; return true;
}); });
auto client = std::make_shared<nano::client_socket> (*node); auto client = std::make_shared<nano::transport::client_socket> (*node);
nano::transport::channel_tcp channel{ *node, client }; nano::transport::channel_tcp channel{ *node, client };
nano::test::counted_completion write_completion (static_cast<unsigned> (total_message_count)); nano::test::counted_completion write_completion (static_cast<unsigned> (total_message_count));
@ -459,11 +459,11 @@ TEST (socket, drop_policy)
// We're going to write twice the queue size + 1, and the server isn't reading // 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::socket::queue_size_max * 2 + 1, nano::buffer_drop_policy::no_socket_drop); func (nano::transport::socket::queue_size_max * 2 + 1, nano::transport::buffer_drop_policy::no_socket_drop);
ASSERT_EQ (1, node->stats.count (nano::stat::type::tcp, nano::stat::detail::tcp_write_no_socket_drop, nano::stat::dir::out)); ASSERT_EQ (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::socket::queue_size_max + 1, nano::buffer_drop_policy::limiter); func (nano::transport::socket::queue_size_max + 1, nano::transport::buffer_drop_policy::limiter);
// The stats are accumulated from before // 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));
@ -493,7 +493,7 @@ TEST (socket, concurrent_writes)
// We're expecting client_count*4 messages // We're expecting client_count*4 messages
nano::test::counted_completion read_count_completion (total_message_count); nano::test::counted_completion read_count_completion (total_message_count);
std::function<void (std::shared_ptr<nano::socket> const &)> reader = [&read_count_completion, &total_message_count, &reader] (std::shared_ptr<nano::socket> const & socket_a) { std::function<void (std::shared_ptr<nano::transport::socket> const &)> reader = [&read_count_completion, &total_message_count, &reader] (std::shared_ptr<nano::transport::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);
#ifndef _WIN32 #ifndef _WIN32
@ -525,14 +525,14 @@ TEST (socket, concurrent_writes)
boost::asio::ip::tcp::endpoint endpoint (boost::asio::ip::address_v4::any (), 25000); boost::asio::ip::tcp::endpoint endpoint (boost::asio::ip::address_v4::any (), 25000);
auto server_socket = std::make_shared<nano::server_socket> (*node, endpoint, max_connections); auto server_socket = std::make_shared<nano::transport::server_socket> (*node, endpoint, max_connections);
boost::system::error_code ec; boost::system::error_code ec;
server_socket->start (ec); server_socket->start (ec);
ASSERT_FALSE (ec); ASSERT_FALSE (ec);
std::vector<std::shared_ptr<nano::socket>> connections; std::vector<std::shared_ptr<nano::transport::socket>> connections;
// On every new connection, start reading data // On every new connection, start reading data
server_socket->on_connection ([&connections, &reader] (std::shared_ptr<nano::socket> const & new_connection, boost::system::error_code const & ec_a) { server_socket->on_connection ([&connections, &reader] (std::shared_ptr<nano::transport::socket> const & new_connection, boost::system::error_code const & ec_a) {
if (ec_a) if (ec_a)
{ {
std::cerr << "on_connection: " << ec_a.message () << std::endl; std::cerr << "on_connection: " << ec_a.message () << std::endl;
@ -547,10 +547,10 @@ TEST (socket, concurrent_writes)
}); });
nano::test::counted_completion connection_count_completion (client_count); nano::test::counted_completion connection_count_completion (client_count);
std::vector<std::shared_ptr<nano::socket>> clients; std::vector<std::shared_ptr<nano::transport::socket>> clients;
for (unsigned i = 0; i < client_count; i++) for (unsigned i = 0; i < client_count; i++)
{ {
auto client = std::make_shared<nano::client_socket> (*node); auto client = std::make_shared<nano::transport::client_socket> (*node);
clients.push_back (client); clients.push_back (client);
client->async_connect (boost::asio::ip::tcp::endpoint (boost::asio::ip::address_v4::loopback (), 25000), client->async_connect (boost::asio::ip::tcp::endpoint (boost::asio::ip::address_v4::loopback (), 25000),
[&connection_count_completion] (boost::system::error_code const & ec_a) { [&connection_count_completion] (boost::system::error_code const & ec_a) {
@ -628,7 +628,7 @@ TEST (socket_timeout, connect)
boost::asio::ip::tcp::endpoint endpoint (boost::asio::ip::make_address_v6 ("::ffff:10.255.254.253"), nano::test::get_available_port ()); boost::asio::ip::tcp::endpoint endpoint (boost::asio::ip::make_address_v6 ("::ffff:10.255.254.253"), nano::test::get_available_port ());
// create a client socket and try to connect to the IP address that wil not respond // create a client socket and try to connect to the IP address that wil not respond
auto socket = std::make_shared<nano::client_socket> (*node); auto socket = std::make_shared<nano::transport::client_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) {
@ -669,7 +669,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::client_socket> (*node); auto socket = std::make_shared<nano::transport::client_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, [&socket, &ec, &done] (boost::system::error_code const & ec_a) { socket->async_connect (endpoint, [&socket, &ec, &done] (boost::system::error_code const & ec_a) {
@ -716,7 +716,7 @@ TEST (socket_timeout, write)
// create a client socket and send lots of data to fill the socket queue on the local and remote side // 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::client_socket> (*node); auto socket = std::make_shared<nano::transport::client_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, [&socket, &ec, &done] (boost::system::error_code const & ec_a) { socket->async_connect (endpoint, [&socket, &ec, &done] (boost::system::error_code const & ec_a) {
@ -769,7 +769,7 @@ TEST (socket_timeout, read_overlapped)
}); });
// create a client socket to connect and call async_read twice, the second call should time out // create a client socket to connect and call async_read twice, the second call should time out
auto socket = std::make_shared<nano::client_socket> (*node); auto socket = std::make_shared<nano::transport::client_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, [&socket, &ec, &done] (boost::system::error_code const & ec_a) { socket->async_connect (endpoint, [&socket, &ec, &done] (boost::system::error_code const & ec_a) {
@ -826,7 +826,7 @@ TEST (socket_timeout, write_overlapped)
// create a client socket and send lots of data to fill the socket queue on the local and remote side // 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::client_socket> (*node); auto socket = std::make_shared<nano::transport::client_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, [&socket, &ec, &done] (boost::system::error_code const & ec_a) { socket->async_connect (endpoint, [&socket, &ec, &done] (boost::system::error_code const & ec_a) {

4
nano/node/CMakeLists.txt
View file

@ -184,8 +184,6 @@ add_library(
rocksdb/rocksdb_txn.cpp rocksdb/rocksdb_txn.cpp
signatures.hpp signatures.hpp
signatures.cpp signatures.cpp
socket.hpp
socket.cpp
state_block_signature_verification.hpp state_block_signature_verification.hpp
state_block_signature_verification.cpp state_block_signature_verification.cpp
telemetry.hpp telemetry.hpp
@ -198,6 +196,8 @@ 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.hpp transport/tcp.hpp
transport/tcp.cpp transport/tcp.cpp
transport/tcp_server.hpp transport/tcp_server.hpp

2
nano/node/blockprocessor.cpp
View file

@ -313,7 +313,7 @@ void nano::block_processor::process_live (nano::transaction const & transaction_
} }
else if (!node.flags.disable_block_processor_republishing && node.block_arrival.recent (hash_a)) else if (!node.flags.disable_block_processor_republishing && node.block_arrival.recent (hash_a))
{ {
node.network.flood_block (block_a, nano::buffer_drop_policy::limiter); node.network.flood_block (block_a, nano::transport::buffer_drop_policy::limiter);
} }
if (node.websocket.server && node.websocket.server->any_subscriber (nano::websocket::topic::new_unconfirmed_block)) if (node.websocket.server && node.websocket.server->any_subscriber (nano::websocket::topic::new_unconfirmed_block))

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

@ -1,6 +1,6 @@
#include <nano/lib/blocks.hpp> #include <nano/lib/blocks.hpp>
#include <nano/node/bootstrap/block_deserializer.hpp> #include <nano/node/bootstrap/block_deserializer.hpp>
#include <nano/node/socket.hpp> #include <nano/node/transport/socket.hpp>
#include <nano/secure/buffer.hpp> #include <nano/secure/buffer.hpp>
nano::bootstrap::block_deserializer::block_deserializer () : nano::bootstrap::block_deserializer::block_deserializer () :
@ -8,7 +8,7 @@ nano::bootstrap::block_deserializer::block_deserializer () :
{ {
} }
void nano::bootstrap::block_deserializer::read (nano::socket & socket, callback_type const && callback) void nano::bootstrap::block_deserializer::read (nano::transport::socket & socket, callback_type const && callback)
{ {
debug_assert (callback); debug_assert (callback);
read_buffer->resize (1); read_buffer->resize (1);
@ -27,7 +27,7 @@ void nano::bootstrap::block_deserializer::read (nano::socket & socket, callback_
}); });
} }
void nano::bootstrap::block_deserializer::received_type (nano::socket & socket, callback_type const && callback) void nano::bootstrap::block_deserializer::received_type (nano::transport::socket & socket, callback_type const && callback)
{ {
nano::block_type type = static_cast<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)

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

@ -8,7 +8,11 @@
namespace nano namespace nano
{ {
class block; class block;
class socket; namespace transport
{
class socket;
}
namespace bootstrap namespace bootstrap
{ {
/** /**
@ -25,14 +29,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::socket & socket, callback_type const && callback); void read (nano::transport::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::socket & socket, callback_type const && callback); void received_type (nano::transport::socket & socket, callback_type const && callback);
/** /**
* Called by received_type when a block is received, it parses the block and calls the callback. * Called by received_type when a block is received, it parses the block and calls the callback.

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

@ -96,7 +96,7 @@ void nano::bulk_pull_client::request ()
this_l->connection->node->stats.inc (nano::stat::type::bootstrap, nano::stat::detail::bulk_pull_request_failure, nano::stat::dir::in); this_l->connection->node->stats.inc (nano::stat::type::bootstrap, nano::stat::detail::bulk_pull_request_failure, nano::stat::dir::in);
} }
}, },
nano::buffer_drop_policy::no_limiter_drop); nano::transport::buffer_drop_policy::no_limiter_drop);
} }
void nano::bulk_pull_client::throttled_receive_block () void nano::bulk_pull_client::throttled_receive_block ()
@ -242,7 +242,7 @@ void nano::bulk_pull_account_client::request ()
this_l->connection->node->stats.inc (nano::stat::type::bootstrap, nano::stat::detail::bulk_pull_error_starting_request, nano::stat::dir::in); this_l->connection->node->stats.inc (nano::stat::type::bootstrap, nano::stat::detail::bulk_pull_error_starting_request, nano::stat::dir::in);
} }
}, },
nano::buffer_drop_policy::no_limiter_drop); nano::transport::buffer_drop_policy::no_limiter_drop);
} }
void nano::bulk_pull_account_client::receive_pending () void nano::bulk_pull_account_client::receive_pending ()

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/socket.hpp> #include <nano/node/transport/socket.hpp>
#include <unordered_set> #include <unordered_set>

2
nano/node/bootstrap/bootstrap_bulk_push.cpp
View file

@ -34,7 +34,7 @@ void nano::bulk_push_client::start ()
} }
} }
}, },
nano::buffer_drop_policy::no_limiter_drop); nano::transport::buffer_drop_policy::no_limiter_drop);
} }
void nano::bulk_push_client::push () void nano::bulk_push_client::push ()

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

@ -16,7 +16,7 @@ constexpr double nano::bootstrap_limits::bootstrap_minimum_termination_time_sec;
constexpr unsigned nano::bootstrap_limits::bootstrap_max_new_connections; constexpr unsigned nano::bootstrap_limits::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, nano::bootstrap_connections & connections_a, std::shared_ptr<nano::transport::channel_tcp> const & channel_a, std::shared_ptr<nano::socket> const & socket_a) : nano::bootstrap_client::bootstrap_client (std::shared_ptr<nano::node> const & node_a, nano::bootstrap_connections & connections_a, std::shared_ptr<nano::transport::channel_tcp> const & channel_a, std::shared_ptr<nano::transport::socket> const & socket_a) :
node (node_a), node (node_a),
connections (connections_a), connections (connections_a),
channel (channel_a), channel (channel_a),
@ -147,7 +147,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::client_socket> (node)); auto socket (std::make_shared<nano::transport::client_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/socket.hpp> #include <nano/node/transport/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, nano::bootstrap_connections & connections_a, std::shared_ptr<nano::transport::channel_tcp> const & channel_a, std::shared_ptr<nano::socket> const & socket_a); bootstrap_client (std::shared_ptr<nano::node> const & node_a, nano::bootstrap_connections & connections_a, std::shared_ptr<nano::transport::channel_tcp> const & channel_a, std::shared_ptr<nano::transport::socket> const & socket_a);
~bootstrap_client (); ~bootstrap_client ();
void stop (bool force); void stop (bool force);
double sample_block_rate (); double sample_block_rate ();
@ -34,7 +34,7 @@ public:
std::shared_ptr<nano::node> node; std::shared_ptr<nano::node> node;
nano::bootstrap_connections & connections; nano::bootstrap_connections & connections;
std::shared_ptr<nano::transport::channel_tcp> channel; std::shared_ptr<nano::transport::channel_tcp> channel;
std::shared_ptr<nano::socket> socket; std::shared_ptr<nano::transport::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/bootstrap/bootstrap_frontier.cpp
View file

@ -38,7 +38,7 @@ void nano::frontier_req_client::run (nano::account const & start_account_a, uint
} }
} }
}, },
nano::buffer_drop_policy::no_limiter_drop); nano::transport::buffer_drop_policy::no_limiter_drop);
} }
nano::frontier_req_client::frontier_req_client (std::shared_ptr<nano::bootstrap_client> const & connection_a, std::shared_ptr<nano::bootstrap_attempt_legacy> const & attempt_a) : nano::frontier_req_client::frontier_req_client (std::shared_ptr<nano::bootstrap_client> const & connection_a, std::shared_ptr<nano::bootstrap_attempt_legacy> const & attempt_a) :

2
nano/node/bootstrap/bootstrap_server.cpp
View file

@ -125,7 +125,7 @@ void nano::bootstrap_server::respond (nano::asc_pull_ack & response, std::shared
stats.inc (nano::stat::type::bootstrap_server, nano::stat::detail::write_error, nano::stat::dir::out); stats.inc (nano::stat::type::bootstrap_server, nano::stat::detail::write_error, nano::stat::dir::out);
} }
}, },
nano::buffer_drop_policy::limiter, nano::bandwidth_limit_type::bootstrap); nano::transport::buffer_drop_policy::limiter, nano::bandwidth_limit_type::bootstrap);
} }
/* /*

2
nano/node/confirmation_solicitor.cpp
View file

@ -46,7 +46,7 @@ bool nano::confirmation_solicitor::broadcast (nano::election const & election_a)
} }
} }
// Random flood for block propagation // Random flood for block propagation
network.flood_message (winner, nano::buffer_drop_policy::limiter, 0.5f); network.flood_message (winner, nano::transport::buffer_drop_policy::limiter, 0.5f);
error = false; error = false;
} }
return error; return error;

2
nano/node/election.cpp
View file

@ -467,7 +467,7 @@ bool nano::election::publish (std::shared_ptr<nano::block> const & block_a)
if (status.winner->hash () == block_a->hash ()) if (status.winner->hash () == block_a->hash ())
{ {
status.winner = block_a; status.winner = block_a;
node.network.flood_block (block_a, nano::buffer_drop_policy::no_limiter_drop); node.network.flood_block (block_a, nano::transport::buffer_drop_policy::no_limiter_drop);
} }
} }
} }

16
nano/node/network.cpp
View file

@ -129,7 +129,7 @@ void nano::network::send_node_id_handshake (std::shared_ptr<nano::transport::cha
channel_a->send (message); channel_a->send (message);
} }
void nano::network::flood_message (nano::message & message_a, nano::buffer_drop_policy const drop_policy_a, float const scale_a) void nano::network::flood_message (nano::message & message_a, nano::transport::buffer_drop_policy const drop_policy_a, float const scale_a)
{ {
for (auto & i : list (fanout (scale_a))) for (auto & i : list (fanout (scale_a)))
{ {
@ -141,17 +141,17 @@ void nano::network::flood_keepalive (float const scale_a)
{ {
nano::keepalive message{ node.network_params.network }; nano::keepalive message{ node.network_params.network };
random_fill (message.peers); random_fill (message.peers);
flood_message (message, nano::buffer_drop_policy::limiter, scale_a); flood_message (message, nano::transport::buffer_drop_policy::limiter, scale_a);
} }
void nano::network::flood_keepalive_self (float const scale_a) void nano::network::flood_keepalive_self (float const scale_a)
{ {
nano::keepalive message{ node.network_params.network }; nano::keepalive message{ node.network_params.network };
fill_keepalive_self (message.peers); fill_keepalive_self (message.peers);
flood_message (message, nano::buffer_drop_policy::limiter, scale_a); flood_message (message, nano::transport::buffer_drop_policy::limiter, scale_a);
} }
void nano::network::flood_block (std::shared_ptr<nano::block> const & block_a, nano::buffer_drop_policy const drop_policy_a) void nano::network::flood_block (std::shared_ptr<nano::block> const & block_a, nano::transport::buffer_drop_policy const drop_policy_a)
{ {
nano::publish message (node.network_params.network, block_a); nano::publish message (node.network_params.network, block_a);
flood_message (message, drop_policy_a); flood_message (message, drop_policy_a);
@ -162,11 +162,11 @@ void nano::network::flood_block_initial (std::shared_ptr<nano::block> const & bl
nano::publish message (node.network_params.network, block_a); nano::publish message (node.network_params.network, block_a);
for (auto const & i : node.rep_crawler.principal_representatives ()) for (auto const & i : node.rep_crawler.principal_representatives ())
{ {
i.channel->send (message, nullptr, nano::buffer_drop_policy::no_limiter_drop); i.channel->send (message, nullptr, nano::transport::buffer_drop_policy::no_limiter_drop);
} }
for (auto & i : list_non_pr (fanout (1.0))) for (auto & i : list_non_pr (fanout (1.0)))
{ {
i->send (message, nullptr, nano::buffer_drop_policy::no_limiter_drop); i->send (message, nullptr, nano::transport::buffer_drop_policy::no_limiter_drop);
} }
} }
@ -184,7 +184,7 @@ void nano::network::flood_vote_pr (std::shared_ptr<nano::vote> const & vote_a)
nano::confirm_ack message{ node.network_params.network, vote_a }; nano::confirm_ack message{ node.network_params.network, vote_a };
for (auto const & i : node.rep_crawler.principal_representatives ()) for (auto const & i : node.rep_crawler.principal_representatives ())
{ {
i.channel->send (message, nullptr, nano::buffer_drop_policy::no_limiter_drop); i.channel->send (message, nullptr, nano::transport::buffer_drop_policy::no_limiter_drop);
} }
} }
@ -480,7 +480,7 @@ public:
auto telemetry_data = node.local_telemetry (); auto telemetry_data = node.local_telemetry ();
telemetry_ack = nano::telemetry_ack{ node.network_params.network, telemetry_data }; telemetry_ack = nano::telemetry_ack{ node.network_params.network, telemetry_data };
} }
channel->send (telemetry_ack, nullptr, nano::buffer_drop_policy::no_socket_drop); channel->send (telemetry_ack, nullptr, nano::transport::buffer_drop_policy::no_socket_drop);
} }
void telemetry_ack (nano::telemetry_ack const & message_a) override void telemetry_ack (nano::telemetry_ack const & message_a) override

4
nano/node/network.hpp
View file

@ -73,7 +73,7 @@ public:
nano::networks id; nano::networks id;
void start (); void start ();
void stop (); void stop ();
void flood_message (nano::message &, nano::buffer_drop_policy const = nano::buffer_drop_policy::limiter, float const = 1.0f); void flood_message (nano::message &, nano::transport::buffer_drop_policy const = nano::transport::buffer_drop_policy::limiter, float const = 1.0f);
void flood_keepalive (float const scale_a = 1.0f); void flood_keepalive (float const scale_a = 1.0f);
void flood_keepalive_self (float const scale_a = 0.5f); void flood_keepalive_self (float const scale_a = 0.5f);
void flood_vote (std::shared_ptr<nano::vote> const &, float scale); void flood_vote (std::shared_ptr<nano::vote> const &, float scale);
@ -81,7 +81,7 @@ public:
// Flood block to all PRs and a random selection of non-PRs // Flood block to all PRs and a random selection of non-PRs
void flood_block_initial (std::shared_ptr<nano::block> const &); void flood_block_initial (std::shared_ptr<nano::block> const &);
// Flood block to a random selection of peers // Flood block to a random selection of peers
void flood_block (std::shared_ptr<nano::block> const &, nano::buffer_drop_policy const = nano::buffer_drop_policy::limiter); void flood_block (std::shared_ptr<nano::block> const &, nano::transport::buffer_drop_policy const = nano::transport::buffer_drop_policy::limiter);
void flood_block_many (std::deque<std::shared_ptr<nano::block>>, std::function<void ()> = nullptr, unsigned = broadcast_interval_ms); void flood_block_many (std::deque<std::shared_ptr<nano::block>>, std::function<void ()> = nullptr, unsigned = broadcast_interval_ms);
void merge_peers (std::array<nano::endpoint, 8> const &); void merge_peers (std::array<nano::endpoint, 8> const &);
void merge_peer (nano::endpoint const &); void merge_peer (nano::endpoint const &);

4
nano/node/node_observers.hpp
View file

@ -23,8 +23,8 @@ public:
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::socket &> socket_connected; nano::observer_set<nano::transport::socket &> socket_connected;
nano::observer_set<nano::socket &> socket_accepted; nano::observer_set<nano::transport::socket &> socket_accepted;
}; };
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);

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

@ -14,11 +14,11 @@ nano::transport::channel::channel (nano::node & node_a) :
set_network_version (node_a.network_params.network.protocol_version); set_network_version (node_a.network_params.network.protocol_version);
} }
void nano::transport::channel::send (nano::message & message_a, std::function<void (boost::system::error_code const &, std::size_t)> const & callback_a, nano::buffer_drop_policy drop_policy_a, nano::bandwidth_limit_type limiter_type) void nano::transport::channel::send (nano::message & message_a, std::function<void (boost::system::error_code const &, std::size_t)> const & callback_a, nano::transport::buffer_drop_policy drop_policy_a, nano::bandwidth_limit_type limiter_type)
{ {
auto buffer (message_a.to_shared_const_buffer ()); auto buffer (message_a.to_shared_const_buffer ());
auto detail = nano::to_stat_detail (message_a.header.type); auto detail = nano::to_stat_detail (message_a.header.type);
auto is_droppable_by_limiter = drop_policy_a == nano::buffer_drop_policy::limiter; auto is_droppable_by_limiter = (drop_policy_a == nano::transport::buffer_drop_policy::limiter);
auto should_pass (node.outbound_limiter.should_pass (buffer.size (), limiter_type)); auto should_pass (node.outbound_limiter.should_pass (buffer.size (), limiter_type));
if (!is_droppable_by_limiter || should_pass) if (!is_droppable_by_limiter || should_pass)
{ {

6
nano/node/transport/channel.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/socket.hpp> #include <nano/node/transport/socket.hpp>
#include <boost/asio/ip/network_v6.hpp> #include <boost/asio/ip/network_v6.hpp>
@ -27,10 +27,10 @@ public:
virtual std::size_t hash_code () const = 0; virtual std::size_t hash_code () const = 0;
virtual bool operator== (nano::transport::channel const &) const = 0; virtual bool operator== (nano::transport::channel const &) const = 0;
void send (nano::message & message_a, std::function<void (boost::system::error_code const &, std::size_t)> const & callback_a = nullptr, nano::buffer_drop_policy policy_a = nano::buffer_drop_policy::limiter, nano::bandwidth_limit_type = nano::bandwidth_limit_type::standard); void send (nano::message & message_a, std::function<void (boost::system::error_code const &, std::size_t)> const & callback_a = nullptr, nano::transport::buffer_drop_policy policy_a = nano::transport::buffer_drop_policy::limiter, nano::bandwidth_limit_type = nano::bandwidth_limit_type::standard);
// TODO: investigate clang-tidy warning about default parameters on virtual/override functions // TODO: investigate clang-tidy warning about default parameters on virtual/override functions
// //
virtual void send_buffer (nano::shared_const_buffer const &, std::function<void (boost::system::error_code const &, std::size_t)> const & = nullptr, nano::buffer_drop_policy = nano::buffer_drop_policy::limiter) = 0; virtual void send_buffer (nano::shared_const_buffer const &, std::function<void (boost::system::error_code const &, std::size_t)> const & = nullptr, nano::transport::buffer_drop_policy = nano::transport::buffer_drop_policy::limiter) = 0;
virtual std::string to_string () const = 0; virtual std::string to_string () const = 0;
virtual nano::endpoint get_endpoint () const = 0; virtual nano::endpoint get_endpoint () const = 0;
virtual nano::tcp_endpoint get_tcp_endpoint () const = 0; virtual nano::tcp_endpoint get_tcp_endpoint () const = 0;

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

@ -14,7 +14,7 @@ nano::transport::fake::channel::channel (nano::node & node) :
/** /**
* The send function behaves like a null device, it throws the data away and returns success. * The send function behaves like a null device, it throws the data away and returns success.
*/ */
void nano::transport::fake::channel::send_buffer (nano::shared_const_buffer const & buffer_a, std::function<void (boost::system::error_code const &, std::size_t)> const & callback_a, nano::buffer_drop_policy drop_policy_a) void nano::transport::fake::channel::send_buffer (nano::shared_const_buffer const & buffer_a, std::function<void (boost::system::error_code const &, std::size_t)> const & callback_a, nano::transport::buffer_drop_policy drop_policy_a)
{ {
//auto bytes = buffer_a.to_bytes (); //auto bytes = buffer_a.to_bytes ();
auto size = buffer_a.size (); auto size = buffer_a.size ();

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

@ -24,7 +24,7 @@ namespace transport
void send_buffer ( void send_buffer (
nano::shared_const_buffer const &, nano::shared_const_buffer const &,
std::function<void (boost::system::error_code const &, std::size_t)> const & = nullptr, std::function<void (boost::system::error_code const &, std::size_t)> const & = nullptr,
nano::buffer_drop_policy = nano::buffer_drop_policy::limiter nano::transport::buffer_drop_policy = nano::transport::buffer_drop_policy::limiter
) override; ) override;
// clang-format on // clang-format on

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

@ -51,7 +51,7 @@ public:
* Send the buffer to the peer and call the callback function when done. The call never fails. * Send the buffer to the peer and call the callback function when done. The call never fails.
* Note that the inbound message visitor will be called before the callback because it is called directly whereas the callback is spawned in the background. * Note that the inbound message visitor will be called before the callback because it is called directly whereas the callback is spawned in the background.
*/ */
void nano::transport::inproc::channel::send_buffer (nano::shared_const_buffer const & buffer_a, std::function<void (boost::system::error_code const &, std::size_t)> const & callback_a, nano::buffer_drop_policy drop_policy_a) void nano::transport::inproc::channel::send_buffer (nano::shared_const_buffer const & buffer_a, std::function<void (boost::system::error_code const &, std::size_t)> const & callback_a, nano::transport::buffer_drop_policy drop_policy_a)
{ {
// we create a temporary channel for the reply path, in case the receiver of the message wants to reply // we create a temporary channel for the reply path, in case the receiver of the message wants to reply
auto remote_channel = std::make_shared<nano::transport::inproc::channel> (destination, node); auto remote_channel = std::make_shared<nano::transport::inproc::channel> (destination, node);

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

@ -20,7 +20,7 @@ namespace transport
bool operator== (nano::transport::channel const &) const override; bool operator== (nano::transport::channel const &) const override;
// TODO: investigate clang-tidy warning about default parameters on virtual/override functions // TODO: investigate clang-tidy warning about default parameters on virtual/override functions
// //
void send_buffer (nano::shared_const_buffer const &, std::function<void (boost::system::error_code const &, std::size_t)> const & = nullptr, nano::buffer_drop_policy = nano::buffer_drop_policy::limiter) override; void send_buffer (nano::shared_const_buffer const &, std::function<void (boost::system::error_code const &, std::size_t)> const & = nullptr, nano::transport::buffer_drop_policy = nano::transport::buffer_drop_policy::limiter) override;
std::string to_string () const override; std::string to_string () const override;
bool operator== (nano::transport::inproc::channel const & other_a) const bool operator== (nano::transport::inproc::channel const & other_a) const
{ {

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

@ -11,7 +11,7 @@ nano::transport::message_deserializer::message_deserializer (nano::network_const
read_buffer->resize (MAX_MESSAGE_SIZE); read_buffer->resize (MAX_MESSAGE_SIZE);
} }
void nano::transport::message_deserializer::read (std::shared_ptr<nano::socket> socket, const nano::transport::message_deserializer::callback_type && callback) void nano::transport::message_deserializer::read (std::shared_ptr<nano::transport::socket> socket, const nano::transport::message_deserializer::callback_type && callback)
{ {
debug_assert (callback); debug_assert (callback);
@ -40,7 +40,7 @@ void nano::transport::message_deserializer::read (std::shared_ptr<nano::socket>
}); });
} }
void nano::transport::message_deserializer::received_header (std::shared_ptr<nano::socket> socket, const nano::transport::message_deserializer::callback_type && callback) void nano::transport::message_deserializer::received_header (std::shared_ptr<nano::transport::socket> socket, const nano::transport::message_deserializer::callback_type && callback)
{ {
nano::bufferstream stream{ read_buffer->data (), HEADER_SIZE }; nano::bufferstream stream{ read_buffer->data (), HEADER_SIZE };
auto error = false; auto error = false;

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

@ -2,7 +2,7 @@
#include <nano/node/common.hpp> #include <nano/node/common.hpp>
#include <nano/node/messages.hpp> #include <nano/node/messages.hpp>
#include <nano/node/socket.hpp> #include <nano/node/transport/socket.hpp>
#include <memory> #include <memory>
#include <vector> #include <vector>
@ -54,10 +54,10 @@ namespace transport
* If message is received successfully, error code won't be set and message will be non-null. `status` field will be set to `success`. * If message is received successfully, error code won't be set and message will be non-null. `status` field will be set to `success`.
* Should not be called until the previous invocation finishes and calls the callback. * Should not be called until the previous invocation finishes and calls the callback.
*/ */
void read (std::shared_ptr<nano::socket> socket, callback_type const && callback); void read (std::shared_ptr<nano::transport::socket> socket, callback_type const && callback);
private: private:
void received_header (std::shared_ptr<nano::socket> socket, callback_type const && callback); void received_header (std::shared_ptr<nano::transport::socket> socket, callback_type const && callback);
void received_message (nano::message_header header, std::size_t payload_size, callback_type const && callback); void received_message (nano::message_header header, std::size_t payload_size, callback_type const && callback);
/* /*

86
nano/node/socket.cpp → nano/node/transport/socket.cpp
View file

@ -2,7 +2,7 @@
#include <nano/boost/asio/ip/address_v6.hpp> #include <nano/boost/asio/ip/address_v6.hpp>
#include <nano/boost/asio/read.hpp> #include <nano/boost/asio/read.hpp>
#include <nano/node/node.hpp> #include <nano/node/node.hpp>
#include <nano/node/socket.hpp> #include <nano/node/transport/socket.hpp>
#include <nano/node/transport/transport.hpp> #include <nano/node/transport/transport.hpp>
#include <boost/format.hpp> #include <boost/format.hpp>
@ -32,7 +32,7 @@ bool is_temporary_error (boost::system::error_code const & ec_a)
} }
} }
nano::socket::socket (nano::node & node_a, endpoint_type_t endpoint_type_a) : nano::transport::socket::socket (nano::node & node_a, endpoint_type_t endpoint_type_a) :
strand{ node_a.io_ctx.get_executor () }, strand{ node_a.io_ctx.get_executor () },
tcp_socket{ node_a.io_ctx }, tcp_socket{ node_a.io_ctx },
node{ node_a }, node{ node_a },
@ -45,12 +45,12 @@ nano::socket::socket (nano::node & node_a, endpoint_type_t endpoint_type_a) :
{ {
} }
nano::socket::~socket () nano::transport::socket::~socket ()
{ {
close_internal (); close_internal ();
} }
void nano::socket::async_connect (nano::tcp_endpoint const & endpoint_a, std::function<void (boost::system::error_code const &)> callback_a) void nano::transport::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 () == endpoint_type_t::client); debug_assert (endpoint_type () == endpoint_type_t::client);
@ -77,7 +77,7 @@ void nano::socket::async_connect (nano::tcp_endpoint const & endpoint_a, std::fu
})); }));
} }
void nano::socket::async_read (std::shared_ptr<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::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);
@ -109,13 +109,13 @@ void nano::socket::async_read (std::shared_ptr<std::vector<uint8_t>> const & buf
} }
else else
{ {
debug_assert (false && "nano::socket::async_read called with incorrect buffer size"); debug_assert (false && "nano::transport::socket::async_read called with incorrect buffer size");
boost::system::error_code ec_buffer = boost::system::errc::make_error_code (boost::system::errc::no_buffer_space); 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::socket::async_write (nano::shared_const_buffer const & buffer_a, std::function<void (boost::system::error_code const &, std::size_t)> callback_a) 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)
{ {
if (closed) if (closed)
{ {
@ -169,7 +169,7 @@ void nano::socket::async_write (nano::shared_const_buffer const & buffer_a, std:
} }
/** Call set_timeout with default_timeout as parameter */ /** Call set_timeout with default_timeout as parameter */
void nano::socket::set_default_timeout () void nano::transport::socket::set_default_timeout ()
{ {
set_timeout (default_timeout); set_timeout (default_timeout);
} }
@ -180,24 +180,24 @@ void nano::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::socket::set_timeout (std::chrono::seconds timeout_a) void nano::transport::socket::set_timeout (std::chrono::seconds timeout_a)
{ {
timeout = timeout_a.count (); timeout = timeout_a.count ();
} }
void nano::socket::set_last_completion () void nano::transport::socket::set_last_completion ()
{ {
last_completion_time_or_init = nano::seconds_since_epoch (); last_completion_time_or_init = nano::seconds_since_epoch ();
} }
void nano::socket::set_last_receive_time () void nano::transport::socket::set_last_receive_time ()
{ {
last_receive_time_or_init = nano::seconds_since_epoch (); last_receive_time_or_init = nano::seconds_since_epoch ();
} }
void nano::socket::checkup () void nano::transport::socket::checkup ()
{ {
std::weak_ptr<nano::socket> this_w (shared_from_this ()); std::weak_ptr<nano::transport::socket> this_w (shared_from_this ());
node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (node.network_params.network.is_dev_network () ? 1 : 5), [this_w] () { node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (node.network_params.network.is_dev_network () ? 1 : 5), [this_w] () {
if (auto this_l = this_w.lock ()) if (auto this_l = this_w.lock ())
{ {
@ -243,22 +243,22 @@ void nano::socket::checkup ()
}); });
} }
bool nano::socket::has_timed_out () const bool nano::transport::socket::has_timed_out () const
{ {
return timed_out; return timed_out;
} }
void nano::socket::set_default_timeout_value (std::chrono::seconds timeout_a) void nano::transport::socket::set_default_timeout_value (std::chrono::seconds timeout_a)
{ {
default_timeout = timeout_a; default_timeout = timeout_a;
} }
std::chrono::seconds nano::socket::get_default_timeout_value () const std::chrono::seconds nano::transport::socket::get_default_timeout_value () const
{ {
return default_timeout; return default_timeout;
} }
void nano::socket::set_silent_connection_tolerance_time (std::chrono::seconds tolerance_time_a) void nano::transport::socket::set_silent_connection_tolerance_time (std::chrono::seconds tolerance_time_a)
{ {
auto this_l (shared_from_this ()); auto this_l (shared_from_this ());
boost::asio::dispatch (strand, boost::asio::bind_executor (strand, [this_l, tolerance_time_a] () { boost::asio::dispatch (strand, boost::asio::bind_executor (strand, [this_l, tolerance_time_a] () {
@ -266,7 +266,7 @@ void nano::socket::set_silent_connection_tolerance_time (std::chrono::seconds to
})); }));
} }
void nano::socket::close () void nano::transport::socket::close ()
{ {
auto this_l (shared_from_this ()); auto this_l (shared_from_this ());
boost::asio::dispatch (strand, boost::asio::bind_executor (strand, [this_l] { boost::asio::dispatch (strand, boost::asio::bind_executor (strand, [this_l] {
@ -275,7 +275,7 @@ void nano::socket::close ()
} }
// This must be called from a strand or the destructor // This must be called from a strand or the destructor
void nano::socket::close_internal () void nano::transport::socket::close_internal ()
{ {
if (!closed.exchange (true)) if (!closed.exchange (true))
{ {
@ -293,17 +293,17 @@ void nano::socket::close_internal ()
} }
} }
nano::tcp_endpoint nano::socket::remote_endpoint () const nano::tcp_endpoint nano::transport::socket::remote_endpoint () const
{ {
return remote; return remote;
} }
nano::tcp_endpoint nano::socket::local_endpoint () const nano::tcp_endpoint nano::transport::socket::local_endpoint () const
{ {
return tcp_socket.local_endpoint (); return tcp_socket.local_endpoint ();
} }
nano::server_socket::server_socket (nano::node & node_a, boost::asio::ip::tcp::endpoint local_a, std::size_t max_connections_a) : nano::transport::server_socket::server_socket (nano::node & node_a, boost::asio::ip::tcp::endpoint local_a, std::size_t max_connections_a) :
socket{ node_a, endpoint_type_t::server }, socket{ node_a, endpoint_type_t::server },
acceptor{ node_a.io_ctx }, acceptor{ node_a.io_ctx },
local{ std::move (local_a) }, local{ std::move (local_a) },
@ -312,7 +312,7 @@ nano::server_socket::server_socket (nano::node & node_a, boost::asio::ip::tcp::e
default_timeout = std::chrono::seconds::max (); default_timeout = std::chrono::seconds::max ();
} }
void nano::server_socket::start (boost::system::error_code & ec_a) void nano::transport::server_socket::start (boost::system::error_code & ec_a)
{ {
acceptor.open (local.protocol ()); acceptor.open (local.protocol ());
acceptor.set_option (boost::asio::ip::tcp::acceptor::reuse_address (true)); acceptor.set_option (boost::asio::ip::tcp::acceptor::reuse_address (true));
@ -323,9 +323,9 @@ void nano::server_socket::start (boost::system::error_code & ec_a)
} }
} }
void nano::server_socket::close () void nano::transport::server_socket::close ()
{ {
auto this_l (std::static_pointer_cast<nano::server_socket> (shared_from_this ())); auto this_l (std::static_pointer_cast<nano::transport::server_socket> (shared_from_this ()));
boost::asio::dispatch (strand, boost::asio::bind_executor (strand, [this_l] () { boost::asio::dispatch (strand, boost::asio::bind_executor (strand, [this_l] () {
this_l->close_internal (); this_l->close_internal ();
@ -341,27 +341,27 @@ void nano::server_socket::close ()
})); }));
} }
boost::asio::ip::network_v6 nano::socket_functions::get_ipv6_subnet_address (boost::asio::ip::address_v6 const & ip_address, size_t network_prefix) boost::asio::ip::network_v6 nano::transport::socket_functions::get_ipv6_subnet_address (boost::asio::ip::address_v6 const & ip_address, size_t network_prefix)
{ {
return boost::asio::ip::make_network_v6 (ip_address, network_prefix); return boost::asio::ip::make_network_v6 (ip_address, network_prefix);
} }
boost::asio::ip::address nano::socket_functions::first_ipv6_subnet_address (boost::asio::ip::address_v6 const & ip_address, size_t network_prefix) boost::asio::ip::address nano::transport::socket_functions::first_ipv6_subnet_address (boost::asio::ip::address_v6 const & ip_address, size_t network_prefix)
{ {
auto range = get_ipv6_subnet_address (ip_address, network_prefix).hosts (); auto range = get_ipv6_subnet_address (ip_address, network_prefix).hosts ();
debug_assert (!range.empty ()); debug_assert (!range.empty ());
return *(range.begin ()); return *(range.begin ());
} }
boost::asio::ip::address nano::socket_functions::last_ipv6_subnet_address (boost::asio::ip::address_v6 const & ip_address, size_t network_prefix) boost::asio::ip::address nano::transport::socket_functions::last_ipv6_subnet_address (boost::asio::ip::address_v6 const & ip_address, size_t network_prefix)
{ {
auto range = get_ipv6_subnet_address (ip_address, network_prefix).hosts (); auto range = get_ipv6_subnet_address (ip_address, network_prefix).hosts ();
debug_assert (!range.empty ()); debug_assert (!range.empty ());
return *(--range.end ()); return *(--range.end ());
} }
size_t nano::socket_functions::count_subnetwork_connections ( size_t nano::transport::socket_functions::count_subnetwork_connections (
nano::address_socket_mmap const & per_address_connections, nano::transport::address_socket_mmap const & per_address_connections,
boost::asio::ip::address_v6 const & remote_address, boost::asio::ip::address_v6 const & remote_address,
size_t network_prefix) size_t network_prefix)
{ {
@ -376,7 +376,7 @@ size_t network_prefix)
return counted_connections; return counted_connections;
} }
bool nano::server_socket::limit_reached_for_incoming_subnetwork_connections (std::shared_ptr<nano::socket> const & new_connection) bool nano::transport::server_socket::limit_reached_for_incoming_subnetwork_connections (std::shared_ptr<nano::transport::socket> const & new_connection)
{ {
debug_assert (strand.running_in_this_thread ()); debug_assert (strand.running_in_this_thread ());
if (node.flags.disable_max_peers_per_subnetwork || nano::transport::is_ipv4_or_v4_mapped_address (new_connection->remote.address ())) if (node.flags.disable_max_peers_per_subnetwork || nano::transport::is_ipv4_or_v4_mapped_address (new_connection->remote.address ()))
@ -392,7 +392,7 @@ bool nano::server_socket::limit_reached_for_incoming_subnetwork_connections (std
return counted_connections >= node.network_params.network.max_peers_per_subnetwork; return counted_connections >= node.network_params.network.max_peers_per_subnetwork;
} }
bool nano::server_socket::limit_reached_for_incoming_ip_connections (std::shared_ptr<nano::socket> const & new_connection) bool nano::transport::server_socket::limit_reached_for_incoming_ip_connections (std::shared_ptr<nano::transport::socket> const & new_connection)
{ {
debug_assert (strand.running_in_this_thread ()); debug_assert (strand.running_in_this_thread ());
if (node.flags.disable_max_peers_per_ip) if (node.flags.disable_max_peers_per_ip)
@ -405,9 +405,9 @@ bool nano::server_socket::limit_reached_for_incoming_ip_connections (std::shared
return counted_connections >= node.network_params.network.max_peers_per_ip; return counted_connections >= node.network_params.network.max_peers_per_ip;
} }
void nano::server_socket::on_connection (std::function<bool (std::shared_ptr<nano::socket> const &, boost::system::error_code const &)> callback_a) void nano::transport::server_socket::on_connection (std::function<bool (std::shared_ptr<nano::transport::socket> const &, boost::system::error_code const &)> callback_a)
{ {
auto this_l (std::static_pointer_cast<nano::server_socket> (shared_from_this ())); auto this_l (std::static_pointer_cast<nano::transport::server_socket> (shared_from_this ()));
boost::asio::post (strand, boost::asio::bind_executor (strand, [this_l, callback = std::move (callback_a)] () mutable { boost::asio::post (strand, boost::asio::bind_executor (strand, [this_l, callback = std::move (callback_a)] () mutable {
if (!this_l->acceptor.is_open ()) if (!this_l->acceptor.is_open ())
@ -417,7 +417,7 @@ void nano::server_socket::on_connection (std::function<bool (std::shared_ptr<nan
} }
// Prepare new connection // Prepare new connection
auto new_connection = std::make_shared<nano::socket> (this_l->node, endpoint_type_t::server); auto new_connection = std::make_shared<nano::transport::socket> (this_l->node, endpoint_type_t::server);
this_l->acceptor.async_accept (new_connection->tcp_socket, new_connection->remote, this_l->acceptor.async_accept (new_connection->tcp_socket, new_connection->remote,
boost::asio::bind_executor (this_l->strand, boost::asio::bind_executor (this_l->strand,
[this_l, new_connection, cbk = std::move (callback)] (boost::system::error_code const & ec_a) mutable { [this_l, new_connection, cbk = std::move (callback)] (boost::system::error_code const & ec_a) mutable {
@ -503,16 +503,16 @@ void nano::server_socket::on_connection (std::function<bool (std::shared_ptr<nan
// If we are unable to accept a socket, for any reason, we wait just a little (1ms) before rescheduling the next connection accept. // If we are unable to accept a socket, for any reason, we wait just a little (1ms) before rescheduling the next connection accept.
// The intention is to throttle back the connection requests and break up any busy loops that could possibly form and // The intention is to throttle back the connection requests and break up any busy loops that could possibly form and
// give the rest of the system a chance to recover. // give the rest of the system a chance to recover.
void nano::server_socket::on_connection_requeue_delayed (std::function<bool (std::shared_ptr<nano::socket> const &, boost::system::error_code const &)> callback_a) void nano::transport::server_socket::on_connection_requeue_delayed (std::function<bool (std::shared_ptr<nano::transport::socket> const &, boost::system::error_code const &)> callback_a)
{ {
auto this_l (std::static_pointer_cast<nano::server_socket> (shared_from_this ())); auto this_l (std::static_pointer_cast<nano::transport::server_socket> (shared_from_this ()));
node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::milliseconds (1), [this_l, callback = std::move (callback_a)] () mutable { node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::milliseconds (1), [this_l, callback = std::move (callback_a)] () mutable {
this_l->on_connection (std::move (callback)); this_l->on_connection (std::move (callback));
}); });
} }
// This must be called from a strand // This must be called from a strand
void nano::server_socket::evict_dead_connections () void nano::transport::server_socket::evict_dead_connections ()
{ {
debug_assert (strand.running_in_this_thread ()); debug_assert (strand.running_in_this_thread ());
for (auto it = connections_per_address.begin (); it != connections_per_address.end ();) for (auto it = connections_per_address.begin (); it != connections_per_address.end ();)
@ -526,17 +526,17 @@ void nano::server_socket::evict_dead_connections ()
} }
} }
std::string nano::socket_type_to_string (nano::socket::type_t type) std::string nano::transport::socket_type_to_string (nano::transport::socket::type_t type)
{ {
switch (type) switch (type)
{ {
case nano::socket::type_t::undefined: case nano::transport::socket::type_t::undefined:
return "undefined"; return "undefined";
case nano::socket::type_t::bootstrap: case nano::transport::socket::type_t::bootstrap:
return "bootstrap"; return "bootstrap";
case nano::socket::type_t::realtime: case nano::transport::socket::type_t::realtime:
return "realtime"; return "realtime";
case nano::socket::type_t::realtime_response_server: case nano::transport::socket::type_t::realtime_response_server:
return "realtime_response_server"; return "realtime_response_server";
} }
return "n/a"; return "n/a";

25
nano/node/socket.hpp → nano/node/transport/socket.hpp
View file

@ -16,6 +16,11 @@ class network_v6;
namespace nano namespace nano
{ {
class node;
}
namespace nano::transport
{
/** Policy to affect at which stage a buffer can be dropped */ /** Policy to affect at which stage a buffer can be dropped */
enum class buffer_drop_policy enum class buffer_drop_policy
{ {
@ -27,11 +32,10 @@ enum class buffer_drop_policy
no_socket_drop no_socket_drop
}; };
class node;
class server_socket; class server_socket;
/** Socket class for tcp clients and newly accepted connections */ /** Socket class for tcp clients and newly accepted connections */
class socket : public std::enable_shared_from_this<nano::socket> class socket : public std::enable_shared_from_this<nano::transport::socket>
{ {
friend class server_socket; friend class server_socket;
@ -57,6 +61,7 @@ public:
*/ */
explicit socket (nano::node & node, endpoint_type_t endpoint_type_a); explicit socket (nano::node & node, endpoint_type_t endpoint_type_a);
virtual ~socket (); virtual ~socket ();
void async_connect (boost::asio::ip::tcp::endpoint const &, std::function<void (boost::system::error_code const &)>); void async_connect (boost::asio::ip::tcp::endpoint const &, std::function<void (boost::system::error_code const &)>);
void async_read (std::shared_ptr<std::vector<uint8_t>> const &, std::size_t, std::function<void (boost::system::error_code const &, std::size_t)>); void async_read (std::shared_ptr<std::vector<uint8_t>> const &, std::size_t, std::function<void (boost::system::error_code const &, std::size_t)>);
void async_write (nano::shared_const_buffer const &, std::function<void (boost::system::error_code const &, std::size_t)> = {}); void async_write (nano::shared_const_buffer const &, std::function<void (boost::system::error_code const &, std::size_t)> = {});
@ -93,11 +98,11 @@ public:
} }
bool is_realtime_connection () const bool is_realtime_connection () const
{ {
return type () == nano::socket::type_t::realtime || type () == nano::socket::type_t::realtime_response_server; return type () == nano::transport::socket::type_t::realtime || type () == nano::transport::socket::type_t::realtime_response_server;
} }
bool is_bootstrap_connection () const bool is_bootstrap_connection () const
{ {
return type () == nano::socket::type_t::bootstrap; return type () == nano::transport::socket::type_t::bootstrap;
} }
bool is_closed () const bool is_closed () const
{ {
@ -184,7 +189,7 @@ namespace socket_functions
boost::asio::ip::network_v6 get_ipv6_subnet_address (boost::asio::ip::address_v6 const &, size_t); boost::asio::ip::network_v6 get_ipv6_subnet_address (boost::asio::ip::address_v6 const &, size_t);
boost::asio::ip::address first_ipv6_subnet_address (boost::asio::ip::address_v6 const &, size_t); boost::asio::ip::address first_ipv6_subnet_address (boost::asio::ip::address_v6 const &, size_t);
boost::asio::ip::address last_ipv6_subnet_address (boost::asio::ip::address_v6 const &, size_t); boost::asio::ip::address last_ipv6_subnet_address (boost::asio::ip::address_v6 const &, size_t);
size_t count_subnetwork_connections (nano::address_socket_mmap const &, boost::asio::ip::address_v6 const &, size_t); size_t count_subnetwork_connections (nano::transport::address_socket_mmap const &, boost::asio::ip::address_v6 const &, size_t);
} }
/** Socket class for TCP servers */ /** Socket class for TCP servers */
@ -203,22 +208,22 @@ public:
/** Stop accepting new connections */ /** Stop accepting new connections */
void close () override; void close () override;
/** Register callback for new connections. The callback must return true to keep accepting new connections. */ /** Register callback for new connections. The callback must return true to keep accepting new connections. */
void on_connection (std::function<bool (std::shared_ptr<nano::socket> const & new_connection, boost::system::error_code const &)>); void on_connection (std::function<bool (std::shared_ptr<nano::transport::socket> const & new_connection, boost::system::error_code const &)>);
uint16_t listening_port () uint16_t listening_port ()
{ {
return acceptor.local_endpoint ().port (); return acceptor.local_endpoint ().port ();
} }
private: private:
nano::address_socket_mmap connections_per_address; nano::transport::address_socket_mmap connections_per_address;
boost::asio::ip::tcp::acceptor acceptor; boost::asio::ip::tcp::acceptor acceptor;
boost::asio::ip::tcp::endpoint local; boost::asio::ip::tcp::endpoint local;
std::size_t max_inbound_connections; std::size_t max_inbound_connections;
void evict_dead_connections (); void evict_dead_connections ();
void on_connection_requeue_delayed (std::function<bool (std::shared_ptr<nano::socket> const & new_connection, boost::system::error_code const &)>); void on_connection_requeue_delayed (std::function<bool (std::shared_ptr<nano::transport::socket> const & new_connection, boost::system::error_code const &)>);
/** Checks whether the maximum number of connections per IP was reached. If so, it returns true. */ /** Checks whether the maximum number of connections per IP was reached. If so, it returns true. */
bool limit_reached_for_incoming_ip_connections (std::shared_ptr<nano::socket> const & new_connection); bool limit_reached_for_incoming_ip_connections (std::shared_ptr<nano::transport::socket> const & new_connection);
bool limit_reached_for_incoming_subnetwork_connections (std::shared_ptr<nano::socket> const & new_connection); bool limit_reached_for_incoming_subnetwork_connections (std::shared_ptr<nano::transport::socket> const & new_connection);
}; };
/** Socket class for TCP clients */ /** Socket class for TCP clients */

22
nano/node/transport/tcp.cpp
View file

@ -8,7 +8,7 @@
* channel_tcp * channel_tcp
*/ */
nano::transport::channel_tcp::channel_tcp (nano::node & node_a, std::weak_ptr<nano::socket> socket_a) : nano::transport::channel_tcp::channel_tcp (nano::node & node_a, std::weak_ptr<nano::transport::socket> socket_a) :
channel (node_a), channel (node_a),
socket (std::move (socket_a)) socket (std::move (socket_a))
{ {
@ -44,11 +44,11 @@ bool nano::transport::channel_tcp::operator== (nano::transport::channel const &
return result; return result;
} }
void nano::transport::channel_tcp::send_buffer (nano::shared_const_buffer const & buffer_a, std::function<void (boost::system::error_code const &, std::size_t)> const & callback_a, nano::buffer_drop_policy policy_a) void nano::transport::channel_tcp::send_buffer (nano::shared_const_buffer const & buffer_a, std::function<void (boost::system::error_code const &, std::size_t)> const & callback_a, nano::transport::buffer_drop_policy policy_a)
{ {
if (auto socket_l = socket.lock ()) if (auto socket_l = socket.lock ())
{ {
if (!socket_l->max () || (policy_a == nano::buffer_drop_policy::no_socket_drop && !socket_l->full ())) if (!socket_l->max () || (policy_a == nano::transport::buffer_drop_policy::no_socket_drop && !socket_l->full ()))
{ {
socket_l->async_write ( socket_l->async_write (
buffer_a, [endpoint_a = socket_l->remote_endpoint (), node = std::weak_ptr<nano::node> (node.shared ()), callback_a] (boost::system::error_code const & ec, std::size_t size_a) { buffer_a, [endpoint_a = socket_l->remote_endpoint (), node = std::weak_ptr<nano::node> (node.shared ()), callback_a] (boost::system::error_code const & ec, std::size_t size_a) {
@ -71,7 +71,7 @@ void nano::transport::channel_tcp::send_buffer (nano::shared_const_buffer const
} }
else else
{ {
if (policy_a == nano::buffer_drop_policy::no_socket_drop) if (policy_a == nano::transport::buffer_drop_policy::no_socket_drop)
{ {
node.stats.inc (nano::stat::type::tcp, nano::stat::detail::tcp_write_no_socket_drop, nano::stat::dir::out); node.stats.inc (nano::stat::type::tcp, nano::stat::detail::tcp_write_no_socket_drop, nano::stat::dir::out);
} }
@ -119,7 +119,7 @@ nano::transport::tcp_channels::tcp_channels (nano::node & node, std::function<vo
{ {
} }
bool nano::transport::tcp_channels::insert (std::shared_ptr<nano::transport::channel_tcp> const & channel_a, std::shared_ptr<nano::socket> const & socket_a, std::shared_ptr<nano::transport::tcp_server> const & server_a) bool nano::transport::tcp_channels::insert (std::shared_ptr<nano::transport::channel_tcp> const & channel_a, std::shared_ptr<nano::transport::socket> const & socket_a, std::shared_ptr<nano::transport::tcp_server> const & server_a)
{ {
auto endpoint (channel_a->get_tcp_endpoint ()); auto endpoint (channel_a->get_tcp_endpoint ());
debug_assert (endpoint.address ().is_v6 ()); debug_assert (endpoint.address ().is_v6 ());
@ -287,7 +287,7 @@ void nano::transport::tcp_channels::process_messages ()
} }
} }
void nano::transport::tcp_channels::process_message (nano::message const & message_a, nano::tcp_endpoint const & endpoint_a, nano::account const & node_id_a, std::shared_ptr<nano::socket> const & socket_a) void nano::transport::tcp_channels::process_message (nano::message const & message_a, nano::tcp_endpoint const & endpoint_a, nano::account const & node_id_a, std::shared_ptr<nano::transport::socket> const & socket_a)
{ {
auto type_a = socket_a->type (); auto type_a = socket_a->type ();
if (!stopped && message_a.header.version_using >= node.network_params.network.protocol_version_min) if (!stopped && message_a.header.version_using >= node.network_params.network.protocol_version_min)
@ -315,9 +315,9 @@ void nano::transport::tcp_channels::process_message (nano::message const & messa
temporary_channel->set_node_id (node_id_a); temporary_channel->set_node_id (node_id_a);
temporary_channel->set_network_version (message_a.header.version_using); temporary_channel->set_network_version (message_a.header.version_using);
temporary_channel->temporary = true; temporary_channel->temporary = true;
debug_assert (type_a == nano::socket::type_t::realtime || type_a == nano::socket::type_t::realtime_response_server); debug_assert (type_a == nano::transport::socket::type_t::realtime || type_a == nano::transport::socket::type_t::realtime_response_server);
// Don't insert temporary channels for response_server // Don't insert temporary channels for response_server
if (type_a == nano::socket::type_t::realtime) if (type_a == nano::transport::socket::type_t::realtime)
{ {
insert (temporary_channel, socket_a, nullptr); insert (temporary_channel, socket_a, nullptr);
} }
@ -534,8 +534,8 @@ void nano::transport::tcp_channels::update (nano::tcp_endpoint const & endpoint_
void nano::transport::tcp_channels::start_tcp (nano::endpoint const & endpoint_a) void nano::transport::tcp_channels::start_tcp (nano::endpoint const & endpoint_a)
{ {
auto socket = std::make_shared<nano::client_socket> (node); auto socket = std::make_shared<nano::transport::client_socket> (node);
std::weak_ptr<nano::socket> socket_w (socket); std::weak_ptr<nano::transport::socket> socket_w (socket);
auto channel (std::make_shared<nano::transport::channel_tcp> (node, socket_w)); auto channel (std::make_shared<nano::transport::channel_tcp> (node, socket_w));
std::weak_ptr<nano::node> node_w (node.shared ()); std::weak_ptr<nano::node> node_w (node.shared ());
socket->async_connect (nano::transport::map_endpoint_to_tcp (endpoint_a), socket->async_connect (nano::transport::map_endpoint_to_tcp (endpoint_a),
@ -717,7 +717,7 @@ void nano::transport::tcp_channels::start_tcp_receive_node_id (std::shared_ptr<n
auto response_server = std::make_shared<nano::transport::tcp_server> (socket_l, node_l); auto response_server = std::make_shared<nano::transport::tcp_server> (socket_l, node_l);
node_l->network.tcp_channels.insert (channel_a, socket_l, response_server); node_l->network.tcp_channels.insert (channel_a, socket_l, response_server);
// Listen for possible responses // Listen for possible responses
response_server->socket->type_set (nano::socket::type_t::realtime_response_server); response_server->socket->type_set (nano::transport::socket::type_t::realtime_response_server);
response_server->remote_node_id = channel_a->get_node_id (); response_server->remote_node_id = channel_a->get_node_id ();
response_server->start (); response_server->start ();
}); });

16
nano/node/transport/tcp.hpp
View file

@ -23,7 +23,7 @@ public:
std::shared_ptr<nano::message> message; std::shared_ptr<nano::message> message;
nano::tcp_endpoint endpoint; nano::tcp_endpoint endpoint;
nano::account node_id; nano::account node_id;
std::shared_ptr<nano::socket> socket; std::shared_ptr<nano::transport::socket> socket;
}; };
namespace transport namespace transport
{ {
@ -35,19 +35,19 @@ namespace transport
friend class nano::transport::tcp_channels; friend class nano::transport::tcp_channels;
public: public:
channel_tcp (nano::node &, std::weak_ptr<nano::socket>); channel_tcp (nano::node &, std::weak_ptr<nano::transport::socket>);
~channel_tcp () override; ~channel_tcp () override;
std::size_t hash_code () const override; std::size_t hash_code () const override;
bool operator== (nano::transport::channel const &) const override; bool operator== (nano::transport::channel const &) const override;
// TODO: investigate clang-tidy warning about default parameters on virtual/override functions // TODO: investigate clang-tidy warning about default parameters on virtual/override functions
// //
void send_buffer (nano::shared_const_buffer const &, std::function<void (boost::system::error_code const &, std::size_t)> const & = nullptr, nano::buffer_drop_policy = nano::buffer_drop_policy::limiter) override; void send_buffer (nano::shared_const_buffer const &, std::function<void (boost::system::error_code const &, std::size_t)> const & = nullptr, nano::transport::buffer_drop_policy = nano::transport::buffer_drop_policy::limiter) override;
std::string to_string () const override; std::string to_string () const override;
bool operator== (nano::transport::channel_tcp const & other_a) const bool operator== (nano::transport::channel_tcp const & other_a) const
{ {
return &node == &other_a.node && socket.lock () == other_a.socket.lock (); return &node == &other_a.node && socket.lock () == other_a.socket.lock ();
} }
std::weak_ptr<nano::socket> socket; std::weak_ptr<nano::transport::socket> socket;
/* Mark for temporary channels. Usually remote ports of these channels are ephemeral and received from incoming connections to server. /* Mark for temporary channels. Usually remote ports of these channels are ephemeral and received from incoming connections to server.
If remote part has open listening port, temporary channel will be replaced with direct connection to listening port soon. But if other side is behing NAT or firewall this connection can be pemanent. */ If remote part has open listening port, temporary channel will be replaced with direct connection to listening port soon. But if other side is behing NAT or firewall this connection can be pemanent. */
std::atomic<bool> temporary{ false }; std::atomic<bool> temporary{ false };
@ -99,7 +99,7 @@ namespace transport
public: public:
explicit tcp_channels (nano::node &, std::function<void (nano::message const &, std::shared_ptr<nano::transport::channel> const &)> = nullptr); explicit tcp_channels (nano::node &, std::function<void (nano::message const &, std::shared_ptr<nano::transport::channel> const &)> = nullptr);
bool insert (std::shared_ptr<nano::transport::channel_tcp> const &, std::shared_ptr<nano::socket> const &, std::shared_ptr<nano::transport::tcp_server> const &); bool insert (std::shared_ptr<nano::transport::channel_tcp> const &, std::shared_ptr<nano::transport::socket> const &, std::shared_ptr<nano::transport::tcp_server> const &);
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::channel_tcp> find_channel (nano::tcp_endpoint const &) const; std::shared_ptr<nano::transport::channel_tcp> find_channel (nano::tcp_endpoint const &) const;
@ -113,7 +113,7 @@ namespace transport
void start (); void start ();
void stop (); void stop ();
void process_messages (); void process_messages ();
void process_message (nano::message const &, nano::tcp_endpoint const &, nano::account const &, std::shared_ptr<nano::socket> const &); void process_message (nano::message const &, nano::tcp_endpoint const &, nano::account const &, std::shared_ptr<nano::transport::socket> const &);
bool max_ip_connections (nano::tcp_endpoint const & endpoint_a); bool max_ip_connections (nano::tcp_endpoint const & endpoint_a);
bool max_subnetwork_connections (nano::tcp_endpoint const & endpoint_a); bool max_subnetwork_connections (nano::tcp_endpoint const & endpoint_a);
bool max_ip_or_subnetwork_connections (nano::tcp_endpoint const & endpoint_a); bool max_ip_or_subnetwork_connections (nano::tcp_endpoint const & endpoint_a);
@ -164,9 +164,9 @@ namespace transport
{ {
public: public:
std::shared_ptr<nano::transport::channel_tcp> channel; std::shared_ptr<nano::transport::channel_tcp> channel;
std::shared_ptr<nano::socket> socket; std::shared_ptr<nano::transport::socket> socket;
std::shared_ptr<nano::transport::tcp_server> response_server; std::shared_ptr<nano::transport::tcp_server> response_server;
channel_tcp_wrapper (std::shared_ptr<nano::transport::channel_tcp> channel_a, std::shared_ptr<nano::socket> socket_a, std::shared_ptr<nano::transport::tcp_server> server_a) : channel_tcp_wrapper (std::shared_ptr<nano::transport::channel_tcp> channel_a, std::shared_ptr<nano::transport::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))
{ {
} }

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

@ -18,7 +18,7 @@ void nano::transport::tcp_listener::start ()
{ {
nano::lock_guard<nano::mutex> lock{ mutex }; nano::lock_guard<nano::mutex> lock{ mutex };
on = true; on = true;
listening_socket = std::make_shared<nano::server_socket> (node, boost::asio::ip::tcp::endpoint (boost::asio::ip::address_v6::any (), port), node.config.tcp_incoming_connections_max); listening_socket = std::make_shared<nano::transport::server_socket> (node, boost::asio::ip::tcp::endpoint (boost::asio::ip::address_v6::any (), port), node.config.tcp_incoming_connections_max);
boost::system::error_code ec; boost::system::error_code ec;
listening_socket->start (ec); listening_socket->start (ec);
if (ec) if (ec)
@ -50,7 +50,7 @@ void nano::transport::tcp_listener::start ()
} }
} }
listening_socket->on_connection ([this] (std::shared_ptr<nano::socket> const & new_connection, boost::system::error_code const & ec_a) { listening_socket->on_connection ([this] (std::shared_ptr<nano::transport::socket> const & new_connection, boost::system::error_code const & ec_a) {
if (!ec_a) if (!ec_a)
{ {
accept_action (ec_a, new_connection); accept_action (ec_a, new_connection);
@ -81,7 +81,7 @@ std::size_t nano::transport::tcp_listener::connection_count ()
return connections.size (); return connections.size ();
} }
void nano::transport::tcp_listener::accept_action (boost::system::error_code const & ec, std::shared_ptr<nano::socket> const & socket_a) void nano::transport::tcp_listener::accept_action (boost::system::error_code const & ec, std::shared_ptr<nano::transport::socket> const & socket_a)
{ {
if (!node.network.excluded_peers.check (socket_a->remote_endpoint ())) if (!node.network.excluded_peers.check (socket_a->remote_endpoint ()))
{ {
@ -121,7 +121,7 @@ std::unique_ptr<nano::container_info_component> nano::transport::collect_contain
return composite; return composite;
} }
nano::transport::tcp_server::tcp_server (std::shared_ptr<nano::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::socket> socket_a, std::shared_ptr<nano::node> node_a, bool allow_bootstrap_a) :
socket{ std::move (socket_a) }, socket{ std::move (socket_a) },
node{ std::move (node_a) }, node{ std::move (node_a) },
allow_bootstrap{ allow_bootstrap_a }, allow_bootstrap{ allow_bootstrap_a },
@ -137,11 +137,11 @@ nano::transport::tcp_server::~tcp_server ()
node->logger.try_log ("Exiting incoming TCP/bootstrap server"); node->logger.try_log ("Exiting incoming TCP/bootstrap server");
} }
if (socket->type () == nano::socket::type_t::bootstrap) if (socket->type () == nano::transport::socket::type_t::bootstrap)
{ {
--node->tcp_listener.bootstrap_count; --node->tcp_listener.bootstrap_count;
} }
else if (socket->type () == nano::socket::type_t::realtime) else if (socket->type () == nano::transport::socket::type_t::realtime)
{ {
--node->tcp_listener.realtime_count; --node->tcp_listener.realtime_count;
@ -570,23 +570,23 @@ bool nano::transport::tcp_server::to_bootstrap_connection ()
{ {
return false; return false;
} }
if (socket->type () != nano::socket::type_t::undefined) if (socket->type () != nano::transport::socket::type_t::undefined)
{ {
return false; return false;
} }
++node->tcp_listener.bootstrap_count; ++node->tcp_listener.bootstrap_count;
socket->type_set (nano::socket::type_t::bootstrap); socket->type_set (nano::transport::socket::type_t::bootstrap);
return true; return true;
} }
bool nano::transport::tcp_server::to_realtime_connection (nano::account const & node_id) bool nano::transport::tcp_server::to_realtime_connection (nano::account const & node_id)
{ {
if (socket->type () == nano::socket::type_t::undefined && !node->flags.disable_tcp_realtime) if (socket->type () == nano::transport::socket::type_t::undefined && !node->flags.disable_tcp_realtime)
{ {
remote_node_id = node_id; remote_node_id = node_id;
++node->tcp_listener.realtime_count; ++node->tcp_listener.realtime_count;
socket->type_set (nano::socket::type_t::realtime); socket->type_set (nano::transport::socket::type_t::realtime);
return true; return true;
} }
return false; return false;
@ -594,7 +594,7 @@ bool nano::transport::tcp_server::to_realtime_connection (nano::account const &
bool nano::transport::tcp_server::is_undefined_connection () const bool nano::transport::tcp_server::is_undefined_connection () const
{ {
return socket->type () == nano::socket::type_t::undefined; return socket->type () == nano::transport::socket::type_t::undefined;
} }
bool nano::transport::tcp_server::is_bootstrap_connection () const bool nano::transport::tcp_server::is_bootstrap_connection () const

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

@ -2,7 +2,7 @@
#include <nano/node/common.hpp> #include <nano/node/common.hpp>
#include <nano/node/messages.hpp> #include <nano/node/messages.hpp>
#include <nano/node/socket.hpp> #include <nano/node/transport/socket.hpp>
#include <atomic> #include <atomic>
@ -25,14 +25,14 @@ public:
tcp_listener (uint16_t, nano::node &); tcp_listener (uint16_t, nano::node &);
void start (); void start ();
void stop (); void stop ();
void accept_action (boost::system::error_code const &, std::shared_ptr<nano::socket> const &); void accept_action (boost::system::error_code const &, std::shared_ptr<nano::transport::socket> const &);
std::size_t connection_count (); std::size_t connection_count ();
nano::mutex mutex; nano::mutex mutex;
std::unordered_map<nano::transport::tcp_server *, std::weak_ptr<nano::transport::tcp_server>> connections; std::unordered_map<nano::transport::tcp_server *, std::weak_ptr<nano::transport::tcp_server>> connections;
nano::tcp_endpoint endpoint (); nano::tcp_endpoint endpoint ();
nano::node & node; nano::node & node;
std::shared_ptr<nano::server_socket> listening_socket; std::shared_ptr<nano::transport::server_socket> listening_socket;
bool on{ false }; bool on{ false };
std::atomic<std::size_t> bootstrap_count{ 0 }; std::atomic<std::size_t> bootstrap_count{ 0 };
std::atomic<std::size_t> realtime_count{ 0 }; std::atomic<std::size_t> realtime_count{ 0 };
@ -44,7 +44,7 @@ std::unique_ptr<container_info_component> collect_container_info (tcp_listener &
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::socket>, std::shared_ptr<nano::node>, bool allow_bootstrap = true); tcp_server (std::shared_ptr<nano::transport::socket>, std::shared_ptr<nano::node>, bool allow_bootstrap = true);
~tcp_server (); ~tcp_server ();
void start (); void start ();
@ -54,7 +54,7 @@ public:
void send_handshake_response (nano::uint256_union query); void send_handshake_response (nano::uint256_union query);
std::shared_ptr<nano::socket> const socket; std::shared_ptr<nano::transport::socket> const socket;
std::shared_ptr<nano::node> const node; std::shared_ptr<nano::node> const node;
nano::mutex mutex; nano::mutex mutex;
std::atomic<bool> stopped{ false }; std::atomic<bool> stopped{ false };

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/socket.hpp> #include <nano/node/transport/socket.hpp>
#include <boost/asio/ip/network_v6.hpp> #include <boost/asio/ip/network_v6.hpp>

2
nano/node/wallet.cpp
View file

@ -956,7 +956,7 @@ std::shared_ptr<nano::block> nano::wallet::send_action (nano::account const & so
if (block != nullptr) if (block != nullptr)
{ {
cached_block = true; cached_block = true;
wallets.node.network.flood_block (block, nano::buffer_drop_policy::no_limiter_drop); wallets.node.network.flood_block (block, nano::transport::buffer_drop_policy::no_limiter_drop);
} }
} }
else if (status != MDB_NOTFOUND) else if (status != MDB_NOTFOUND)