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

Moving networking related parameters off of the node config class an on to the networking config class where they belong.

Browse source
This commit is contained in:
clemahieu 2021-07-26 10:51:30 +01:00
commit 012105f98e
No known key found for this signature in database
GPG key ID: 43708520C8DFB938
12 changed files with 46 additions and 40 deletions
Download patch file Download diff file Expand all files Collapse all files

4
nano/core_test/network.cpp
View file

@ -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<nano::node> (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 ());

27
nano/lib/config.hpp
View file

@ -5,6 +5,7 @@
#include <algorithm>
#include <array>
#include <chrono>
#include <string>
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<std::chrono::milliseconds> (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
{

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

@ -97,7 +97,7 @@ void nano::bootstrap_connections::pool_connection (std::shared_ptr<nano::bootstr
auto const & socket_l = client_a->socket;
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)
{

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

@ -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

8
nano/node/network.cpp
View file

@ -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<nano::transport::channel> 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<nano::node> 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<nano::node> 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 ();

4
nano/node/node.cpp
View file

@ -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<nano::node> 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 ();

2
nano/node/socket.cpp
View file

@ -269,7 +269,7 @@ void nano::server_socket::on_connection (std::function<bool (std::shared_ptr<nan
// Make sure the new connection doesn't idle. Note that in most cases, the callback is going to start
// an IO operation immediately, which will start a timer.
new_connection->checkup ();
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))

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

@ -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<nano::mutex> lock (mutex);
result = channels.get<ip_address_tag> ().count (address) >= node.network_params.node.max_peers_per_ip || channels.get<subnetwork_tag> ().count (subnet) >= node.network_params.node.max_peers_per_subnetwork;
result = channels.get<ip_address_tag> ().count (address) >= node.network_params.network.max_peers_per_ip || channels.get<subnetwork_tag> ().count (subnet) >= node.network_params.network.max_peers_per_subnetwork;
if (!result)
{
result = attempts.get<ip_address_tag> ().count (address) >= node.network_params.node.max_peers_per_ip || attempts.get<subnetwork_tag> ().count (subnet) >= node.network_params.node.max_peers_per_subnetwork;
result = attempts.get<ip_address_tag> ().count (address) >= node.network_params.network.max_peers_per_ip || attempts.get<subnetwork_tag> ().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<nano::mutex> lock (mutex);
// Wake up channels
std::vector<std::shared_ptr<nano::transport::channel_tcp>> send_list;
auto keepalive_sent_cutoff (channels.get<last_packet_sent_tag> ().lower_bound (std::chrono::steady_clock::now () - node.network_params.node.period));
auto keepalive_sent_cutoff (channels.get<last_packet_sent_tag> ().lower_bound (std::chrono::steady_clock::now () - node.network_params.network.cleanup_period));
for (auto i (channels.get<last_packet_sent_tag> ().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<nano::node> 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)

6
nano/node/transport/udp.cpp
View file

@ -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<nano::mutex> lock (mutex);
result = channels.get<ip_address_tag> ().count (address) >= node.network_params.node.max_peers_per_ip || channels.get<subnetwork_tag> ().count (subnet) >= node.network_params.node.max_peers_per_subnetwork;
result = channels.get<ip_address_tag> ().count (address) >= node.network_params.network.max_peers_per_ip || channels.get<subnetwork_tag> ().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<std::shared_ptr<nano::transport::channel_udp>> send_list;
nano::unique_lock<nano::mutex> lock (mutex);
auto keepalive_cutoff (channels.get<last_packet_received_tag> ().lower_bound (std::chrono::steady_clock::now () - node.network_params.node.period));
auto keepalive_cutoff (channels.get<last_packet_received_tag> ().lower_bound (std::chrono::steady_clock::now () - node.network_params.network.cleanup_period));
for (auto i (channels.get<last_packet_received_tag> ().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<nano::node> 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 ();

9
nano/secure/common.cpp
View file

@ -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
}

12
nano/secure/common.hpp
View file

@ -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;

2
nano/test_common/system.cpp
View file

@ -44,7 +44,7 @@ std::shared_ptr<nano::node> 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)
{