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

Rename socket to tcp_socket

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

56
nano/core_test/bootstrap.cpp
View file

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

16
nano/core_test/network.cpp
View file

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

2
nano/core_test/peer_container.cpp
View file

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

12
nano/core_test/request_aggregator.cpp
View file

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

80
nano/core_test/socket.cpp
View file

@ -2,8 +2,8 @@
#include <nano/boost/asio/ip/network_v6.hpp>
#include <nano/lib/thread_runner.hpp>
#include <nano/node/inactive_node.hpp>
#include <nano/node/transport/socket.hpp>
#include <nano/node/transport/tcp_listener.hpp>
#include <nano/node/transport/tcp_socket.hpp>
#include <nano/test_common/system.hpp>
#include <nano/test_common/testutil.hpp>
@ -36,13 +36,13 @@ TEST (socket, max_connections)
};
// start 3 clients, 2 will persist but 1 will be dropped
auto client1 = std::make_shared<nano::transport::socket> (*node);
auto client1 = std::make_shared<nano::transport::tcp_socket> (*node);
client1->async_connect (node->network.endpoint (), connect_handler);
auto client2 = std::make_shared<nano::transport::socket> (*node);
auto client2 = std::make_shared<nano::transport::tcp_socket> (*node);
client2->async_connect (node->network.endpoint (), connect_handler);
auto client3 = std::make_shared<nano::transport::socket> (*node);
auto client3 = std::make_shared<nano::transport::tcp_socket> (*node);
client3->async_connect (node->network.endpoint (), connect_handler);
ASSERT_TIMELY_EQ (5s, node->stats.count (nano::stat::type::tcp_listener, nano::stat::detail::accept_success), 2);
@ -57,10 +57,10 @@ TEST (socket, max_connections)
}
ASSERT_TIMELY_EQ (10s, node->tcp_listener.sockets ().size (), 1);
auto client4 = std::make_shared<nano::transport::socket> (*node);
auto client4 = std::make_shared<nano::transport::tcp_socket> (*node);
client4->async_connect (node->network.endpoint (), connect_handler);
auto client5 = std::make_shared<nano::transport::socket> (*node);
auto client5 = std::make_shared<nano::transport::tcp_socket> (*node);
client5->async_connect (node->network.endpoint (), connect_handler);
ASSERT_TIMELY_EQ (5s, node->stats.count (nano::stat::type::tcp_listener, nano::stat::detail::accept_success), 3);
@ -76,13 +76,13 @@ TEST (socket, max_connections)
}
ASSERT_TIMELY_EQ (10s, node->tcp_listener.sockets ().size (), 0);
auto client6 = std::make_shared<nano::transport::socket> (*node);
auto client6 = std::make_shared<nano::transport::tcp_socket> (*node);
client6->async_connect (node->network.endpoint (), connect_handler);
auto client7 = std::make_shared<nano::transport::socket> (*node);
auto client7 = std::make_shared<nano::transport::tcp_socket> (*node);
client7->async_connect (node->network.endpoint (), connect_handler);
auto client8 = std::make_shared<nano::transport::socket> (*node);
auto client8 = std::make_shared<nano::transport::tcp_socket> (*node);
client8->async_connect (node->network.endpoint (), connect_handler);
ASSERT_TIMELY_EQ (5s, node->stats.count (nano::stat::type::tcp_listener, nano::stat::detail::accept_success), 5);
@ -113,12 +113,12 @@ TEST (socket, max_connections_per_ip)
};
// start n clients, n-1 will persist but 1 will be dropped, where n == max_ip_connections
std::vector<std::shared_ptr<nano::transport::socket>> client_list;
std::vector<std::shared_ptr<nano::transport::tcp_socket>> client_list;
client_list.reserve (max_ip_connections + 1);
for (auto idx = 0; idx < max_ip_connections + 1; ++idx)
{
auto client = std::make_shared<nano::transport::socket> (*node);
auto client = std::make_shared<nano::transport::tcp_socket> (*node);
client->async_connect (node->network.endpoint (), connect_handler);
client_list.push_back (client);
}
@ -163,13 +163,13 @@ TEST (socket, count_subnetwork_connections)
auto address5 = boost::asio::ip::make_address ("a41d:b7b3::"); // out of the network prefix
auto address6 = boost::asio::ip::make_address ("a41d:b7b3::1"); // out of the network prefix
auto connection0 = std::make_shared<nano::transport::socket> (*node);
auto connection1 = std::make_shared<nano::transport::socket> (*node);
auto connection2 = std::make_shared<nano::transport::socket> (*node);
auto connection3 = std::make_shared<nano::transport::socket> (*node);
auto connection4 = std::make_shared<nano::transport::socket> (*node);
auto connection5 = std::make_shared<nano::transport::socket> (*node);
auto connection6 = std::make_shared<nano::transport::socket> (*node);
auto connection0 = std::make_shared<nano::transport::tcp_socket> (*node);
auto connection1 = std::make_shared<nano::transport::tcp_socket> (*node);
auto connection2 = std::make_shared<nano::transport::tcp_socket> (*node);
auto connection3 = std::make_shared<nano::transport::tcp_socket> (*node);
auto connection4 = std::make_shared<nano::transport::tcp_socket> (*node);
auto connection5 = std::make_shared<nano::transport::tcp_socket> (*node);
auto connection6 = std::make_shared<nano::transport::tcp_socket> (*node);
nano::transport::address_socket_mmap connections_per_address;
connections_per_address.emplace (address0, connection0);
@ -210,12 +210,12 @@ TEST (socket, max_connections_per_subnetwork)
};
// start n clients, n-1 will persist but 1 will be dropped, where n == max_subnetwork_connections
std::vector<std::shared_ptr<nano::transport::socket>> client_list;
std::vector<std::shared_ptr<nano::transport::tcp_socket>> client_list;
client_list.reserve (max_subnetwork_connections + 1);
for (auto idx = 0; idx < max_subnetwork_connections + 1; ++idx)
{
auto client = std::make_shared<nano::transport::socket> (*node);
auto client = std::make_shared<nano::transport::tcp_socket> (*node);
client->async_connect (node->network.endpoint (), connect_handler);
client_list.push_back (client);
}
@ -250,12 +250,12 @@ TEST (socket, disabled_max_peers_per_ip)
};
// start n clients, n-1 will persist but 1 will be dropped, where n == max_ip_connections
std::vector<std::shared_ptr<nano::transport::socket>> client_list;
std::vector<std::shared_ptr<nano::transport::tcp_socket>> client_list;
client_list.reserve (max_ip_connections + 1);
for (auto idx = 0; idx < max_ip_connections + 1; ++idx)
{
auto client = std::make_shared<nano::transport::socket> (*node);
auto client = std::make_shared<nano::transport::tcp_socket> (*node);
client->async_connect (node->network.endpoint (), connect_handler);
client_list.push_back (client);
}
@ -278,8 +278,8 @@ TEST (socket, disconnection_of_silent_connections)
auto node = system.add_node (config);
// On a connection, a server data socket is created. The shared pointer guarantees the object's lifecycle until the end of this test.
std::promise<std::shared_ptr<nano::transport::socket>> server_data_socket_promise;
std::future<std::shared_ptr<nano::transport::socket>> server_data_socket_future = server_data_socket_promise.get_future ();
std::promise<std::shared_ptr<nano::transport::tcp_socket>> server_data_socket_promise;
std::future<std::shared_ptr<nano::transport::tcp_socket>> server_data_socket_future = server_data_socket_promise.get_future ();
node->tcp_listener.connection_accepted.add ([&server_data_socket_promise] (auto const & socket, auto const & server) {
server_data_socket_promise.set_value (socket);
});
@ -287,7 +287,7 @@ TEST (socket, disconnection_of_silent_connections)
boost::asio::ip::tcp::endpoint dst_endpoint{ boost::asio::ip::address_v6::loopback (), node->tcp_listener.endpoint ().port () };
// Instantiates a client to simulate an incoming connection.
auto client_socket = std::make_shared<nano::transport::socket> (*node);
auto client_socket = std::make_shared<nano::transport::tcp_socket> (*node);
std::atomic<bool> connected{ false };
// Opening a connection that will be closed because it remains silent during the tolerance time.
client_socket->async_connect (dst_endpoint, [client_socket, &connected] (boost::system::error_code const & ec_a) {
@ -316,7 +316,7 @@ TEST (socket, drop_policy)
nano::inactive_node inactivenode (nano::unique_path (), node_flags);
auto node = inactivenode.node;
std::vector<std::shared_ptr<nano::transport::socket>> connections;
std::vector<std::shared_ptr<nano::transport::tcp_socket>> connections;
auto func = [&] (size_t total_message_count, nano::transport::buffer_drop_policy drop_policy) {
boost::asio::ip::tcp::endpoint endpoint (boost::asio::ip::address_v6::loopback (), system.get_available_port ());
@ -330,7 +330,7 @@ TEST (socket, drop_policy)
EXPECT_FALSE (ec);
});
auto client = std::make_shared<nano::transport::socket> (*node);
auto client = std::make_shared<nano::transport::tcp_socket> (*node);
auto channel = std::make_shared<nano::transport::tcp_channel> (*node, client);
std::atomic completed_writes{ 0 };
@ -355,11 +355,11 @@ TEST (socket, drop_policy)
// We're going to write twice the queue size + 1, and the server isn't reading
// The total number of drops should thus be 1 (the socket allows doubling the queue size for no_socket_drop)
func (nano::transport::socket::default_max_queue_size * 2 + 1, nano::transport::buffer_drop_policy::no_socket_drop);
func (nano::transport::tcp_socket::default_max_queue_size * 2 + 1, nano::transport::buffer_drop_policy::no_socket_drop);
ASSERT_EQ (1, node->stats.count (nano::stat::type::tcp, nano::stat::detail::tcp_write_no_socket_drop, nano::stat::dir::out));
ASSERT_EQ (0, node->stats.count (nano::stat::type::tcp, nano::stat::detail::tcp_write_drop, nano::stat::dir::out));
func (nano::transport::socket::default_max_queue_size + 1, nano::transport::buffer_drop_policy::limiter);
func (nano::transport::tcp_socket::default_max_queue_size + 1, nano::transport::buffer_drop_policy::limiter);
// The stats are accumulated from before
ASSERT_EQ (1, node->stats.count (nano::stat::type::tcp, nano::stat::detail::tcp_write_no_socket_drop, nano::stat::dir::out));
ASSERT_EQ (1, node->stats.count (nano::stat::type::tcp, nano::stat::detail::tcp_write_drop, nano::stat::dir::out));
@ -386,8 +386,8 @@ TEST (socket, concurrent_writes)
// We're expecting client_count*4 messages
std::atomic completed_reads{ 0 };
using reader_callback_t = std::function<void (std::shared_ptr<nano::transport::socket> const &)>;
reader_callback_t reader = [&completed_reads, &total_message_count, &reader] (std::shared_ptr<nano::transport::socket> const & socket_a) {
using reader_callback_t = std::function<void (std::shared_ptr<nano::transport::tcp_socket> const &)>;
reader_callback_t reader = [&completed_reads, &total_message_count, &reader] (std::shared_ptr<nano::transport::tcp_socket> const & socket_a) {
auto buff (std::make_shared<std::vector<uint8_t>> ());
buff->resize (1);
socket_a->async_read (buff, 1, [&completed_reads, &reader, &total_message_count, socket_a, buff] (boost::system::error_code const & ec, size_t size_a) {
@ -405,7 +405,7 @@ TEST (socket, concurrent_writes)
});
};
std::vector<std::shared_ptr<nano::transport::socket>> connections;
std::vector<std::shared_ptr<nano::transport::tcp_socket>> connections;
auto server_port (system.get_available_port ());
boost::asio::ip::tcp::endpoint endpoint (boost::asio::ip::address_v6::any (), server_port);
@ -418,7 +418,7 @@ TEST (socket, concurrent_writes)
accept_callback_t accept_callback = [&] (boost::system::error_code const & ec, boost::asio::ip::tcp::socket socket) {
if (!ec)
{
auto new_connection = std::make_shared<nano::transport::socket> (*node, std::move (socket), socket.remote_endpoint (), socket.local_endpoint ());
auto new_connection = std::make_shared<nano::transport::tcp_socket> (*node, std::move (socket), socket.remote_endpoint (), socket.local_endpoint ());
connections.push_back (new_connection);
reader (new_connection);
@ -433,10 +433,10 @@ TEST (socket, concurrent_writes)
std::atomic completed_connections{ 0 };
std::vector<std::shared_ptr<nano::transport::socket>> clients;
std::vector<std::shared_ptr<nano::transport::tcp_socket>> clients;
for (unsigned i = 0; i < client_count; i++)
{
auto client = std::make_shared<nano::transport::socket> (*node);
auto client = std::make_shared<nano::transport::tcp_socket> (*node);
clients.push_back (client);
client->async_connect (boost::asio::ip::tcp::endpoint (boost::asio::ip::address_v4::loopback (), acceptor.local_endpoint ().port ()),
[&completed_connections] (boost::system::error_code const & ec_a) {
@ -501,7 +501,7 @@ TEST (socket_timeout, connect)
boost::asio::ip::tcp::endpoint endpoint (boost::asio::ip::make_address_v6 ("::ffff:10.255.254.253"), 1234);
// create a client socket and try to connect to the IP address that wil not respond
auto socket = std::make_shared<nano::transport::socket> (*node);
auto socket = std::make_shared<nano::transport::tcp_socket> (*node);
std::atomic<bool> done = false;
boost::system::error_code ec;
socket->async_connect (endpoint, [&ec, &done] (boost::system::error_code const & ec_a) {
@ -544,7 +544,7 @@ TEST (socket_timeout, read)
});
// create a client socket to connect and call async_read, which should time out
auto socket = std::make_shared<nano::transport::socket> (*node);
auto socket = std::make_shared<nano::transport::tcp_socket> (*node);
std::atomic<bool> done = false;
boost::system::error_code ec;
socket->async_connect (acceptor.local_endpoint (), [&socket, &ec, &done] (boost::system::error_code const & ec_a) {
@ -592,7 +592,7 @@ TEST (socket_timeout, write)
// create a client socket and send lots of data to fill the socket queue on the local and remote side
// eventually, the all tcp queues should fill up and async_write will not be able to progress
// and the timeout should kick in and close the socket, which will cause the async_write to return an error
auto socket = std::make_shared<nano::transport::socket> (*node, nano::transport::socket_endpoint::client, 1024 * 64); // socket with a max queue size much larger than OS buffers
auto socket = std::make_shared<nano::transport::tcp_socket> (*node, nano::transport::socket_endpoint::client, 1024 * 64); // socket with a max queue size much larger than OS buffers
std::atomic<bool> done = false;
boost::system::error_code ec;
socket->async_connect (acceptor.local_endpoint (), [&socket, &ec, &done] (boost::system::error_code const & ec_a) {
@ -647,7 +647,7 @@ TEST (socket_timeout, read_overlapped)
});
// create a client socket to connect and call async_read twice, the second call should time out
auto socket = std::make_shared<nano::transport::socket> (*node);
auto socket = std::make_shared<nano::transport::tcp_socket> (*node);
std::atomic<bool> done = false;
boost::system::error_code ec;
socket->async_connect (acceptor.local_endpoint (), [&socket, &ec, &done] (boost::system::error_code const & ec_a) {
@ -706,7 +706,7 @@ TEST (socket_timeout, write_overlapped)
// create a client socket and send lots of data to fill the socket queue on the local and remote side
// eventually, the all tcp queues should fill up and async_write will not be able to progress
// and the timeout should kick in and close the socket, which will cause the async_write to return an error
auto socket = std::make_shared<nano::transport::socket> (*node, nano::transport::socket_endpoint::client, 1024 * 64); // socket with a max queue size much larger than OS buffers
auto socket = std::make_shared<nano::transport::tcp_socket> (*node, nano::transport::socket_endpoint::client, 1024 * 64); // socket with a max queue size much larger than OS buffers
std::atomic<bool> done = false;
boost::system::error_code ec;
socket->async_connect (acceptor.local_endpoint (), [&socket, &ec, &done] (boost::system::error_code const & ec_a) {

4
nano/node/CMakeLists.txt
View file

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

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

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

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

@ -1,6 +1,7 @@
#pragma once
#include <nano/lib/block_type.hpp>
#include <nano/node/transport/fwd.hpp>
#include <boost/system/error_code.hpp>
@ -10,10 +11,6 @@
namespace nano
{
class block;
namespace transport
{
class socket;
}
namespace bootstrap
{
@ -31,14 +28,14 @@ namespace bootstrap
* Read a type-prefixed block from 'socket' and pass the result, or an error, to 'callback'
* A normal end to series of blocks is a marked by return no error and a nullptr for block.
*/
void read (nano::transport::socket & socket, callback_type const && callback);
void read (nano::transport::tcp_socket & socket, callback_type const && callback);
private:
/**
* Called by read method on receipt of a block type byte.
* The type byte will be in the read_buffer.
*/
void received_type (nano::transport::socket & socket, callback_type const && callback);
void received_type (nano::transport::tcp_socket & socket, callback_type const && callback);
/**
* Called by received_type when a block is received, it parses the block and calls the callback.

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

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

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

@ -15,7 +15,7 @@ constexpr double nano::bootstrap_limits::bootstrap_minimum_termination_time_sec;
constexpr unsigned nano::bootstrap_limits::bootstrap_max_new_connections;
constexpr unsigned nano::bootstrap_limits::requeued_pulls_processed_blocks_factor;
nano::bootstrap_client::bootstrap_client (std::shared_ptr<nano::node> const & node_a, std::shared_ptr<nano::transport::tcp_channel> const & channel_a, std::shared_ptr<nano::transport::socket> const & socket_a) :
nano::bootstrap_client::bootstrap_client (std::shared_ptr<nano::node> const & node_a, std::shared_ptr<nano::transport::tcp_channel> const & channel_a, std::shared_ptr<nano::transport::tcp_socket> const & socket_a) :
node (node_a),
channel (channel_a),
socket (socket_a),
@ -151,7 +151,7 @@ std::shared_ptr<nano::bootstrap_client> nano::bootstrap_connections::find_connec
void nano::bootstrap_connections::connect_client (nano::tcp_endpoint const & endpoint_a, bool push_front)
{
++connections_count;
auto socket (std::make_shared<nano::transport::socket> (node));
auto socket (std::make_shared<nano::transport::tcp_socket> (node));
auto this_l (shared_from_this ());
socket->async_connect (endpoint_a,
[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/common.hpp>
#include <nano/node/transport/socket.hpp>
#include <nano/node/transport/tcp_socket.hpp>
#include <atomic>
@ -25,7 +25,7 @@ class pull_info;
class bootstrap_client final : public std::enable_shared_from_this<bootstrap_client>
{
public:
bootstrap_client (std::shared_ptr<nano::node> const & node_a, std::shared_ptr<nano::transport::tcp_channel> const & channel_a, std::shared_ptr<nano::transport::socket> const & socket_a);
bootstrap_client (std::shared_ptr<nano::node> const & node_a, std::shared_ptr<nano::transport::tcp_channel> const & channel_a, std::shared_ptr<nano::transport::tcp_socket> const & socket_a);
~bootstrap_client ();
void stop (bool force);
double sample_block_rate ();
@ -33,7 +33,7 @@ public:
void set_start_time (std::chrono::steady_clock::time_point start_time_a);
std::weak_ptr<nano::node> node;
std::shared_ptr<nano::transport::tcp_channel> channel;
std::shared_ptr<nano::transport::socket> socket;
std::shared_ptr<nano::transport::tcp_socket> socket;
std::shared_ptr<std::vector<uint8_t>> receive_buffer;
std::atomic<uint64_t> block_count{ 0 };
std::atomic<double> block_rate{ 0 };

2
nano/node/node_observers.hpp
View file

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@ -395,7 +395,7 @@ auto nano::transport::tcp_listener::accept_one (asio::ip::tcp::socket raw_socket
stats.inc (nano::stat::type::tcp_listener, nano::stat::detail::accept_success, to_stat_dir (type));
logger.debug (nano::log::type::tcp_listener, "Accepted connection: {} ({})", fmt::streamed (remote_endpoint), to_string (type));
auto socket = std::make_shared<nano::transport::socket> (node, std::move (raw_socket), remote_endpoint, local_endpoint, to_socket_endpoint (type));
auto socket = std::make_shared<nano::transport::tcp_socket> (node, std::move (raw_socket), remote_endpoint, local_endpoint, to_socket_endpoint (type));
auto server = std::make_shared<nano::transport::tcp_server> (socket, node.shared (), true);
connections.emplace_back (connection{ remote_endpoint, socket, server });
@ -567,7 +567,7 @@ asio::ip::tcp::endpoint nano::transport::tcp_listener::endpoint () const
return { asio::ip::address_v6::loopback (), local.port () };
}
auto nano::transport::tcp_listener::sockets () const -> std::vector<std::shared_ptr<socket>>
auto nano::transport::tcp_listener::sockets () const -> std::vector<std::shared_ptr<tcp_socket>>
{
nano::lock_guard<nano::mutex> lock{ mutex };
auto r = connections

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

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

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

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

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

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

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

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

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

@ -58,7 +58,7 @@ private:
};
/** Socket class for tcp clients and newly accepted connections */
class socket final : public std::enable_shared_from_this<socket>
class tcp_socket final : public std::enable_shared_from_this<tcp_socket>
{
friend class tcp_server;
friend class tcp_channels;
@ -68,10 +68,10 @@ public:
static std::size_t constexpr default_max_queue_size = 128;
public:
explicit socket (nano::node &, nano::transport::socket_endpoint = socket_endpoint::client, std::size_t max_queue_size = default_max_queue_size);
explicit tcp_socket (nano::node &, nano::transport::socket_endpoint = socket_endpoint::client, std::size_t max_queue_size = default_max_queue_size);
// TODO: Accepting remote/local endpoints as a parameter is unnecessary, but is needed for now to keep compatibility with the legacy code
socket (
tcp_socket (
nano::node &,
boost::asio::ip::tcp::socket,
boost::asio::ip::tcp::endpoint remote_endpoint,
@ -79,7 +79,7 @@ public:
nano::transport::socket_endpoint = socket_endpoint::server,
std::size_t max_queue_size = default_max_queue_size);
~socket ();
~tcp_socket ();
void start ();
void close ();
@ -147,7 +147,7 @@ protected:
std::weak_ptr<nano::node> node_w;
boost::asio::strand<boost::asio::io_context::executor_type> strand;
boost::asio::ip::tcp::socket tcp_socket;
boost::asio::ip::tcp::socket raw_socket;
/** The other end of the connection */
boost::asio::ip::tcp::endpoint remote;
@ -205,7 +205,7 @@ public: // Logging
virtual void operator() (nano::object_stream &) const;
};
using address_socket_mmap = std::multimap<boost::asio::ip::address, std::weak_ptr<socket>>;
using address_socket_mmap = std::multimap<boost::asio::ip::address, std::weak_ptr<tcp_socket>>;
namespace socket_functions
{

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

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