Merge pull request #1172 from input-output-hk/network-perf-update

poldercast crate update and automatic topology reset

Author: NicolasDP

Cargo.lock

@@ -48,7 +48,13 @@ p2p:
   Every time a new propagation event is triggered, the node will select
   randomly a certain amount of unreachable nodes to connect to in addition
   to the one selected by other p2p topology layer `[default: 20]`
-
+- `gossip_interval`: (optional) interval to start gossiping with new nodes,
+  changing the value will affect the bandwidth. The more often the node will
+  gossip the more bandwidth the node will need. The less often the node gossips
+  the less good the resilience to node churn. `[default: 10]`
+- `topology_force_reset_interval`: (optional) If this value is set, it will
+  trigger a force reset of the topology layers. The default is to not do
+  force the reset. It is recommended to let the protocol handle it.
 
 ### The trusted peers
 

doc/configuration/network.md

@@ -39,7 +39,7 @@ linked-hash-map = "0.5"
 native-tls = "0.2.2"
 network-core    = { path = "../chain-deps/network-core" }
 network-grpc    = { path = "../chain-deps/network-grpc" }
-poldercast = "0.9.7"
+poldercast = "0.9.9"
 rand = "0.6"
 serde = "1.0"
 serde_derive = "1.0"

jormungandr/Cargo.toml

@@ -255,8 +255,20 @@ pub fn start(
     let handle_cmds = handle_network_input(input, global_state.clone(), channels.clone());
 
     let gossip_err_logger = global_state.logger.clone();
-    // TODO: get gossip propagation interval from configuration
-    let gossip = Interval::new_interval(Duration::from_secs(10))
+    let reset_err_logger = global_state.logger.clone();
+    let tp2p = global_state.topology.clone();
+
+    if let Some(interval) = global_state.config.topology_force_reset_interval.clone() {
+        global_state.spawn(
+            Interval::new_interval(interval)
+                .map_err(move |e| {
+                    error!(reset_err_logger, "interval timer error: {:?}", e);
+                })
+                .for_each(move |_| Ok(tp2p.force_reset_layers())),
+        );
+    }
+
+    let gossip = Interval::new_interval(global_state.config.gossip_interval.clone())
         .map_err(move |e| {
             error!(gossip_err_logger, "interval timer error: {:?}", e);
         })

jormungandr/src/network/mod.rs

@@ -14,6 +14,7 @@ use slog::Logger;
 use std::sync::{Arc, RwLock};
 
 /// object holding the P2pTopology of the Node
+#[derive(Clone)]
 pub struct P2pTopology {
     lock: Arc<RwLock<Topology>>,
     logger: Logger,
@@ -96,6 +97,10 @@ impl P2pTopology {
         self.lock.read().unwrap().profile().clone()
     }
 
+    pub fn force_reset_layers(&self) {
+        self.lock.write().unwrap().force_reset_layers()
+    }
+
     /// register a strike against the given node id
     ///
     /// the function returns `None` if the node was not even in the

jormungandr/src/network/p2p/topology.rs

@@ -108,6 +108,22 @@ pub struct P2pConfig {
     /// to the one selected by other p2p topology layer.
     #[serde(default)]
     pub max_unreachable_nodes_to_connect_per_event: Option<usize>,
+
+    /// interval to start gossiping with new nodes, changing the value will
+    /// affect the bandwidth. The more often the node will gossip the more
+    /// bandwidth the node will need. The less often the node gossips the less
+    /// good the resilience to node churn.
+    ///
+    /// The default value is 10seconds.
+    #[serde(default)]
+    pub gossip_interval: Option<Duration>,
+
+    /// If this value is set, it will trigger a force reset of the topology
+    /// layers. The default is to not do force the reset. It is recommended
+    /// to let the protocol handle it.
+    ///
+    #[serde(default)]
+    pub topology_force_reset_interval: Option<Duration>,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -169,6 +185,8 @@ impl Default for P2pConfig {
             allow_private_addresses: false,
             policy: PolicyConfig::default(),
             max_unreachable_nodes_to_connect_per_event: None,
+            gossip_interval: None,
+            topology_force_reset_interval: None,
         }
     }
 }

jormungandr/src/settings/start/config.rs

@@ -243,6 +243,11 @@ fn generate_network(
         timeout: std::time::Duration::from_secs(15),
         allow_private_addresses: p2p.allow_private_addresses,
         max_unreachable_nodes_to_connect_per_event: p2p.max_unreachable_nodes_to_connect_per_event,
+        gossip_interval: p2p
+            .gossip_interval
+            .map(|d| d.into())
+            .unwrap_or(std::time::Duration::from_secs(10)),
+        topology_force_reset_interval: p2p.topology_force_reset_interval.map(|d| d.into()),
     };
 
     Ok(network)

jormungandr/src/settings/start/mod.rs

@@ -68,6 +68,10 @@ pub struct Configuration {
     pub allow_private_addresses: bool,
 
     pub max_unreachable_nodes_to_connect_per_event: Option<usize>,
+
+    pub gossip_interval: Duration,
+
+    pub topology_force_reset_interval: Option<Duration>,
 }
 
 #[derive(Clone)]