From 012105f98e54f13f0a3ef8b136b15f653ca24764 Mon Sep 17 00:00:00 2001 From: clemahieu Date: Mon, 26 Jul 2021 10:51:30 +0100 Subject: [PATCH] Moving networking related parameters off of the node config class an on to the networking config class where they belong. --- nano/core_test/network.cpp | 4 +-- nano/lib/config.hpp | 27 +++++++++++++++++++ nano/node/bootstrap/bootstrap_connections.cpp | 2 +- nano/node/bootstrap/bootstrap_server.cpp | 2 +- nano/node/network.cpp | 8 +++--- nano/node/node.cpp | 4 +-- nano/node/socket.cpp | 2 +- nano/node/transport/tcp.cpp | 8 +++--- nano/node/transport/udp.cpp | 6 ++--- nano/secure/common.cpp | 9 ------- nano/secure/common.hpp | 12 --------- nano/test_common/system.cpp | 2 +- 12 files changed, 46 insertions(+), 40 deletions(-) diff --git a/nano/core_test/network.cpp b/nano/core_test/network.cpp index fd840137..abf7a945 100644 --- a/nano/core_test/network.cpp +++ b/nano/core_test/network.cpp @@ -904,7 +904,7 @@ TEST (network, peer_max_tcp_attempts) node_flags.disable_connection_cleanup = true; nano::system system; auto node = system.add_node (node_flags); - for (auto i (0); i < node->network_params.node.max_peers_per_ip; ++i) + for (auto i (0); i < node->network_params.network.max_peers_per_ip; ++i) { auto node2 (std::make_shared (system.io_ctx, nano::get_available_port (), nano::unique_path (), system.logging, system.work, node_flags)); node2->start (); @@ -925,7 +925,7 @@ namespace transport { nano::system system (1); auto node (system.nodes[0]); - for (auto i (0); i < node->network_params.node.max_peers_per_subnetwork; ++i) + for (auto i (0); i < node->network_params.network.max_peers_per_subnetwork; ++i) { auto address (boost::asio::ip::address_v6::v4_mapped (boost::asio::ip::address_v4 (0x7f000001 + i))); // 127.0.0.1 hex nano::endpoint endpoint (address, nano::get_available_port ()); diff --git a/nano/lib/config.hpp b/nano/lib/config.hpp index b0806213..c4c9d4c7 100644 --- a/nano/lib/config.hpp +++ b/nano/lib/config.hpp @@ -5,6 +5,7 @@ #include #include +#include #include namespace boost @@ -120,6 +121,13 @@ public: default_ipc_port = is_live_network () ? 7077 : is_beta_network () ? 56000 : is_test_network () ? test_ipc_port () : 46000; default_websocket_port = is_live_network () ? 7078 : is_beta_network () ? 57000 : is_test_network () ? test_websocket_port () : 47000; request_interval_ms = is_dev_network () ? 20 : 500; + cleanup_period = is_dev_network () ? std::chrono::seconds (1) : std::chrono::seconds (60); + idle_timeout = is_dev_network () ? cleanup_period * 15 : cleanup_period * 2; + syn_cookie_cutoff = std::chrono::seconds (5); + bootstrap_interval = std::chrono::seconds (15 * 60); + max_peers_per_ip = is_dev_network () ? 10 : 5; + max_peers_per_subnetwork = max_peers_per_ip * 4; + peer_dump_interval = is_dev_network () ? std::chrono::seconds (1) : std::chrono::seconds (5 * 60); } /** Network work thresholds. Define these inline as constexpr when moving to cpp17. */ @@ -142,6 +150,25 @@ public: uint16_t default_websocket_port; unsigned request_interval_ms; + std::chrono::seconds cleanup_period; + std::chrono::milliseconds cleanup_period_half () const + { + return std::chrono::duration_cast (cleanup_period) / 2; + } + std::chrono::seconds cleanup_cutoff () const + { + return cleanup_period * 5; + } + /** Default maximum idle time for a socket before it's automatically closed */ + std::chrono::seconds idle_timeout; + std::chrono::seconds syn_cookie_cutoff; + std::chrono::seconds bootstrap_interval; + /** Maximum number of peers per IP */ + size_t max_peers_per_ip; + /** Maximum number of peers per subnetwork */ + size_t max_peers_per_subnetwork; + std::chrono::seconds peer_dump_interval; + /** Returns the network this object contains values for */ nano::networks network () const { diff --git a/nano/node/bootstrap/bootstrap_connections.cpp b/nano/node/bootstrap/bootstrap_connections.cpp index aa5a8a94..09a4e761 100644 --- a/nano/node/bootstrap/bootstrap_connections.cpp +++ b/nano/node/bootstrap/bootstrap_connections.cpp @@ -97,7 +97,7 @@ void nano::bootstrap_connections::pool_connection (std::shared_ptrsocket; if (!stopped && !client_a->pending_stop && !node.network.excluded_peers.check (client_a->channel->get_tcp_endpoint ())) { - socket_l->start_timer (node.network_params.node.idle_timeout); + socket_l->start_timer (node.network_params.network.idle_timeout); // Push into idle deque if (!push_front) { diff --git a/nano/node/bootstrap/bootstrap_server.cpp b/nano/node/bootstrap/bootstrap_server.cpp index 16bc4d9c..8f76aa55 100644 --- a/nano/node/bootstrap/bootstrap_server.cpp +++ b/nano/node/bootstrap/bootstrap_server.cpp @@ -146,7 +146,7 @@ void nano::bootstrap_server::stop () void nano::bootstrap_server::receive () { // Increase timeout to receive TCP header (idle server socket) - socket->set_timeout (node->network_params.node.idle_timeout); + socket->set_timeout (node->network_params.network.idle_timeout); auto this_l (shared_from_this ()); socket->async_read (receive_buffer, 8, [this_l] (boost::system::error_code const & ec, size_t size_a) { // Set remote_endpoint diff --git a/nano/node/network.cpp b/nano/node/network.cpp index f7b483b1..aab55793 100644 --- a/nano/node/network.cpp +++ b/nano/node/network.cpp @@ -13,7 +13,7 @@ nano::network::network (nano::node & node_a, uint16_t port_a) : id (nano::network_constants::active_network), - syn_cookies (node_a.network_params.node.max_peers_per_ip), + syn_cookies (node_a.network_params.network.max_peers_per_ip), inbound{ [this] (nano::message const & message, std::shared_ptr const & channel) { if (message.header.network == id) { @@ -745,9 +745,9 @@ void nano::network::cleanup (std::chrono::steady_clock::time_point const & cutof void nano::network::ongoing_cleanup () { - cleanup (std::chrono::steady_clock::now () - node.network_params.node.cutoff); + cleanup (std::chrono::steady_clock::now () - node.network_params.network.cleanup_cutoff ()); std::weak_ptr node_w (node.shared ()); - node.workers.add_timed_task (std::chrono::steady_clock::now () + node.network_params.node.period, [node_w] () { + node.workers.add_timed_task (std::chrono::steady_clock::now () + node.network_params.network.cleanup_period, [node_w] () { if (auto node_l = node_w.lock ()) { node_l->network.ongoing_cleanup (); @@ -772,7 +772,7 @@ void nano::network::ongoing_keepalive () flood_keepalive (0.75f); flood_keepalive_self (0.25f); std::weak_ptr node_w (node.shared ()); - node.workers.add_timed_task (std::chrono::steady_clock::now () + node.network_params.node.half_period, [node_w] () { + node.workers.add_timed_task (std::chrono::steady_clock::now () + node.network_params.network.cleanup_period_half (), [node_w] () { if (auto node_l = node_w.lock ()) { node_l->network.ongoing_keepalive (); diff --git a/nano/node/node.cpp b/nano/node/node.cpp index c28a3e57..73c8524c 100644 --- a/nano/node/node.cpp +++ b/nano/node/node.cpp @@ -785,7 +785,7 @@ void nano::node::ongoing_rep_calculation () void nano::node::ongoing_bootstrap () { - auto next_wakeup (network_params.node.bootstrap_interval); + auto next_wakeup = network_params.network.bootstrap_interval; if (warmed_up < 3) { // Re-attempt bootstrapping more aggressively on startup @@ -848,7 +848,7 @@ void nano::node::ongoing_peer_store () bool stored (network.tcp_channels.store_all (true)); network.udp_channels.store_all (!stored); std::weak_ptr node_w (shared_from_this ()); - workers.add_timed_task (std::chrono::steady_clock::now () + network_params.node.peer_interval, [node_w] () { + workers.add_timed_task (std::chrono::steady_clock::now () + network_params.network.peer_dump_interval, [node_w] () { if (auto node_l = node_w.lock ()) { node_l->ongoing_peer_store (); diff --git a/nano/node/socket.cpp b/nano/node/socket.cpp index c3b321ff..ee4f9341 100644 --- a/nano/node/socket.cpp +++ b/nano/node/socket.cpp @@ -269,7 +269,7 @@ void nano::server_socket::on_connection (std::functioncheckup (); - new_connection->start_timer (this_l->node.network_params.network.is_dev_network () ? std::chrono::seconds (2) : this_l->node.network_params.node.idle_timeout); + new_connection->start_timer (this_l->node.network_params.network.is_dev_network () ? std::chrono::seconds (2) : this_l->node.network_params.network.idle_timeout); this_l->node.stats.inc (nano::stat::type::tcp, nano::stat::detail::tcp_accept_success, nano::stat::dir::in); this_l->connections.push_back (new_connection); if (callback_a (new_connection, ec_a)) diff --git a/nano/node/transport/tcp.cpp b/nano/node/transport/tcp.cpp index e459a1e1..83b62db2 100644 --- a/nano/node/transport/tcp.cpp +++ b/nano/node/transport/tcp.cpp @@ -374,10 +374,10 @@ bool nano::transport::tcp_channels::max_ip_connections (nano::tcp_endpoint const auto const address (nano::transport::ipv4_address_or_ipv6_subnet (endpoint_a.address ())); auto const subnet (nano::transport::map_address_to_subnetwork (endpoint_a.address ())); nano::unique_lock lock (mutex); - result = channels.get ().count (address) >= node.network_params.node.max_peers_per_ip || channels.get ().count (subnet) >= node.network_params.node.max_peers_per_subnetwork; + result = channels.get ().count (address) >= node.network_params.network.max_peers_per_ip || channels.get ().count (subnet) >= node.network_params.network.max_peers_per_subnetwork; if (!result) { - result = attempts.get ().count (address) >= node.network_params.node.max_peers_per_ip || attempts.get ().count (subnet) >= node.network_params.node.max_peers_per_subnetwork; + result = attempts.get ().count (address) >= node.network_params.network.max_peers_per_ip || attempts.get ().count (subnet) >= node.network_params.network.max_peers_per_subnetwork; } } if (result) @@ -450,7 +450,7 @@ void nano::transport::tcp_channels::ongoing_keepalive () nano::unique_lock lock (mutex); // Wake up channels std::vector> send_list; - auto keepalive_sent_cutoff (channels.get ().lower_bound (std::chrono::steady_clock::now () - node.network_params.node.period)); + auto keepalive_sent_cutoff (channels.get ().lower_bound (std::chrono::steady_clock::now () - node.network_params.network.cleanup_period)); for (auto i (channels.get ().begin ()); i != keepalive_sent_cutoff; ++i) { send_list.push_back (i->channel); @@ -475,7 +475,7 @@ void nano::transport::tcp_channels::ongoing_keepalive () } } std::weak_ptr node_w (node.shared ()); - node.workers.add_timed_task (std::chrono::steady_clock::now () + node.network_params.node.half_period, [node_w] () { + node.workers.add_timed_task (std::chrono::steady_clock::now () + node.network_params.network.cleanup_period_half (), [node_w] () { if (auto node_l = node_w.lock ()) { if (!node_l->network.tcp_channels.stopped) diff --git a/nano/node/transport/udp.cpp b/nano/node/transport/udp.cpp index 370975a0..227edf48 100644 --- a/nano/node/transport/udp.cpp +++ b/nano/node/transport/udp.cpp @@ -636,7 +636,7 @@ bool nano::transport::udp_channels::max_ip_connections (nano::endpoint const & e auto const address (nano::transport::ipv4_address_or_ipv6_subnet (endpoint_a.address ())); auto const subnet (nano::transport::map_address_to_subnetwork (endpoint_a.address ())); nano::unique_lock lock (mutex); - result = channels.get ().count (address) >= node.network_params.node.max_peers_per_ip || channels.get ().count (subnet) >= node.network_params.node.max_peers_per_subnetwork; + result = channels.get ().count (address) >= node.network_params.network.max_peers_per_ip || channels.get ().count (subnet) >= node.network_params.network.max_peers_per_subnetwork; } return result; } @@ -690,7 +690,7 @@ void nano::transport::udp_channels::ongoing_keepalive () node.network.random_fill (message.peers); std::vector> send_list; nano::unique_lock lock (mutex); - auto keepalive_cutoff (channels.get ().lower_bound (std::chrono::steady_clock::now () - node.network_params.node.period)); + auto keepalive_cutoff (channels.get ().lower_bound (std::chrono::steady_clock::now () - node.network_params.network.cleanup_period)); for (auto i (channels.get ().begin ()); i != keepalive_cutoff; ++i) { send_list.push_back (i->channel); @@ -701,7 +701,7 @@ void nano::transport::udp_channels::ongoing_keepalive () channel->send (message); } std::weak_ptr node_w (node.shared ()); - node.workers.add_timed_task (std::chrono::steady_clock::now () + node.network_params.node.period, [node_w] () { + node.workers.add_timed_task (std::chrono::steady_clock::now () + node.network_params.network.cleanup_period, [node_w] () { if (auto node_l = node_w.lock ()) { node_l->network.udp_channels.ongoing_keepalive (); diff --git a/nano/secure/common.cpp b/nano/secure/common.cpp index f1a29996..6aa3ebcc 100644 --- a/nano/secure/common.cpp +++ b/nano/secure/common.cpp @@ -166,19 +166,10 @@ nano::random_constants::random_constants () nano::node_constants::node_constants (nano::network_constants & network_constants) { - period = network_constants.is_dev_network () ? std::chrono::seconds (1) : std::chrono::seconds (60); - half_period = network_constants.is_dev_network () ? std::chrono::milliseconds (500) : std::chrono::milliseconds (30 * 1000); - idle_timeout = network_constants.is_dev_network () ? period * 15 : period * 2; - cutoff = period * 5; - syn_cookie_cutoff = std::chrono::seconds (5); backup_interval = std::chrono::minutes (5); - bootstrap_interval = std::chrono::seconds (15 * 60); search_pending_interval = network_constants.is_dev_network () ? std::chrono::seconds (1) : std::chrono::seconds (5 * 60); - peer_interval = search_pending_interval; unchecked_cleaning_interval = std::chrono::minutes (30); process_confirmed_interval = network_constants.is_dev_network () ? std::chrono::milliseconds (50) : std::chrono::milliseconds (500); - max_peers_per_ip = network_constants.is_dev_network () ? 10 : 5; - max_peers_per_subnetwork = max_peers_per_ip * 4; max_weight_samples = (network_constants.is_live_network () || network_constants.is_test_network ()) ? 4032 : 288; weight_period = 5 * 60; // 5 minutes } diff --git a/nano/secure/common.hpp b/nano/secure/common.hpp index 57253606..c661965f 100644 --- a/nano/secure/common.hpp +++ b/nano/secure/common.hpp @@ -415,22 +415,10 @@ class node_constants { public: node_constants (nano::network_constants & network_constants); - std::chrono::seconds period; - std::chrono::milliseconds half_period; - /** Default maximum idle time for a socket before it's automatically closed */ - std::chrono::seconds idle_timeout; - std::chrono::seconds cutoff; - std::chrono::seconds syn_cookie_cutoff; std::chrono::minutes backup_interval; - std::chrono::seconds bootstrap_interval; std::chrono::seconds search_pending_interval; - std::chrono::seconds peer_interval; std::chrono::minutes unchecked_cleaning_interval; std::chrono::milliseconds process_confirmed_interval; - /** Maximum number of peers per IP */ - size_t max_peers_per_ip; - /** Maximum number of peers per subnetwork */ - size_t max_peers_per_subnetwork; /** The maximum amount of samples for a 2 week period on live or 1 day on beta */ uint64_t max_weight_samples; diff --git a/nano/test_common/system.cpp b/nano/test_common/system.cpp index 56d996cf..2edee0fd 100644 --- a/nano/test_common/system.cpp +++ b/nano/test_common/system.cpp @@ -44,7 +44,7 @@ std::shared_ptr nano::system::add_node (nano::node_config const & no nodes.push_back (node); if (nodes.size () > 1) { - debug_assert (nodes.size () - 1 <= node->network_params.node.max_peers_per_ip || node->flags.disable_max_peers_per_ip); // Check that we don't start more nodes than limit for single IP address + debug_assert (nodes.size () - 1 <= node->network_params.network.max_peers_per_ip || node->flags.disable_max_peers_per_ip); // Check that we don't start more nodes than limit for single IP address auto begin = nodes.end () - 2; for (auto i (begin), j (begin + 1), n (nodes.end ()); j != n; ++i, ++j) {