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)
{
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);
req->start = 1;
req->end = 2;
@ -25,7 +25,7 @@ TEST (bulk_pull, no_address)
TEST (bulk_pull, genesis_to_end)
{
nano::test::system system (1);
auto connection (std::make_shared<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);
req->start = nano::dev::genesis_key.pub;
req->end.clear ();
@ -38,7 +38,7 @@ TEST (bulk_pull, genesis_to_end)
TEST (bulk_pull, no_end)
{
nano::test::system system (1);
auto connection (std::make_shared<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);
req->start = nano::dev::genesis_key.pub;
req->end = 1;
@ -70,7 +70,7 @@ TEST (bulk_pull, end_not_owned)
open->signature = nano::sign_message (key2.prv, key2.pub, open->hash ());
system.nodes[0]->work_generate_blocking (*open);
ASSERT_EQ (nano::process_result::progress, system.nodes[0]->process (*open).code);
auto connection (std::make_shared<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);
req->start = key2.pub;
req->end = nano::dev::genesis->hash ();
@ -81,7 +81,7 @@ TEST (bulk_pull, end_not_owned)
TEST (bulk_pull, none)
{
nano::test::system system (1);
auto connection (std::make_shared<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);
req->start = nano::dev::genesis_key.pub;
req->end = nano::dev::genesis->hash ();
@ -93,7 +93,7 @@ TEST (bulk_pull, none)
TEST (bulk_pull, get_next_on_open)
{
nano::test::system system (1);
auto connection (std::make_shared<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);
req->start = nano::dev::genesis_key.pub;
req->end.clear ();
@ -123,7 +123,7 @@ TEST (bulk_pull, ascending_one_hash)
.build_shared ();
node.work_generate_blocking (*block1);
ASSERT_EQ (nano::process_result::progress, node.process (*block1).code);
auto socket = std::make_shared<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 req = std::make_unique<nano::bulk_pull> (nano::dev::network_params.network);
req->start = nano::dev::genesis->hash ();
@ -155,7 +155,7 @@ TEST (bulk_pull, ascending_two_account)
.build_shared ();
node.work_generate_blocking (*block1);
ASSERT_EQ (nano::process_result::progress, node.process (*block1).code);
auto socket = std::make_shared<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 req = std::make_unique<nano::bulk_pull> (nano::dev::network_params.network);
req->start = nano::dev::genesis->hash ();
@ -190,7 +190,7 @@ TEST (bulk_pull, ascending_end)
.build_shared ();
node.work_generate_blocking (*block1);
ASSERT_EQ (nano::process_result::progress, node.process (*block1).code);
auto socket = std::make_shared<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 req = std::make_unique<nano::bulk_pull> (nano::dev::network_params.network);
req->start = nano::dev::genesis_key.pub;
@ -206,7 +206,7 @@ TEST (bulk_pull, ascending_end)
TEST (bulk_pull, by_block)
{
nano::test::system system (1);
auto connection (std::make_shared<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);
req->start = nano::dev::genesis->hash ();
req->end.clear ();
@ -222,7 +222,7 @@ TEST (bulk_pull, by_block)
TEST (bulk_pull, by_block_single)
{
nano::test::system system (1);
auto connection (std::make_shared<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);
req->start = nano::dev::genesis->hash ();
req->end = nano::dev::genesis->hash ();
@ -259,7 +259,7 @@ TEST (bulk_pull, count_limit)
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node0->process (*receive1).code);
auto connection (std::make_shared<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);
req->start = receive1->hash ();
req->set_count_present (true);
@ -1643,7 +1643,7 @@ TEST (frontier_req_response, DISABLED_destruction)
TEST (frontier_req, begin)
{
nano::test::system system (1);
auto connection (std::make_shared<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);
req->start.clear ();
req->age = std::numeric_limits<decltype (req->age)>::max ();
@ -1656,7 +1656,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::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);
req->start = nano::dev::genesis_key.pub.number () + 1;
req->age = std::numeric_limits<decltype (req->age)>::max ();
@ -1697,7 +1697,7 @@ TEST (frontier_req, count)
node1->work_generate_blocking (*receive1);
ASSERT_EQ (nano::process_result::progress, node1->process (*receive1).code);
auto connection (std::make_shared<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);
req->start.clear ();
req->age = std::numeric_limits<decltype (req->age)>::max ();
@ -1710,7 +1710,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::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);
req->start.clear ();
req->age = 1;
@ -1723,7 +1723,7 @@ TEST (frontier_req, time_bound)
req2->start.clear ();
req2->age = 1;
req2->count = std::numeric_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)));
ASSERT_TRUE (request2->current.is_zero ());
}
@ -1731,7 +1731,7 @@ TEST (frontier_req, time_bound)
TEST (frontier_req, time_cutoff)
{
nano::test::system system (1);
auto connection (std::make_shared<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);
req->start.clear ();
req->age = 3;
@ -1745,7 +1745,7 @@ TEST (frontier_req, time_cutoff)
req2->start.clear ();
req2->age = 3;
req2->count = std::numeric_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)));
ASSERT_TRUE (request2->frontier.is_zero ());
}
@ -1817,7 +1817,7 @@ TEST (frontier_req, confirmed_frontier)
ASSERT_EQ (nano::process_result::progress, node1->process (*receive2).code);
// Request for all accounts (confirmed only)
auto connection (std::make_shared<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);
req->start.clear ();
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);
// 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);
req2->start = key_before_genesis.pub;
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);
// 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);
req3->start = key_after_genesis.pub;
req3->age = std::numeric_limits<decltype (req3->age)>::max ();
@ -1856,7 +1856,7 @@ TEST (frontier_req, confirmed_frontier)
ASSERT_TRUE (request3->frontier.is_zero ());
// Request for all accounts (unconfirmed blocks)
auto connection4 (std::make_shared<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);
req4->start.clear ();
req4->age = std::numeric_limits<decltype (req4->age)>::max ();
@ -1867,7 +1867,7 @@ TEST (frontier_req, confirmed_frontier)
ASSERT_EQ (receive1->hash (), request4->frontier);
// Request starting with account after genesis (unconfirmed blocks)
auto connection5 (std::make_shared<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);
req5->start = key_after_genesis.pub;
req5->age = std::numeric_limits<decltype (req5->age)>::max ();
@ -1880,7 +1880,7 @@ TEST (frontier_req, confirmed_frontier)
// Confirm account before genesis (confirmed only)
nano::test::start_elections (system, *node1, { send1, receive1 }, true);
ASSERT_TIMELY (5s, node1->block_confirmed (send1->hash ()) && node1->block_confirmed (receive1->hash ()));
auto connection6 (std::make_shared<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);
req6->start = key_before_genesis.pub;
req6->age = std::numeric_limits<decltype (req6->age)>::max ();
@ -1895,7 +1895,7 @@ TEST (frontier_req, confirmed_frontier)
// Confirm account after genesis (confirmed only)
nano::test::start_elections (system, *node1, { send2, receive2 }, true);
ASSERT_TIMELY (5s, node1->block_confirmed (send2->hash ()) && node1->block_confirmed (receive2->hash ()));
auto connection7 (std::make_shared<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);
req7->start = key_after_genesis.pub;
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 send3 (system.wallet (0)->send_action (nano::dev::genesis->account (), key1.pub, 2));
ASSERT_TIMELY (5s, system.nodes[0]->balance (key1.pub) == 25);
auto connection (std::make_shared<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);

30
nano/core_test/network.cpp
View file

@ -1,7 +1,7 @@
#include <nano/node/network.hpp>
#include <nano/node/nodeconfig.hpp>
#include <nano/node/socket.hpp>
#include <nano/node/transport/inproc.hpp>
#include <nano/node/transport/socket.hpp>
#include <nano/test_common/network.hpp>
#include <nano/test_common/system.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
std::shared_ptr<nano::socket> sock0 = channel0->socket.lock ();
std::shared_ptr<nano::socket> sock1 = channel1->socket.lock ();
std::shared_ptr<nano::transport::socket> sock0 = channel0->socket.lock ();
std::shared_ptr<nano::transport::socket> sock1 = channel1->socket.lock ();
ASSERT_TRUE (sock0->local_endpoint () == sock1->remote_endpoint ());
ASSERT_TRUE (sock1->local_endpoint () == sock0->remote_endpoint ());
}
@ -703,7 +703,7 @@ TEST (node, port_mapping)
TEST (tcp_listener, tcp_node_id_handshake)
{
nano::test::system system (1);
auto socket (std::make_shared<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 cookie (system.nodes[0]->network.syn_cookies.assign (nano::transport::map_tcp_to_endpoint (bootstrap_endpoint)));
nano::node_id_handshake node_id_handshake{ nano::dev::network_params.network, cookie, boost::none };
@ -739,7 +739,7 @@ TEST (tcp_listener, DISABLED_tcp_listener_timeout_empty)
{
nano::test::system system (1);
auto node0 (system.nodes[0]);
auto socket (std::make_shared<nano::client_socket> (*node0));
auto socket (std::make_shared<nano::transport::client_socket> (*node0));
std::atomic<bool> connected (false);
socket->async_connect (node0->tcp_listener.endpoint (), [&connected] (boost::system::error_code const & ec) {
ASSERT_FALSE (ec);
@ -762,7 +762,7 @@ TEST (tcp_listener, tcp_listener_timeout_node_id_handshake)
{
nano::test::system system (1);
auto node0 (system.nodes[0]);
auto socket (std::make_shared<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 ())));
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);
@ -919,7 +919,7 @@ TEST (network, bandwidth_limiter)
ASSERT_TIMELY (1s, 1 == node.stats.count (nano::stat::type::drop, nano::stat::detail::publish, nano::stat::dir::out));
// Send non-droppable message, i.e. drop stats should not increase
channel2.send (message, nullptr, nano::buffer_drop_policy::no_limiter_drop);
channel2.send (message, nullptr, nano::transport::buffer_drop_policy::no_limiter_drop);
ASSERT_TIMELY (1s, 1 == node.stats.count (nano::stat::type::drop, nano::stat::detail::publish, nano::stat::dir::out));
// change the bandwidth settings, 2 packets will be dropped
@ -1195,11 +1195,11 @@ TEST (network, purge_dead_channel_outgoing)
auto & node1 = *system.add_node (flags);
// We expect one incoming and one outgoing connection
std::shared_ptr<nano::socket> outgoing;
std::shared_ptr<nano::socket> incoming;
std::shared_ptr<nano::transport::socket> outgoing;
std::shared_ptr<nano::transport::socket> incoming;
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++;
outgoing = socket.shared_from_this ();
@ -1207,7 +1207,7 @@ TEST (network, purge_dead_channel_outgoing)
});
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++;
incoming = socket.shared_from_this ();
@ -1267,11 +1267,11 @@ TEST (network, purge_dead_channel_incoming)
auto & node1 = *system.add_node (flags);
// We expect one incoming and one outgoing connection
std::shared_ptr<nano::socket> outgoing;
std::shared_ptr<nano::socket> incoming;
std::shared_ptr<nano::transport::socket> outgoing;
std::shared_ptr<nano::transport::socket> incoming;
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++;
outgoing = socket.shared_from_this ();
@ -1279,7 +1279,7 @@ TEST (network, purge_dead_channel_incoming)
});
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++;
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 ()))
.build_shared ();
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.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_server.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 ();
std::vector<std::pair<nano::block_hash, nano::root>> request;
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);
node.aggregator.add (dummy_channel, request);
ASSERT_EQ (1, node.aggregator.size ());
@ -98,7 +98,7 @@ TEST (request_aggregator, one_update)
ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *receive1).code);
std::vector<std::pair<nano::block_hash, nano::root>> request;
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);
node.aggregator.add (dummy_channel, request);
request.clear ();
@ -165,7 +165,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::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);
// Process both blocks
node.aggregator.add (dummy_channel, request);
@ -289,7 +289,7 @@ TEST (request_aggregator, split)
election->force_confirm ();
ASSERT_TIMELY (5s, max_vbh + 2 == node.ledger.cache.cemented_count);
ASSERT_EQ (max_vbh + 1, request.size ());
auto client = std::make_shared<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);
node.aggregator.add (dummy_channel, request);
ASSERT_EQ (1, node.aggregator.size ());
@ -330,7 +330,7 @@ TEST (request_aggregator, channel_lifetime)
request.emplace_back (send1->hash (), send1->root ());
{
// The aggregator should extend the lifetime of the channel
auto client = std::make_shared<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);
node.aggregator.add (dummy_channel, request);
}
@ -361,11 +361,11 @@ TEST (request_aggregator, channel_update)
request.emplace_back (send1->hash (), send1->root ());
std::weak_ptr<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);
channel1_w = dummy_channel1;
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);
// The aggregator then hold channel2 and drop channel1
node.aggregator.add (dummy_channel2, request);
@ -399,7 +399,7 @@ TEST (request_aggregator, channel_max_queue)
ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send1).code);
std::vector<std::pair<nano::block_hash, nano::root>> request;
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);
node.aggregator.add (dummy_channel, request);
node.aggregator.add (dummy_channel, request);
@ -427,7 +427,7 @@ TEST (request_aggregator, unique)
ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send1).code);
std::vector<std::pair<nano::block_hash, nano::root>> request;
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);
node.aggregator.add (dummy_channel, request);
node.aggregator.add (dummy_channel, request);
@ -474,7 +474,7 @@ TEST (request_aggregator, cannot_vote)
request.emplace_back (send2->hash (), send2->root ());
// Incorrect hash, correct root
request.emplace_back (1, send2->root ());
auto client = std::make_shared<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);
node.aggregator.add (dummy_channel, request);
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/network_v6.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/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 };
// 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;
server_socket->start (ec);
ASSERT_FALSE (ec);
// successful incoming connections are stored in server_sockets to keep them alive (server side)
std::vector<std::shared_ptr<nano::socket>> server_sockets;
server_socket->on_connection ([&server_sockets] (std::shared_ptr<nano::socket> const & new_connection, boost::system::error_code const & ec_a) {
std::vector<std::shared_ptr<nano::transport::socket>> server_sockets;
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);
return true;
});
@ -48,13 +48,13 @@ TEST (socket, max_connections)
// start 3 clients, 2 will persist but 1 will be dropped
auto client1 = std::make_shared<nano::client_socket> (*node);
auto client1 = std::make_shared<nano::transport::client_socket> (*node);
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);
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);
auto get_tcp_accept_failures = [&node] () {
@ -73,10 +73,10 @@ TEST (socket, max_connections)
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);
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);
ASSERT_TIMELY (5s, get_tcp_accept_failures () == 2);
@ -90,13 +90,13 @@ TEST (socket, max_connections)
server_sockets[2].reset ();
ASSERT_EQ (server_sockets.size (), 3);
auto client6 = std::make_shared<nano::client_socket> (*node);
auto client6 = std::make_shared<nano::transport::client_socket> (*node);
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);
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);
ASSERT_TIMELY (5s, get_tcp_accept_failures () == 3);
@ -123,14 +123,14 @@ TEST (socket, max_connections_per_ip)
const auto max_global_connections = 1000;
auto server_socket = std::make_shared<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;
server_socket->start (ec);
ASSERT_FALSE (ec);
// successful incoming connections are stored in server_sockets to keep them alive (server side)
std::vector<std::shared_ptr<nano::socket>> server_sockets;
server_socket->on_connection ([&server_sockets] (std::shared_ptr<nano::socket> const & new_connection, boost::system::error_code const & ec_a) {
std::vector<std::shared_ptr<nano::transport::socket>> server_sockets;
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);
return true;
});
@ -143,12 +143,12 @@ TEST (socket, max_connections_per_ip)
};
// start n clients, n-1 will persist but 1 will be dropped, where n == max_ip_connections
std::vector<std::shared_ptr<nano::socket>> client_list;
std::vector<std::shared_ptr<nano::transport::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::client_socket> (*node);
auto client = std::make_shared<nano::transport::client_socket> (*node);
client->async_connect (dst_endpoint, connect_handler);
client_list.push_back (client);
}
@ -171,7 +171,7 @@ TEST (socket, max_connections_per_ip)
TEST (socket, limited_subnet_address)
{
auto address = boost::asio::ip::make_address ("a41d:b7b2:8298:cf45:672e:bd1a:e7fb:f713");
auto network = nano::socket_functions::get_ipv6_subnet_address (address.to_v6 (), 32); // network prefix = 32.
auto network = nano::transport::socket_functions::get_ipv6_subnet_address (address.to_v6 (), 32); // network prefix = 32.
ASSERT_EQ ("a41d:b7b2:8298:cf45:672e:bd1a:e7fb:f713/32", network.to_string ());
ASSERT_EQ ("a41d:b7b2::/32", network.canonical ().to_string ());
}
@ -179,14 +179,14 @@ TEST (socket, limited_subnet_address)
TEST (socket, first_ipv6_subnet_address)
{
auto address = boost::asio::ip::make_address ("a41d:b7b2:8298:cf45:672e:bd1a:e7fb:f713");
auto first_address = nano::socket_functions::first_ipv6_subnet_address (address.to_v6 (), 32); // network prefix = 32.
auto first_address = nano::transport::socket_functions::first_ipv6_subnet_address (address.to_v6 (), 32); // network prefix = 32.
ASSERT_EQ ("a41d:b7b2::", first_address.to_string ());
}
TEST (socket, last_ipv6_subnet_address)
{
auto address = boost::asio::ip::make_address ("a41d:b7b2:8298:cf45:672e:bd1a:e7fb:f713");
auto last_address = nano::socket_functions::last_ipv6_subnet_address (address.to_v6 (), 32); // network prefix = 32.
auto last_address = nano::transport::socket_functions::last_ipv6_subnet_address (address.to_v6 (), 32); // network prefix = 32.
ASSERT_EQ ("a41d:b7b2:ffff:ffff:ffff:ffff:ffff:ffff", last_address.to_string ());
}
@ -203,15 +203,15 @@ TEST (socket, count_subnetwork_connections)
auto address5 = boost::asio::ip::make_address ("a41d:b7b3::"); // out of the network prefix
auto address6 = boost::asio::ip::make_address ("a41d:b7b3::1"); // out of the network prefix
auto connection0 = std::make_shared<nano::client_socket> (*node);
auto connection1 = std::make_shared<nano::client_socket> (*node);
auto connection2 = std::make_shared<nano::client_socket> (*node);
auto connection3 = std::make_shared<nano::client_socket> (*node);
auto connection4 = std::make_shared<nano::client_socket> (*node);
auto connection5 = std::make_shared<nano::client_socket> (*node);
auto connection6 = std::make_shared<nano::client_socket> (*node);
auto connection0 = std::make_shared<nano::transport::client_socket> (*node);
auto connection1 = std::make_shared<nano::transport::client_socket> (*node);
auto connection2 = std::make_shared<nano::transport::client_socket> (*node);
auto connection3 = std::make_shared<nano::transport::client_socket> (*node);
auto connection4 = std::make_shared<nano::transport::client_socket> (*node);
auto connection5 = std::make_shared<nano::transport::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 (address1, connection1);
connections_per_address.emplace (address2, connection2);
@ -221,7 +221,7 @@ TEST (socket, count_subnetwork_connections)
connections_per_address.emplace (address6, connection6);
// Asserts it counts only the connections for the specified address and its network prefix.
ASSERT_EQ (4, nano::socket_functions::count_subnetwork_connections (connections_per_address, address1.to_v6 (), 32));
ASSERT_EQ (4, nano::transport::socket_functions::count_subnetwork_connections (connections_per_address, address1.to_v6 (), 32));
}
TEST (socket, max_connections_per_subnetwork)
@ -245,14 +245,14 @@ TEST (socket, max_connections_per_subnetwork)
const auto max_global_connections = 1000;
auto server_socket = std::make_shared<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;
server_socket->start (ec);
ASSERT_FALSE (ec);
// successful incoming connections are stored in server_sockets to keep them alive (server side)
std::vector<std::shared_ptr<nano::socket>> server_sockets;
server_socket->on_connection ([&server_sockets] (std::shared_ptr<nano::socket> const & new_connection, boost::system::error_code const & ec_a) {
std::vector<std::shared_ptr<nano::transport::socket>> server_sockets;
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);
return true;
});
@ -265,12 +265,12 @@ TEST (socket, max_connections_per_subnetwork)
};
// start n clients, n-1 will persist but 1 will be dropped, where n == max_subnetwork_connections
std::vector<std::shared_ptr<nano::socket>> client_list;
std::vector<std::shared_ptr<nano::transport::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::client_socket> (*node);
auto client = std::make_shared<nano::transport::client_socket> (*node);
client->async_connect (dst_endpoint, connect_handler);
client_list.push_back (client);
}
@ -308,14 +308,14 @@ TEST (socket, disabled_max_peers_per_ip)
const auto max_global_connections = 1000;
auto server_socket = std::make_shared<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;
server_socket->start (ec);
ASSERT_FALSE (ec);
// successful incoming connections are stored in server_sockets to keep them alive (server side)
std::vector<std::shared_ptr<nano::socket>> server_sockets;
server_socket->on_connection ([&server_sockets] (std::shared_ptr<nano::socket> const & new_connection, boost::system::error_code const & ec_a) {
std::vector<std::shared_ptr<nano::transport::socket>> server_sockets;
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);
return true;
});
@ -328,12 +328,12 @@ TEST (socket, disabled_max_peers_per_ip)
};
// start n clients, n-1 will persist but 1 will be dropped, where n == max_ip_connections
std::vector<std::shared_ptr<nano::socket>> client_list;
std::vector<std::shared_ptr<nano::transport::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::client_socket> (*node);
auto client = std::make_shared<nano::transport::client_socket> (*node);
client->async_connect (dst_endpoint, connect_handler);
client_list.push_back (client);
}
@ -371,20 +371,20 @@ TEST (socket, disconnection_of_silent_connections)
boost::asio::ip::tcp::endpoint dst_endpoint{ boost::asio::ip::address_v6::loopback (), server_port };
// start a server listening socket
auto server_socket = std::make_shared<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;
server_socket->start (ec);
ASSERT_FALSE (ec);
// on a connection, a server data socket is created. The shared pointer guarantees the object's lifecycle until the end of this test.
std::shared_ptr<nano::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) {
std::shared_ptr<nano::transport::socket> server_data_socket;
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;
return true;
});
// 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 };
// Opening a connection that will be closed because it remains silent during the tolerance time.
client_socket->async_connect (dst_endpoint, [client_socket, &connected] (boost::system::error_code const & ec_a) {
@ -419,24 +419,24 @@ TEST (socket, drop_policy)
nano::thread_runner runner (node->io_ctx, 1);
std::vector<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 ());
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;
server_socket->start (ec);
ASSERT_FALSE (ec);
// Accept connection, but don't read so the writer will drop.
server_socket->on_connection ([&connections] (std::shared_ptr<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);
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::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
// The total number of drops should thus be 1 (the socket allows doubling the queue size for no_socket_drop)
func (nano::socket::queue_size_max * 2 + 1, nano::buffer_drop_policy::no_socket_drop);
func (nano::transport::socket::queue_size_max * 2 + 1, nano::transport::buffer_drop_policy::no_socket_drop);
ASSERT_EQ (1, node->stats.count (nano::stat::type::tcp, nano::stat::detail::tcp_write_no_socket_drop, nano::stat::dir::out));
ASSERT_EQ (0, node->stats.count (nano::stat::type::tcp, nano::stat::detail::tcp_write_drop, nano::stat::dir::out));
func (nano::socket::queue_size_max + 1, nano::buffer_drop_policy::limiter);
func (nano::transport::socket::queue_size_max + 1, nano::transport::buffer_drop_policy::limiter);
// The stats are accumulated from before
ASSERT_EQ (1, node->stats.count (nano::stat::type::tcp, nano::stat::detail::tcp_write_no_socket_drop, nano::stat::dir::out));
ASSERT_EQ (1, node->stats.count (nano::stat::type::tcp, nano::stat::detail::tcp_write_drop, nano::stat::dir::out));
@ -493,7 +493,7 @@ TEST (socket, concurrent_writes)
// We're expecting client_count*4 messages
nano::test::counted_completion read_count_completion (total_message_count);
std::function<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>> ());
buff->resize (1);
#ifndef _WIN32
@ -525,14 +525,14 @@ TEST (socket, concurrent_writes)
boost::asio::ip::tcp::endpoint endpoint (boost::asio::ip::address_v4::any (), 25000);
auto server_socket = std::make_shared<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;
server_socket->start (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
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)
{
std::cerr << "on_connection: " << ec_a.message () << std::endl;
@ -547,10 +547,10 @@ TEST (socket, concurrent_writes)
});
nano::test::counted_completion connection_count_completion (client_count);
std::vector<std::shared_ptr<nano::socket>> clients;
std::vector<std::shared_ptr<nano::transport::socket>> clients;
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);
client->async_connect (boost::asio::ip::tcp::endpoint (boost::asio::ip::address_v4::loopback (), 25000),
[&connection_count_completion] (boost::system::error_code const & ec_a) {
@ -628,7 +628,7 @@ TEST (socket_timeout, connect)
boost::asio::ip::tcp::endpoint endpoint (boost::asio::ip::make_address_v6 ("::ffff:10.255.254.253"), nano::test::get_available_port ());
// create a client socket and try to connect to the IP address that wil not respond
auto socket = std::make_shared<nano::client_socket> (*node);
auto socket = std::make_shared<nano::transport::client_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) {
@ -669,7 +669,7 @@ TEST (socket_timeout, read)
});
// create a client socket to connect and call async_read, which should time out
auto socket = std::make_shared<nano::client_socket> (*node);
auto socket = std::make_shared<nano::transport::client_socket> (*node);
std::atomic<bool> done = false;
boost::system::error_code ec;
socket->async_connect (endpoint, [&socket, &ec, &done] (boost::system::error_code const & ec_a) {
@ -716,7 +716,7 @@ TEST (socket_timeout, write)
// create a client socket and send lots of data to fill the socket queue on the local and remote side
// eventually, the all tcp queues should fill up and async_write will not be able to progress
// and the timeout should kick in and close the socket, which will cause the async_write to return an error
auto socket = std::make_shared<nano::client_socket> (*node);
auto socket = std::make_shared<nano::transport::client_socket> (*node);
std::atomic<bool> done = false;
boost::system::error_code ec;
socket->async_connect (endpoint, [&socket, &ec, &done] (boost::system::error_code const & ec_a) {
@ -769,7 +769,7 @@ TEST (socket_timeout, read_overlapped)
});
// create a client socket to connect and call async_read twice, the second call should time out
auto socket = std::make_shared<nano::client_socket> (*node);
auto socket = std::make_shared<nano::transport::client_socket> (*node);
std::atomic<bool> done = false;
boost::system::error_code ec;
socket->async_connect (endpoint, [&socket, &ec, &done] (boost::system::error_code const & ec_a) {
@ -826,7 +826,7 @@ TEST (socket_timeout, write_overlapped)
// create a client socket and send lots of data to fill the socket queue on the local and remote side
// eventually, the all tcp queues should fill up and async_write will not be able to progress
// and the timeout should kick in and close the socket, which will cause the async_write to return an error
auto socket = std::make_shared<nano::client_socket> (*node);
auto socket = std::make_shared<nano::transport::client_socket> (*node);
std::atomic<bool> done = false;
boost::system::error_code ec;
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
signatures.hpp
signatures.cpp
socket.hpp
socket.cpp
state_block_signature_verification.hpp
state_block_signature_verification.cpp
telemetry.hpp
@ -198,6 +196,8 @@ add_library(
transport/inproc.cpp
transport/message_deserializer.hpp
transport/message_deserializer.cpp
transport/socket.hpp
transport/socket.cpp
transport/tcp.hpp
transport/tcp.cpp
transport/tcp_server.hpp

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))
{
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))

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

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

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

@ -8,7 +8,11 @@
namespace nano
{
class block;
class socket;
namespace transport
{
class socket;
}
namespace bootstrap
{
/**
@ -25,14 +29,14 @@ namespace bootstrap
* Read a type-prefixed block from 'socket' and pass the result, or an error, to 'callback'
* A normal end to series of blocks is a marked by return no error and a nullptr for block.
*/
void read (nano::socket & socket, callback_type const && callback);
void read (nano::transport::socket & socket, callback_type const && callback);
private:
/**
* Called by read method on receipt of a block type byte.
* The type byte will be in the read_buffer.
*/
void received_type (nano::socket & socket, callback_type const && callback);
void received_type (nano::transport::socket & socket, callback_type const && callback);
/**
* Called by received_type when a block is received, it parses the block and calls the callback.

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

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

@ -1,7 +1,7 @@
#pragma once
#include <nano/node/messages.hpp>
#include <nano/node/socket.hpp>
#include <nano/node/transport/socket.hpp>
#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 ()

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::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),
connections (connections_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)
{
++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 ());
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/socket.hpp>
#include <nano/node/transport/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, 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 ();
void stop (bool force);
double sample_block_rate ();
@ -34,7 +34,7 @@ public:
std::shared_ptr<nano::node> node;
nano::bootstrap_connections & connections;
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::atomic<uint64_t> block_count{ 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) :

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);
}
},
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
network.flood_message (winner, nano::buffer_drop_policy::limiter, 0.5f);
network.flood_message (winner, nano::transport::buffer_drop_policy::limiter, 0.5f);
error = false;
}
return error;

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

4
nano/node/network.hpp
View file

@ -73,7 +73,7 @@ public:
nano::networks id;
void start ();
void stop ();
void flood_message (nano::message &, nano::buffer_drop_policy const = nano::buffer_drop_policy::limiter, float const = 1.0f);
void flood_message (nano::message &, nano::transport::buffer_drop_policy const = nano::transport::buffer_drop_policy::limiter, float const = 1.0f);
void flood_keepalive (float const scale_a = 1.0f);
void flood_keepalive_self (float const scale_a = 0.5f);
void flood_vote (std::shared_ptr<nano::vote> const &, float scale);
@ -81,7 +81,7 @@ public:
// Flood block to all PRs and a random selection of non-PRs
void flood_block_initial (std::shared_ptr<nano::block> const &);
// 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 merge_peers (std::array<nano::endpoint, 8> 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::telemetry_data const &, std::shared_ptr<nano::transport::channel> const &> telemetry;
nano::observer_set<nano::socket &> socket_connected;
nano::observer_set<nano::socket &> socket_accepted;
nano::observer_set<nano::transport::socket &> socket_connected;
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);

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);
}
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 detail = nano::to_stat_detail (message_a.header.type);
auto is_droppable_by_limiter = drop_policy_a == nano::buffer_drop_policy::limiter;
auto is_droppable_by_limiter = (drop_policy_a == nano::transport::buffer_drop_policy::limiter);
auto should_pass (node.outbound_limiter.should_pass (buffer.size (), limiter_type));
if (!is_droppable_by_limiter || should_pass)
{

6
nano/node/transport/channel.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/socket.hpp>
#include <nano/node/transport/socket.hpp>
#include <boost/asio/ip/network_v6.hpp>
@ -27,10 +27,10 @@ public:
virtual std::size_t hash_code () const = 0;
virtual bool operator== (nano::transport::channel const &) const = 0;
void send (nano::message & message_a, std::function<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
//
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 nano::endpoint get_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.
*/
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 size = buffer_a.size ();

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

@ -24,7 +24,7 @@ namespace transport
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
nano::transport::buffer_drop_policy = nano::transport::buffer_drop_policy::limiter
) override;
// 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.
* 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
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;
// 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;
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);
}
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);
@ -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 };
auto error = false;

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

@ -2,7 +2,7 @@
#include <nano/node/common.hpp>
#include <nano/node/messages.hpp>
#include <nano/node/socket.hpp>
#include <nano/node/transport/socket.hpp>
#include <memory>
#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`.
* 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:
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);
/*

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/read.hpp>
#include <nano/node/node.hpp>
#include <nano/node/socket.hpp>
#include <nano/node/transport/socket.hpp>
#include <nano/node/transport/transport.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 () },
tcp_socket{ node_a.io_ctx },
node{ node_a },
@ -45,12 +45,12 @@ nano::socket::socket (nano::node & node_a, endpoint_type_t endpoint_type_a) :
{
}
nano::socket::~socket ()
nano::transport::socket::~socket ()
{
close_internal ();
}
void nano::socket::async_connect (nano::tcp_endpoint const & endpoint_a, std::function<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 (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);
@ -109,13 +109,13 @@ void nano::socket::async_read (std::shared_ptr<std::vector<uint8_t>> const & buf
}
else
{
debug_assert (false && "nano::socket::async_read called with incorrect buffer size");
debug_assert (false && "nano::transport::socket::async_read called with incorrect buffer size");
boost::system::error_code ec_buffer = boost::system::errc::make_error_code (boost::system::errc::no_buffer_space);
callback_a (ec_buffer, 0);
}
}
void nano::socket::async_write (nano::shared_const_buffer const & buffer_a, std::function<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)
{
@ -169,7 +169,7 @@ void nano::socket::async_write (nano::shared_const_buffer const & buffer_a, std:
}
/** Call set_timeout with default_timeout as parameter */
void nano::socket::set_default_timeout ()
void nano::transport::socket::set_default_timeout ()
{
set_timeout (default_timeout);
}
@ -180,24 +180,24 @@ void nano::socket::set_default_timeout ()
* to set infinite timeout, use std::numeric_limits<uint64_t>::max ()
* the function checkup() checks for timeout on a regular interval
*/
void nano::socket::set_timeout (std::chrono::seconds timeout_a)
void nano::transport::socket::set_timeout (std::chrono::seconds timeout_a)
{
timeout = timeout_a.count ();
}
void nano::socket::set_last_completion ()
void nano::transport::socket::set_last_completion ()
{
last_completion_time_or_init = nano::seconds_since_epoch ();
}
void nano::socket::set_last_receive_time ()
void nano::transport::socket::set_last_receive_time ()
{
last_receive_time_or_init = nano::seconds_since_epoch ();
}
void nano::socket::checkup ()
void nano::transport::socket::checkup ()
{
std::weak_ptr<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] () {
if (auto this_l = this_w.lock ())
{
@ -243,22 +243,22 @@ void nano::socket::checkup ()
});
}
bool nano::socket::has_timed_out () const
bool nano::transport::socket::has_timed_out () const
{
return timed_out;
}
void nano::socket::set_default_timeout_value (std::chrono::seconds timeout_a)
void nano::transport::socket::set_default_timeout_value (std::chrono::seconds timeout_a)
{
default_timeout = timeout_a;
}
std::chrono::seconds nano::socket::get_default_timeout_value () const
std::chrono::seconds nano::transport::socket::get_default_timeout_value () const
{
return default_timeout;
}
void nano::socket::set_silent_connection_tolerance_time (std::chrono::seconds tolerance_time_a)
void nano::transport::socket::set_silent_connection_tolerance_time (std::chrono::seconds tolerance_time_a)
{
auto this_l (shared_from_this ());
boost::asio::dispatch (strand, boost::asio::bind_executor (strand, [this_l, tolerance_time_a] () {
@ -266,7 +266,7 @@ void nano::socket::set_silent_connection_tolerance_time (std::chrono::seconds to
}));
}
void nano::socket::close ()
void nano::transport::socket::close ()
{
auto this_l (shared_from_this ());
boost::asio::dispatch (strand, boost::asio::bind_executor (strand, [this_l] {
@ -275,7 +275,7 @@ void nano::socket::close ()
}
// This must be called from a strand or the destructor
void nano::socket::close_internal ()
void nano::transport::socket::close_internal ()
{
if (!closed.exchange (true))
{
@ -293,17 +293,17 @@ void nano::socket::close_internal ()
}
}
nano::tcp_endpoint nano::socket::remote_endpoint () const
nano::tcp_endpoint nano::transport::socket::remote_endpoint () const
{
return remote;
}
nano::tcp_endpoint nano::socket::local_endpoint () const
nano::tcp_endpoint nano::transport::socket::local_endpoint () const
{
return tcp_socket.local_endpoint ();
}
nano::server_socket::server_socket (nano::node & node_a, boost::asio::ip::tcp::endpoint local_a, std::size_t max_connections_a) :
nano::transport::server_socket::server_socket (nano::node & node_a, boost::asio::ip::tcp::endpoint local_a, std::size_t max_connections_a) :
socket{ node_a, endpoint_type_t::server },
acceptor{ node_a.io_ctx },
local{ std::move (local_a) },
@ -312,7 +312,7 @@ nano::server_socket::server_socket (nano::node & node_a, boost::asio::ip::tcp::e
default_timeout = std::chrono::seconds::max ();
}
void nano::server_socket::start (boost::system::error_code & ec_a)
void nano::transport::server_socket::start (boost::system::error_code & ec_a)
{
acceptor.open (local.protocol ());
acceptor.set_option (boost::asio::ip::tcp::acceptor::reuse_address (true));
@ -323,9 +323,9 @@ void nano::server_socket::start (boost::system::error_code & ec_a)
}
}
void nano::server_socket::close ()
void nano::transport::server_socket::close ()
{
auto this_l (std::static_pointer_cast<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] () {
this_l->close_internal ();
@ -341,27 +341,27 @@ void nano::server_socket::close ()
}));
}
boost::asio::ip::network_v6 nano::socket_functions::get_ipv6_subnet_address (boost::asio::ip::address_v6 const & ip_address, size_t network_prefix)
boost::asio::ip::network_v6 nano::transport::socket_functions::get_ipv6_subnet_address (boost::asio::ip::address_v6 const & ip_address, size_t network_prefix)
{
return boost::asio::ip::make_network_v6 (ip_address, network_prefix);
}
boost::asio::ip::address nano::socket_functions::first_ipv6_subnet_address (boost::asio::ip::address_v6 const & ip_address, size_t network_prefix)
boost::asio::ip::address nano::transport::socket_functions::first_ipv6_subnet_address (boost::asio::ip::address_v6 const & ip_address, size_t network_prefix)
{
auto range = get_ipv6_subnet_address (ip_address, network_prefix).hosts ();
debug_assert (!range.empty ());
return *(range.begin ());
}
boost::asio::ip::address nano::socket_functions::last_ipv6_subnet_address (boost::asio::ip::address_v6 const & ip_address, size_t network_prefix)
boost::asio::ip::address nano::transport::socket_functions::last_ipv6_subnet_address (boost::asio::ip::address_v6 const & ip_address, size_t network_prefix)
{
auto range = get_ipv6_subnet_address (ip_address, network_prefix).hosts ();
debug_assert (!range.empty ());
return *(--range.end ());
}
size_t nano::socket_functions::count_subnetwork_connections (
nano::address_socket_mmap const & per_address_connections,
size_t nano::transport::socket_functions::count_subnetwork_connections (
nano::transport::address_socket_mmap const & per_address_connections,
boost::asio::ip::address_v6 const & remote_address,
size_t network_prefix)
{
@ -376,7 +376,7 @@ size_t network_prefix)
return counted_connections;
}
bool nano::server_socket::limit_reached_for_incoming_subnetwork_connections (std::shared_ptr<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 ());
if (node.flags.disable_max_peers_per_subnetwork || nano::transport::is_ipv4_or_v4_mapped_address (new_connection->remote.address ()))
@ -392,7 +392,7 @@ bool nano::server_socket::limit_reached_for_incoming_subnetwork_connections (std
return counted_connections >= node.network_params.network.max_peers_per_subnetwork;
}
bool nano::server_socket::limit_reached_for_incoming_ip_connections (std::shared_ptr<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 ());
if (node.flags.disable_max_peers_per_ip)
@ -405,9 +405,9 @@ bool nano::server_socket::limit_reached_for_incoming_ip_connections (std::shared
return counted_connections >= node.network_params.network.max_peers_per_ip;
}
void nano::server_socket::on_connection (std::function<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 {
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
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,
boost::asio::bind_executor (this_l->strand,
[this_l, new_connection, cbk = std::move (callback)] (boost::system::error_code const & ec_a) mutable {
@ -503,16 +503,16 @@ void nano::server_socket::on_connection (std::function<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.
// 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.
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 {
this_l->on_connection (std::move (callback));
});
}
// This must be called from a strand
void nano::server_socket::evict_dead_connections ()
void nano::transport::server_socket::evict_dead_connections ()
{
debug_assert (strand.running_in_this_thread ());
for (auto it = connections_per_address.begin (); it != connections_per_address.end ();)
@ -526,17 +526,17 @@ void nano::server_socket::evict_dead_connections ()
}
}
std::string nano::socket_type_to_string (nano::socket::type_t type)
std::string nano::transport::socket_type_to_string (nano::transport::socket::type_t type)
{
switch (type)
{
case nano::socket::type_t::undefined:
case nano::transport::socket::type_t::undefined:
return "undefined";
case nano::socket::type_t::bootstrap:
case nano::transport::socket::type_t::bootstrap:
return "bootstrap";
case nano::socket::type_t::realtime:
case nano::transport::socket::type_t::realtime:
return "realtime";
case nano::socket::type_t::realtime_response_server:
case nano::transport::socket::type_t::realtime_response_server:
return "realtime_response_server";
}
return "n/a";

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

@ -16,6 +16,11 @@ class network_v6;
namespace nano
{
class node;
}
namespace nano::transport
{
/** Policy to affect at which stage a buffer can be dropped */
enum class buffer_drop_policy
{
@ -27,11 +32,10 @@ enum class buffer_drop_policy
no_socket_drop
};
class node;
class server_socket;
/** Socket class for tcp clients and newly accepted connections */
class socket : public std::enable_shared_from_this<nano::socket>
class socket : public std::enable_shared_from_this<nano::transport::socket>
{
friend class server_socket;
@ -57,6 +61,7 @@ public:
*/
explicit socket (nano::node & node, endpoint_type_t endpoint_type_a);
virtual ~socket ();
void async_connect (boost::asio::ip::tcp::endpoint const &, std::function<void (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_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
{
return type () == nano::socket::type_t::realtime || type () == nano::socket::type_t::realtime_response_server;
return type () == nano::transport::socket::type_t::realtime || type () == nano::transport::socket::type_t::realtime_response_server;
}
bool is_bootstrap_connection () const
{
return type () == nano::socket::type_t::bootstrap;
return type () == nano::transport::socket::type_t::bootstrap;
}
bool is_closed () const
{
@ -184,7 +189,7 @@ namespace socket_functions
boost::asio::ip::network_v6 get_ipv6_subnet_address (boost::asio::ip::address_v6 const &, size_t);
boost::asio::ip::address first_ipv6_subnet_address (boost::asio::ip::address_v6 const &, size_t);
boost::asio::ip::address last_ipv6_subnet_address (boost::asio::ip::address_v6 const &, size_t);
size_t count_subnetwork_connections (nano::address_socket_mmap const &, boost::asio::ip::address_v6 const &, size_t);
size_t count_subnetwork_connections (nano::transport::address_socket_mmap const &, boost::asio::ip::address_v6 const &, size_t);
}
/** Socket class for TCP servers */
@ -203,22 +208,22 @@ public:
/** Stop accepting new connections */
void close () override;
/** Register callback for new connections. The callback must return true to keep accepting new connections. */
void on_connection (std::function<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 ()
{
return acceptor.local_endpoint ().port ();
}
private:
nano::address_socket_mmap connections_per_address;
nano::transport::address_socket_mmap connections_per_address;
boost::asio::ip::tcp::acceptor acceptor;
boost::asio::ip::tcp::endpoint local;
std::size_t max_inbound_connections;
void evict_dead_connections ();
void on_connection_requeue_delayed (std::function<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. */
bool limit_reached_for_incoming_ip_connections (std::shared_ptr<nano::socket> const & new_connection);
bool limit_reached_for_incoming_subnetwork_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::transport::socket> const & new_connection);
};
/** Socket class for TCP clients */

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

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

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

@ -23,7 +23,7 @@ public:
std::shared_ptr<nano::message> message;
nano::tcp_endpoint endpoint;
nano::account node_id;
std::shared_ptr<nano::socket> socket;
std::shared_ptr<nano::transport::socket> socket;
};
namespace transport
{
@ -35,19 +35,19 @@ namespace transport
friend class nano::transport::tcp_channels;
public:
channel_tcp (nano::node &, std::weak_ptr<nano::socket>);
channel_tcp (nano::node &, std::weak_ptr<nano::transport::socket>);
~channel_tcp () override;
std::size_t hash_code () const override;
bool operator== (nano::transport::channel const &) const override;
// TODO: investigate clang-tidy warning about default parameters on virtual/override functions
//
void send_buffer (nano::shared_const_buffer const &, std::function<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;
bool operator== (nano::transport::channel_tcp const & other_a) const
{
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.
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 };
@ -99,7 +99,7 @@ namespace transport
public:
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 &);
std::size_t size () const;
std::shared_ptr<nano::transport::channel_tcp> find_channel (nano::tcp_endpoint const &) const;
@ -113,7 +113,7 @@ namespace transport
void start ();
void stop ();
void process_messages ();
void process_message (nano::message const &, nano::tcp_endpoint const &, nano::account const &, std::shared_ptr<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_subnetwork_connections (nano::tcp_endpoint const & endpoint_a);
bool max_ip_or_subnetwork_connections (nano::tcp_endpoint const & endpoint_a);
@ -164,9 +164,9 @@ namespace transport
{
public:
std::shared_ptr<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;
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))
{
}

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 };
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;
listening_socket->start (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)
{
accept_action (ec_a, new_connection);
@ -81,7 +81,7 @@ std::size_t nano::transport::tcp_listener::connection_count ()
return connections.size ();
}
void nano::transport::tcp_listener::accept_action (boost::system::error_code const & ec, std::shared_ptr<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 ()))
{
@ -121,7 +121,7 @@ std::unique_ptr<nano::container_info_component> nano::transport::collect_contain
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) },
node{ std::move (node_a) },
allow_bootstrap{ allow_bootstrap_a },
@ -137,11 +137,11 @@ nano::transport::tcp_server::~tcp_server ()
node->logger.try_log ("Exiting incoming TCP/bootstrap server");
}
if (socket->type () == nano::socket::type_t::bootstrap)
if (socket->type () == nano::transport::socket::type_t::bootstrap)
{
--node->tcp_listener.bootstrap_count;
}
else if (socket->type () == nano::socket::type_t::realtime)
else if (socket->type () == nano::transport::socket::type_t::realtime)
{
--node->tcp_listener.realtime_count;
@ -570,23 +570,23 @@ bool nano::transport::tcp_server::to_bootstrap_connection ()
{
return false;
}
if (socket->type () != nano::socket::type_t::undefined)
if (socket->type () != nano::transport::socket::type_t::undefined)
{
return false;
}
++node->tcp_listener.bootstrap_count;
socket->type_set (nano::socket::type_t::bootstrap);
socket->type_set (nano::transport::socket::type_t::bootstrap);
return true;
}
bool nano::transport::tcp_server::to_realtime_connection (nano::account const & node_id)
{
if (socket->type () == nano::socket::type_t::undefined && !node->flags.disable_tcp_realtime)
if (socket->type () == nano::transport::socket::type_t::undefined && !node->flags.disable_tcp_realtime)
{
remote_node_id = node_id;
++node->tcp_listener.realtime_count;
socket->type_set (nano::socket::type_t::realtime);
socket->type_set (nano::transport::socket::type_t::realtime);
return true;
}
return false;
@ -594,7 +594,7 @@ bool nano::transport::tcp_server::to_realtime_connection (nano::account const &
bool nano::transport::tcp_server::is_undefined_connection () const
{
return socket->type () == nano::socket::type_t::undefined;
return socket->type () == nano::transport::socket::type_t::undefined;
}
bool nano::transport::tcp_server::is_bootstrap_connection () const

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

@ -2,7 +2,7 @@
#include <nano/node/common.hpp>
#include <nano/node/messages.hpp>
#include <nano/node/socket.hpp>
#include <nano/node/transport/socket.hpp>
#include <atomic>
@ -25,14 +25,14 @@ public:
tcp_listener (uint16_t, nano::node &);
void start ();
void stop ();
void accept_action (boost::system::error_code const &, std::shared_ptr<nano::socket> const &);
void accept_action (boost::system::error_code const &, std::shared_ptr<nano::transport::socket> const &);
std::size_t connection_count ();
nano::mutex mutex;
std::unordered_map<nano::transport::tcp_server *, std::weak_ptr<nano::transport::tcp_server>> connections;
nano::tcp_endpoint endpoint ();
nano::node & node;
std::shared_ptr<nano::server_socket> listening_socket;
std::shared_ptr<nano::transport::server_socket> listening_socket;
bool on{ false };
std::atomic<std::size_t> bootstrap_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>
{
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 ();
void start ();
@ -54,7 +54,7 @@ public:
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;
nano::mutex mutex;
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/common.hpp>
#include <nano/node/messages.hpp>
#include <nano/node/socket.hpp>
#include <nano/node/transport/socket.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)
{
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)