From ce29ba079fddad0bec199aee59d3683c861d57cc Mon Sep 17 00:00:00 2001 From: clemahieu Date: Sat, 11 Sep 2021 14:07:35 +0100 Subject: [PATCH 01/10] Cleanup nano::transport::establish_tcp Removes usage of start_tcp callback and replace it with simple polling for an established connection. --- nano/test_common/network.cpp | 22 +++++++--------------- 1 file changed, 7 insertions(+), 15 deletions(-) diff --git a/nano/test_common/network.cpp b/nano/test_common/network.cpp index 316218a9..ae3add44 100644 --- a/nano/test_common/network.cpp +++ b/nano/test_common/network.cpp @@ -8,27 +8,19 @@ #include #include +using namespace std::chrono_literals; + std::shared_ptr nano::establish_tcp (nano::system & system, nano::node & node, nano::endpoint const & endpoint) { - using namespace std::chrono_literals; debug_assert (node.network.endpoint () != endpoint && "Establishing TCP to self is not allowed"); std::shared_ptr result; debug_assert (!node.flags.disable_tcp_realtime); - std::promise> promise; - auto callback = [&promise] (std::shared_ptr channel_a) { promise.set_value (channel_a); }; - auto future = promise.get_future (); - node.network.tcp_channels.start_tcp (endpoint, callback); - auto error = system.poll_until_true (2s, [&future] { return future.wait_for (0s) == std::future_status::ready; }); - if (!error) - { - auto channel = future.get (); - EXPECT_NE (nullptr, channel); - if (channel) - { - result = node.network.tcp_channels.find_channel (channel->get_tcp_endpoint ()); - } - } + node.network.tcp_channels.start_tcp (endpoint); + auto error = system.poll_until_true (2s, [&result, &node, &endpoint] { + result = node.network.tcp_channels.find_channel (nano::transport::map_endpoint_to_tcp (endpoint)); + return result != nullptr; + }); return result; } From 942e12e7e6859f373dda800cea04c418cbdab13e Mon Sep 17 00:00:00 2001 From: clemahieu Date: Sat, 11 Sep 2021 14:25:45 +0100 Subject: [PATCH 02/10] Remove keepalive_tcp_callback as unnecessary. --- nano/core_test/network.cpp | 6 +++--- nano/core_test/node.cpp | 2 +- nano/test_common/network.cpp | 10 ---------- nano/test_common/network.hpp | 3 --- 4 files changed, 4 insertions(+), 17 deletions(-) diff --git a/nano/core_test/network.cpp b/nano/core_test/network.cpp index 5d6040f3..28497be6 100644 --- a/nano/core_test/network.cpp +++ b/nano/core_test/network.cpp @@ -112,7 +112,7 @@ TEST (network, send_node_id_handshake_tcp) auto initial_node1 (node1->stats.count (nano::stat::type::message, nano::stat::detail::node_id_handshake, nano::stat::dir::in)); auto initial_keepalive (node0->stats.count (nano::stat::type::message, nano::stat::detail::keepalive, nano::stat::dir::in)); std::weak_ptr node_w (node0); - node0->network.tcp_channels.start_tcp (node1->network.endpoint (), nano::keepalive_tcp_callback (*node1)); + node0->network.tcp_channels.start_tcp (node1->network.endpoint ()); ASSERT_EQ (0, node0->network.size ()); ASSERT_EQ (0, node1->network.size ()); ASSERT_TIMELY (10s, node0->stats.count (nano::stat::type::message, nano::stat::detail::node_id_handshake, nano::stat::dir::in) >= initial + 2); @@ -189,13 +189,13 @@ TEST (network, multi_keepalive) system.nodes.push_back (node1); ASSERT_EQ (0, node1->network.size ()); ASSERT_EQ (0, node0->network.size ()); - node1->network.tcp_channels.start_tcp (node0->network.endpoint (), nano::keepalive_tcp_callback (*node1)); + node1->network.tcp_channels.start_tcp (node0->network.endpoint ()); ASSERT_TIMELY (10s, node0->network.size () == 1 && node0->stats.count (nano::stat::type::message, nano::stat::detail::keepalive) >= 1); auto node2 (std::make_shared (system.io_ctx, nano::get_available_port (), nano::unique_path (), system.logging, system.work)); ASSERT_FALSE (node2->init_error ()); node2->start (); system.nodes.push_back (node2); - node2->network.tcp_channels.start_tcp (node0->network.endpoint (), nano::keepalive_tcp_callback (*node2)); + node2->network.tcp_channels.start_tcp (node0->network.endpoint ()); ASSERT_TIMELY (10s, node1->network.size () == 2 && node0->network.size () == 2 && node2->network.size () == 2 && node0->stats.count (nano::stat::type::message, nano::stat::detail::keepalive) >= 2); } diff --git a/nano/core_test/node.cpp b/nano/core_test/node.cpp index 0968dc4b..ba8380d4 100644 --- a/nano/core_test/node.cpp +++ b/nano/core_test/node.cpp @@ -262,7 +262,7 @@ TEST (node, node_receive_quorum) system2.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); ASSERT_TRUE (node1.balance (key.pub).is_zero ()); - node1.network.tcp_channels.start_tcp (system2.nodes[0]->network.endpoint (), nano::keepalive_tcp_callback (node1)); + node1.network.tcp_channels.start_tcp (system2.nodes[0]->network.endpoint ()); while (node1.balance (key.pub).is_zero ()) { ASSERT_NO_ERROR (system.poll ()); diff --git a/nano/test_common/network.cpp b/nano/test_common/network.cpp index ae3add44..1ef0faed 100644 --- a/nano/test_common/network.cpp +++ b/nano/test_common/network.cpp @@ -23,13 +23,3 @@ std::shared_ptr nano::establish_tcp (nano::system }); return result; } - -std::function channel_a)> nano::keepalive_tcp_callback (nano::node & node_a) -{ - return [node_w = std::weak_ptr (node_a.shared ())] (std::shared_ptr channel_a) { - if (auto node_l = node_w.lock ()) - { - node_l->network.send_keepalive (channel_a); - }; - }; -} diff --git a/nano/test_common/network.hpp b/nano/test_common/network.hpp index 316330a2..4eeea69a 100644 --- a/nano/test_common/network.hpp +++ b/nano/test_common/network.hpp @@ -15,7 +15,4 @@ namespace transport /** Waits until a TCP connection is established and returns the TCP channel on success*/ std::shared_ptr establish_tcp (nano::system &, nano::node &, nano::endpoint const &); - -/** Returns a callback to be used for start_tcp to send a keepalive*/ -std::function channel_a)> keepalive_tcp_callback (nano::node &); } From 3159a5cdc836c1caed40d78502846ff4e8a950b0 Mon Sep 17 00:00:00 2001 From: clemahieu Date: Sat, 11 Sep 2021 14:35:34 +0100 Subject: [PATCH 03/10] Removing usage of callback to send keepalive as unnecessary. --- nano/core_test/network.cpp | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-) diff --git a/nano/core_test/network.cpp b/nano/core_test/network.cpp index 28497be6..e5bfd2cd 100644 --- a/nano/core_test/network.cpp +++ b/nano/core_test/network.cpp @@ -1215,12 +1215,7 @@ TEST (network, cleanup_purge) ASSERT_EQ (0, node1.network.size ()); std::weak_ptr node_w = node1.shared (); - node1.network.tcp_channels.start_tcp (node2->network.endpoint (), [node_w] (std::shared_ptr const & channel_a) { - if (auto node_l = node_w.lock ()) - { - node_l->network.send_keepalive (channel_a); - } - }); + node1.network.tcp_channels.start_tcp (node2->network.endpoint ()); ASSERT_TIMELY (3s, node1.network.size () == 1); node1.network.cleanup (test_start); From ff76c1eb37d9a9a013855edf7e7cdc7a0009c96c Mon Sep 17 00:00:00 2001 From: clemahieu Date: Sat, 11 Sep 2021 15:03:32 +0100 Subject: [PATCH 04/10] Remove direct rep_crawler query in add_initial_peers as all peers are queried via an observer set in rep_crawler::rep_crawler. --- nano/node/node.cpp | 4 ---- 1 file changed, 4 deletions(-) diff --git a/nano/node/node.cpp b/nano/node/node.cpp index a32bdced..0d48d28f 100644 --- a/nano/node/node.cpp +++ b/nano/node/node.cpp @@ -1218,10 +1218,6 @@ void nano::node::add_initial_peers () if (auto node_l = node_w.lock ()) { node_l->network.send_keepalive (channel_a); - if (!node_l->flags.disable_rep_crawler) - { - node_l->rep_crawler.query (channel_a); - } } }); } From c12ee369db0f27204a810255df92243b1a497147 Mon Sep 17 00:00:00 2001 From: clemahieu Date: Sat, 11 Sep 2021 18:25:43 +0100 Subject: [PATCH 05/10] Remove keepalive callback from add_initial_peer. --- nano/node/node.cpp | 8 +------- 1 file changed, 1 insertion(+), 7 deletions(-) diff --git a/nano/node/node.cpp b/nano/node/node.cpp index 0d48d28f..aec1c3b6 100644 --- a/nano/node/node.cpp +++ b/nano/node/node.cpp @@ -1213,13 +1213,7 @@ void nano::node::add_initial_peers () nano::endpoint endpoint (boost::asio::ip::address_v6 (i->first.address_bytes ()), i->first.port ()); if (!network.reachout (endpoint, config.allow_local_peers)) { - std::weak_ptr node_w (shared_from_this ()); - network.tcp_channels.start_tcp (endpoint, [node_w] (std::shared_ptr const & channel_a) { - if (auto node_l = node_w.lock ()) - { - node_l->network.send_keepalive (channel_a); - } - }); + network.tcp_channels.start_tcp (endpoint); } } } From 6552a82c7e902100022f355030bc4a321cdd16da Mon Sep 17 00:00:00 2001 From: clemahieu Date: Sat, 11 Sep 2021 21:28:58 +0100 Subject: [PATCH 06/10] Removing keepalive callback passed in through start_tcp as unnecessary. --- nano/node/node.cpp | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-) diff --git a/nano/node/node.cpp b/nano/node/node.cpp index aec1c3b6..7cea3f81 100644 --- a/nano/node/node.cpp +++ b/nano/node/node.cpp @@ -45,12 +45,7 @@ void nano::node::keepalive (std::string const & address_a, uint16_t port_a) auto channel (node_l->network.find_channel (endpoint)); if (!channel) { - node_l->network.tcp_channels.start_tcp (endpoint, [node_w] (std::shared_ptr const & channel_a) { - if (auto node_l = node_w.lock ()) - { - node_l->network.send_keepalive (channel_a); - } - }); + node_l->network.tcp_channels.start_tcp (endpoint); } else { From e055092826a29ba51878c7e03b26b8dd0eecc6ae Mon Sep 17 00:00:00 2001 From: clemahieu Date: Sat, 11 Sep 2021 22:45:59 +0100 Subject: [PATCH 07/10] Connect to node2 over TCP instead of falling back to UDP as this is unnecessary. --- nano/core_test/node.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/nano/core_test/node.cpp b/nano/core_test/node.cpp index ba8380d4..ef056cc3 100644 --- a/nano/core_test/node.cpp +++ b/nano/core_test/node.cpp @@ -2277,8 +2277,8 @@ TEST (node, rep_remove) auto vote2 = std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, 0, nano::dev::genesis); node.rep_crawler.response (channel1, vote2); ASSERT_TIMELY (10s, node.rep_crawler.representative_count () == 1); - // Add inactive TCP representative channel auto node2 (std::make_shared (system.io_ctx, nano::unique_path (), nano::node_config (nano::get_available_port (), system.logging), system.work)); + node2->start (); std::weak_ptr node_w (node.shared ()); auto vote3 = std::make_shared (keypair2.pub, keypair2.prv, 0, nano::dev::genesis); node.network.tcp_channels.start_tcp (node2->network.endpoint (), [node_w, &vote3] (std::shared_ptr const & channel2) { From 372a1289c360c04053b531a7d3c4e8ba5f125118 Mon Sep 17 00:00:00 2001 From: clemahieu Date: Sat, 11 Sep 2021 22:47:15 +0100 Subject: [PATCH 08/10] Removing start_tcp callback and poll for channel to node2 from node. --- nano/core_test/node.cpp | 10 ++++------ 1 file changed, 4 insertions(+), 6 deletions(-) diff --git a/nano/core_test/node.cpp b/nano/core_test/node.cpp index ef056cc3..4cc186f2 100644 --- a/nano/core_test/node.cpp +++ b/nano/core_test/node.cpp @@ -2281,12 +2281,10 @@ TEST (node, rep_remove) node2->start (); std::weak_ptr node_w (node.shared ()); auto vote3 = std::make_shared (keypair2.pub, keypair2.prv, 0, nano::dev::genesis); - node.network.tcp_channels.start_tcp (node2->network.endpoint (), [node_w, &vote3] (std::shared_ptr const & channel2) { - if (auto node_l = node_w.lock ()) - { - ASSERT_FALSE (node_l->rep_crawler.response (channel2, vote3)); - } - }); + node.network.tcp_channels.start_tcp (node2->network.endpoint ()); + std::shared_ptr channel2; + ASSERT_TIMELY (10s, (channel2 = node.network.tcp_channels.find_channel (nano::transport::map_endpoint_to_tcp (node2->network.endpoint ()))) != nullptr); + ASSERT_FALSE (node.rep_crawler.response (channel2, vote3)); ASSERT_TIMELY (10s, node.rep_crawler.representative_count () == 2); node2->stop (); ASSERT_TIMELY (10s, node.rep_crawler.representative_count () == 1); From 809e50bf5db8442fcca467dc9b5b1b0567f66368 Mon Sep 17 00:00:00 2001 From: clemahieu Date: Sun, 12 Sep 2021 10:56:58 +0100 Subject: [PATCH 09/10] Removing callback passed through merge_peer as it's only used for udp_fallback. Directly call send_keepalive in place of using this callback. --- nano/node/network.cpp | 7 +------ nano/node/transport/tcp.cpp | 8 ++++++-- 2 files changed, 7 insertions(+), 8 deletions(-) diff --git a/nano/node/network.cpp b/nano/node/network.cpp index 12951314..a564c42b 100644 --- a/nano/node/network.cpp +++ b/nano/node/network.cpp @@ -575,12 +575,7 @@ void nano::network::merge_peer (nano::endpoint const & peer_a) if (!reachout (peer_a, node.config.allow_local_peers)) { std::weak_ptr node_w (node.shared ()); - node.network.tcp_channels.start_tcp (peer_a, [node_w] (std::shared_ptr const & channel_a) { - if (auto node_l = node_w.lock ()) - { - node_l->network.send_keepalive (channel_a); - } - }); + node.network.tcp_channels.start_tcp (peer_a); } } diff --git a/nano/node/transport/tcp.cpp b/nano/node/transport/tcp.cpp index a02f8bcb..12a13878 100644 --- a/nano/node/transport/tcp.cpp +++ b/nano/node/transport/tcp.cpp @@ -714,9 +714,13 @@ void nano::transport::tcp_channels::udp_fallback (nano::endpoint const & endpoin nano::lock_guard lock (mutex); attempts.get ().erase (nano::transport::map_endpoint_to_tcp (endpoint_a)); } - if (callback_a && !node.flags.disable_udp) + if (!node.flags.disable_udp) { auto channel_udp (node.network.udp_channels.create (endpoint_a)); - callback_a (channel_udp); + node.network.send_keepalive (channel_udp); + if (callback_a) + { + callback_a (channel_udp); + } } } From e1786a40f0e62e88984852e0d00d72de45a4e5df Mon Sep 17 00:00:00 2001 From: clemahieu Date: Sun, 12 Sep 2021 11:13:39 +0100 Subject: [PATCH 10/10] Remove callbacks passed through start_tcp as they're no longer used. --- nano/node/transport/tcp.cpp | 50 ++++++++++++++++--------------------- nano/node/transport/tcp.hpp | 6 ++--- 2 files changed, 24 insertions(+), 32 deletions(-) diff --git a/nano/node/transport/tcp.cpp b/nano/node/transport/tcp.cpp index 12a13878..65976419 100644 --- a/nano/node/transport/tcp.cpp +++ b/nano/node/transport/tcp.cpp @@ -516,11 +516,11 @@ void nano::transport::tcp_channels::update (nano::tcp_endpoint const & endpoint_ } } -void nano::transport::tcp_channels::start_tcp (nano::endpoint const & endpoint_a, std::function const &)> const & callback_a) +void nano::transport::tcp_channels::start_tcp (nano::endpoint const & endpoint_a) { if (node.flags.disable_tcp_realtime) { - node.network.tcp_channels.udp_fallback (endpoint_a, callback_a); + node.network.tcp_channels.udp_fallback (endpoint_a); return; } auto socket = std::make_shared (node, boost::none); @@ -528,7 +528,7 @@ void nano::transport::tcp_channels::start_tcp (nano::endpoint const & endpoint_a auto channel (std::make_shared (node, socket_w)); std::weak_ptr node_w (node.shared ()); socket->async_connect (nano::transport::map_endpoint_to_tcp (endpoint_a), - [node_w, channel, socket, endpoint_a, callback_a] (boost::system::error_code const & ec) { + [node_w, channel, socket, endpoint_a] (boost::system::error_code const & ec) { if (auto node_l = node_w.lock ()) { if (!ec && channel) @@ -543,12 +543,12 @@ void nano::transport::tcp_channels::start_tcp (nano::endpoint const & endpoint_a channel->set_endpoint (); std::shared_ptr> receive_buffer (std::make_shared> ()); receive_buffer->resize (256); - channel->send (message, [node_w, channel, endpoint_a, receive_buffer, callback_a] (boost::system::error_code const & ec, size_t size_a) { + channel->send (message, [node_w, channel, endpoint_a, receive_buffer] (boost::system::error_code const & ec, size_t size_a) { if (auto node_l = node_w.lock ()) { if (!ec) { - node_l->network.tcp_channels.start_tcp_receive_node_id (channel, endpoint_a, receive_buffer, callback_a); + node_l->network.tcp_channels.start_tcp_receive_node_id (channel, endpoint_a, receive_buffer); } else { @@ -560,25 +560,25 @@ void nano::transport::tcp_channels::start_tcp (nano::endpoint const & endpoint_a { node_l->logger.try_log (boost::str (boost::format ("Error sending node_id_handshake to %1%: %2%") % endpoint_a % ec.message ())); } - node_l->network.tcp_channels.udp_fallback (endpoint_a, callback_a); + node_l->network.tcp_channels.udp_fallback (endpoint_a); } } }); } else { - node_l->network.tcp_channels.udp_fallback (endpoint_a, callback_a); + node_l->network.tcp_channels.udp_fallback (endpoint_a); } } }); } -void nano::transport::tcp_channels::start_tcp_receive_node_id (std::shared_ptr const & channel_a, nano::endpoint const & endpoint_a, std::shared_ptr> const & receive_buffer_a, std::function const &)> const & callback_a) +void nano::transport::tcp_channels::start_tcp_receive_node_id (std::shared_ptr const & channel_a, nano::endpoint const & endpoint_a, std::shared_ptr> const & receive_buffer_a) { std::weak_ptr node_w (node.shared ()); if (auto socket_l = channel_a->socket.lock ()) { - auto cleanup_node_id_handshake_socket = [socket_w = channel_a->socket, node_w] (nano::endpoint const & endpoint_a, std::function)> const & callback_a) { + auto cleanup_node_id_handshake_socket = [socket_w = channel_a->socket, node_w] (nano::endpoint const & endpoint_a) { if (auto node_l = node_w.lock ()) { if (auto socket_l = socket_w.lock ()) @@ -588,15 +588,15 @@ void nano::transport::tcp_channels::start_tcp_receive_node_id (std::shared_ptrsocket, node_w, cleanup_node_id_handshake_socket] (nano::endpoint const & endpoint_a, std::function)> const & callback_a) { + auto cleanup_and_udp_fallback = [socket_w = channel_a->socket, node_w, cleanup_node_id_handshake_socket] (nano::endpoint const & endpoint_a) { if (auto node_l = node_w.lock ()) { - node_l->network.tcp_channels.udp_fallback (endpoint_a, callback_a); - cleanup_node_id_handshake_socket (endpoint_a, callback_a); + node_l->network.tcp_channels.udp_fallback (endpoint_a); + cleanup_node_id_handshake_socket (endpoint_a); } }; - socket_l->async_read (receive_buffer_a, 8 + sizeof (nano::account) + sizeof (nano::account) + sizeof (nano::signature), [node_w, channel_a, endpoint_a, receive_buffer_a, callback_a, cleanup_and_udp_fallback, cleanup_node_id_handshake_socket] (boost::system::error_code const & ec, size_t size_a) { + socket_l->async_read (receive_buffer_a, 8 + sizeof (nano::account) + sizeof (nano::account) + sizeof (nano::signature), [node_w, channel_a, endpoint_a, receive_buffer_a, cleanup_and_udp_fallback, cleanup_node_id_handshake_socket] (boost::system::error_code const & ec, size_t size_a) { if (auto node_l = node_w.lock ()) { if (!ec && channel_a) @@ -635,7 +635,7 @@ void nano::transport::tcp_channels::start_tcp_receive_node_id (std::shared_ptrlogger.try_log (boost::str (boost::format ("Node ID handshake response sent with node ID %1% to %2%: query %3%") % node_l->node_id.pub.to_node_id () % endpoint_a % (*message.query).to_string ())); } - channel_a->send (response_message, [node_w, channel_a, endpoint_a, callback_a, cleanup_and_udp_fallback] (boost::system::error_code const & ec, size_t size_a) { + channel_a->send (response_message, [node_w, channel_a, endpoint_a, cleanup_and_udp_fallback] (boost::system::error_code const & ec, size_t size_a) { if (auto node_l = node_w.lock ()) { if (!ec && channel_a) @@ -646,10 +646,6 @@ void nano::transport::tcp_channels::start_tcp_receive_node_id (std::shared_ptrset_last_packet_sent (std::chrono::steady_clock::now ()); auto response_server = std::make_shared (socket_l, node_l); node_l->network.tcp_channels.insert (channel_a, socket_l, response_server); - if (callback_a) - { - callback_a (channel_a); - } // Listen for possible responses response_server->socket->type_set (nano::socket::type_t::realtime_response_server); response_server->remote_node_id = channel_a->get_node_id (); @@ -669,7 +665,7 @@ void nano::transport::tcp_channels::start_tcp_receive_node_id (std::shared_ptrlogger.try_log (boost::str (boost::format ("Error sending node_id_handshake to %1%: %2%") % endpoint_a % ec.message ())); } - cleanup_and_udp_fallback (endpoint_a, callback_a); + cleanup_and_udp_fallback (endpoint_a); } } }); @@ -677,13 +673,13 @@ void nano::transport::tcp_channels::start_tcp_receive_node_id (std::shared_ptr lock (node_l->network.tcp_channels.mutex); node_l->network.tcp_channels.attempts.get ().erase (nano::transport::map_endpoint_to_tcp (endpoint_a)); @@ -692,7 +688,7 @@ void nano::transport::tcp_channels::start_tcp_receive_node_id (std::shared_ptrlogger.try_log (boost::str (boost::format ("Error reading node_id_handshake from %1%: %2%") % endpoint_a % ec.message ())); } - cleanup_and_udp_fallback (endpoint_a, callback_a); + cleanup_and_udp_fallback (endpoint_a); } } }); } } -void nano::transport::tcp_channels::udp_fallback (nano::endpoint const & endpoint_a, std::function const &)> const & callback_a) +void nano::transport::tcp_channels::udp_fallback (nano::endpoint const & endpoint_a) { { nano::lock_guard lock (mutex); @@ -716,11 +712,7 @@ void nano::transport::tcp_channels::udp_fallback (nano::endpoint const & endpoin } if (!node.flags.disable_udp) { - auto channel_udp (node.network.udp_channels.create (endpoint_a)); + auto channel_udp = node.network.udp_channels.create (endpoint_a); node.network.send_keepalive (channel_udp); - if (callback_a) - { - callback_a (channel_udp); - } } } diff --git a/nano/node/transport/tcp.hpp b/nano/node/transport/tcp.hpp index f33bd922..9e7fe011 100644 --- a/nano/node/transport/tcp.hpp +++ b/nano/node/transport/tcp.hpp @@ -102,9 +102,9 @@ namespace transport void modify (std::shared_ptr const &, std::function const &)>); void update (nano::tcp_endpoint const &); // Connection start - void start_tcp (nano::endpoint const &, std::function const &)> const & = nullptr); - void start_tcp_receive_node_id (std::shared_ptr const &, nano::endpoint const &, std::shared_ptr> const &, std::function const &)> const &); - void udp_fallback (nano::endpoint const &, std::function const &)> const &); + void start_tcp (nano::endpoint const &); + void start_tcp_receive_node_id (std::shared_ptr const &, nano::endpoint const &, std::shared_ptr> const &); + void udp_fallback (nano::endpoint const &); nano::node & node; private: