logically seperate p2p config (#177)

Currently the p2p config has become cluttered with multiple behaviours;
i.e internode relations, bootstrap info and other things. PR adds extra
sub settings to logically separate the functionality for clarity and
context.

Author: minikin

src/jormungandr/jormungandr-lib/src/interfaces/config/mod.rs

@@ -6,7 +6,7 @@ mod secret;
 pub use log::{Log, LogEntry, LogOutput};
 pub use mempool::{LogMaxEntries, Mempool, PersistentLog, PoolMaxEntries};
 pub use node::{
-    Cors, CorsOrigin, JRpc, LayersConfig, NodeConfig, NodeId, P2p, Policy, PreferredListConfig,
-    Rest, Tls, TopicsOfInterest, TrustedPeer,
+    Bootstrap, Connection, Cors, CorsOrigin, JRpc, LayersConfig, NodeConfig, NodeId, P2p, Policy,
+    PreferredListConfig, Rest, Tls, TopicsOfInterest, TrustedPeer,
 };
 pub use secret::{Bft, GenesisPraos, NodeSecret};

src/jormungandr/jormungandr-lib/src/interfaces/config/node.rs

@@ -188,17 +188,37 @@ impl Serialize for HttpMethod {
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct P2p {
-    /// The public address to which other peers may connect to
-    pub public_address: Multiaddr,
+    pub bootstrap: Bootstrap,
+
+    pub connection: Connection,
+
+    pub policy: Option<Policy>,
 
-    /// File with the secret key used to advertise and authenticate the node
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub node_key_file: Option<PathBuf>,
+    pub layers: Option<LayersConfig>,
+}
 
+/// Bootstrap contains meta data for initial startup
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Bootstrap {
     /// the rendezvous points for the peer to connect to in order to initiate
     /// the p2p discovery from.
     pub trusted_peers: Vec<TrustedPeer>,
 
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub max_bootstrap_attempts: Option<usize>,
+
+    /// File with the secret key used to advertise and authenticate the node
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub node_key_file: Option<PathBuf>,
+}
+
+/// Miscellaneous network configuration
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Connection {
+    /// The public address to which other peers may connect to
+    pub public_address: Multiaddr,
+
     /// Listen address.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub listen: Option<SocketAddr>,
@@ -209,21 +229,17 @@ pub struct P2p {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub max_inbound_connections: Option<u32>,
 
+    /// Whether to allow non-public IP addresses in gossip
     pub allow_private_addresses: bool,
 
+    /// contains addrs of nodes which we can accept fragments from
     pub whitelist: Option<Vec<SocketAddr>>,
 
-    pub policy: Option<Policy>,
-
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub layers: Option<LayersConfig>,
-
+    /// interval to start gossiping with new nodes, changing the value will affect the bandwidth.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub gossip_interval: Option<Duration>,
 
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub max_bootstrap_attempts: Option<usize>,
-
+    /// If no gossip has been received in the last interval, try to connect to nodes that were previously known to this node
     #[serde(skip_serializing_if = "Option::is_none")]
     pub network_stuck_check: Option<Duration>,
 }
@@ -234,6 +250,7 @@ pub struct TopicsOfInterest {
     pub blocks: String,
 }
 
+/// policy module
 #[derive(Debug, Serialize, Deserialize, Clone)]
 pub struct Policy {
     #[serde(skip_serializing_if = "Option::is_none")]
@@ -242,6 +259,7 @@ pub struct Policy {
     pub quarantine_whitelist: Option<Vec<Multiaddr>>,
 }
 
+/// Jörmungandr provides multiple additional layers to the poldercast default ones: the preferred list or the bottle in the sea.
 #[derive(Default, Debug, Clone, Serialize, Deserialize)]
 #[serde(deny_unknown_fields)]
 pub struct LayersConfig {
@@ -308,7 +326,8 @@ pub struct NodeConfig {
 
 impl P2p {
     pub fn get_listen_addr(&self) -> Option<SocketAddr> {
-        self.listen
-            .or_else(|| multiaddr_utils::to_tcp_socket_addr(&self.public_address))
+        self.connection
+            .listen
+            .or_else(|| multiaddr_utils::to_tcp_socket_addr(&self.connection.public_address))
     }
 }

src/jormungandr/jormungandr/src/settings/start/config.rs

@@ -66,15 +66,22 @@ pub struct ConfigLogSettings {
 #[derive(Debug, Clone, Deserialize, Default)]
 #[serde(deny_unknown_fields)]
 pub struct P2pConfig {
-    /// The public address to which other peers may connect to
-    pub public_address: Option<Multiaddr>,
+    pub bootstrap: Bootstrap,
 
-    /// The socket address to listen on, if different from the public address.
-    /// The format is "{ip_address}:{port}".
-    /// The IP address can be specified as 0.0.0.0 or :: to listen on
-    /// all network interfaces.
-    pub listen: Option<Address>,
+    pub connection: Connection,
+
+    /// setting for the policy
+    #[serde(default)]
+    pub policy: QuarantineConfig,
+
+    /// settings for the different custom layers
+    #[serde(default)]
+    pub layers: LayersConfig,
+}
 
+#[derive(Debug, Clone, Deserialize, Default)]
+#[serde(deny_unknown_fields)]
+pub struct Bootstrap {
     /// File with the secret key used to advertise and authenticate the node
     #[serde(skip_serializing_if = "Option::is_none")]
     pub node_key_file: Option<PathBuf>,
@@ -83,6 +90,31 @@ pub struct P2pConfig {
     /// the p2p discovery from.
     pub trusted_peers: Option<Vec<TrustedPeer>>,
 
+    /// The number of times to retry bootstrapping from trusted peers. The default
+    /// value of None will result in the bootstrap process retrying indefinitely. A
+    /// value of zero will skip bootstrap all together -- even if trusted peers are
+    /// defined. If the node fails to bootstrap from any of the trusted peers and the
+    /// number of bootstrap retry attempts is exceeded, then the node will continue to
+    /// run without completing the bootstrap process. This will allow the node to act
+    /// as the first node in the p2p network (i.e. genesis node), or immediately begin
+    /// gossip with the trusted peers if any are defined.
+    #[serde(default)]
+    pub max_bootstrap_attempts: Option<usize>,
+}
+
+/// Start up connection configuration
+#[derive(Debug, Clone, Deserialize, Default)]
+#[serde(deny_unknown_fields)]
+pub struct Connection {
+    /// The public address to which other peers may connect to
+    pub public_address: Option<Multiaddr>,
+
+    /// The socket address to listen on, if different from the public address.
+    /// The format is "{ip_address}:{port}".
+    /// The IP address can be specified as 0.0.0.0 or :: to listen on
+    /// all network interfaces.
+    pub listen: Option<Address>,
+
     /// Limit on the number of simultaneous connections.
     /// If not specified, an internal default limit is used.
     pub max_connections: Option<usize>,
@@ -99,16 +131,9 @@ pub struct P2pConfig {
     #[serde(default)]
     pub allow_private_addresses: bool,
 
+    /// contains addrs of nodes which we can accept fragments from
     pub whitelist: Option<Vec<SocketAddr>>,
 
-    /// setting for the policy
-    #[serde(default)]
-    pub policy: QuarantineConfig,
-
-    /// settings for the different custom layers
-    #[serde(default)]
-    pub layers: LayersConfig,
-
     /// 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
@@ -124,17 +149,6 @@ pub struct P2pConfig {
     /// The default value is 5 min.
     #[serde(default)]
     pub network_stuck_check: Option<Duration>,
-
-    /// The number of times to retry bootstrapping from trusted peers. The default
-    /// value of None will result in the bootstrap process retrying indefinitely. A
-    /// value of zero will skip bootstrap all together -- even if trusted peers are
-    /// defined. If the node fails to bootstrap from any of the trusted peers and the
-    /// number of bootstrap retry attempts is exceeded, then the node will continue to
-    /// run without completing the bootstrap process. This will allow the node to act
-    /// as the first node in the p2p network (i.e. genesis node), or immediately begin
-    /// gossip with the trusted peers if any are defined.
-    #[serde(default)]
-    pub max_bootstrap_attempts: Option<usize>,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]

src/jormungandr/jormungandr/src/settings/start/mod.rs

@@ -260,15 +260,16 @@ fn generate_network(
             (config::P2pConfig::default(), Vec::new(), false, false)
         };
 
-    if p2p.trusted_peers.is_some() {
-        if let Some(peers) = p2p.trusted_peers.as_mut() {
+    if p2p.bootstrap.trusted_peers.is_some() {
+        if let Some(peers) = p2p.bootstrap.trusted_peers.as_mut() {
             peers.extend(command_arguments.trusted_peer.clone())
         }
     } else if !command_arguments.trusted_peer.is_empty() {
-        p2p.trusted_peers = Some(command_arguments.trusted_peer.clone())
+        p2p.bootstrap.trusted_peers = Some(command_arguments.trusted_peer.clone())
     }
 
     let trusted_peers = p2p
+        .bootstrap
         .trusted_peers
         .as_ref()
         .map_or_else(Vec::new, |peers| resolve_trusted_peers(peers));
@@ -286,23 +287,21 @@ fn generate_network(
         .transpose()?
         .unwrap_or_default();
 
-    // TODO: do we want to check that we end up with a valid address?
-    // Is it possible for a node to specify no public address?
-    let config_addr = p2p.public_address;
+    let config_addr = p2p.connection.public_address;
     let public_address = command_arguments
         .public_address
         .clone()
         .or(config_addr)
         .and_then(|addr| multiaddr::to_tcp_socket_addr(&addr));
 
-    let node_key = match p2p.node_key_file {
+    let node_key = match p2p.bootstrap.node_key_file {
         Some(node_key_file) => {
             <SigningKey<Ed25519>>::from_bech32_str(&std::fs::read_to_string(&node_key_file)?)?
         }
         None => SigningKey::generate(rand::thread_rng()),
     };
 
-    let p2p_listen_address = p2p.listen.as_ref();
+    let p2p_listen_address = p2p.connection.listen.as_ref();
     let listen_address = command_arguments
         .listen_address
         .as_ref()
@@ -321,23 +320,27 @@ fn generate_network(
             rings,
         },
         max_connections: p2p
+            .connection
             .max_connections
             .unwrap_or(network::DEFAULT_MAX_CONNECTIONS),
         max_client_connections: p2p
+            .connection
             .max_client_connections
             .unwrap_or(network::DEFAULT_MAX_CLIENT_CONNECTIONS),
         timeout: std::time::Duration::from_secs(15),
-        allow_private_addresses: p2p.allow_private_addresses,
-        whitelist: p2p.whitelist,
+        allow_private_addresses: p2p.connection.allow_private_addresses,
+        whitelist: p2p.connection.whitelist,
         gossip_interval: p2p
+            .connection
             .gossip_interval
             .map(|d| d.into())
             .unwrap_or_else(|| std::time::Duration::from_secs(10)),
         network_stuck_check: p2p
+            .connection
             .network_stuck_check
             .map(Into::into)
             .unwrap_or(crate::topology::DEFAULT_NETWORK_STUCK_INTERVAL),
-        max_bootstrap_attempts: p2p.max_bootstrap_attempts,
+        max_bootstrap_attempts: p2p.bootstrap.max_bootstrap_attempts,
         http_fetch_block0_service,
         bootstrap_from_trusted_peers,
         skip_bootstrap,

src/jormungandr/testing/hersir/src/builder/explorer.rs

@@ -16,7 +16,13 @@ pub fn generate_explorer(
     Ok(ExplorerConfiguration {
         explorer_port: get_available_port(),
         explorer_listen_address: "127.0.0.1".to_string(),
-        node_address: settings.config.p2p.public_address.clone().to_http_addr(),
+        node_address: settings
+            .config
+            .p2p
+            .connection
+            .public_address
+            .clone()
+            .to_http_addr(),
         logs_dir: Some(Path::new("C:\\work\\iohk\\logs.txt").to_path_buf()),
         storage_dir: None,
         params: explorer_template.to_explorer_params(),

src/jormungandr/testing/hersir/src/builder/settings/mod.rs

@@ -178,14 +178,14 @@ impl Settings {
                         .to_public(),
                 );
                 trusted_peers.push(TrustedPeer {
-                    address: trusted_peer.config.p2p.public_address.clone(),
+                    address: trusted_peer.config.p2p.connection.public_address.clone(),
                     id: Some(id),
                 })
             }
 
             node.config.skip_bootstrap = Some(trusted_peers.is_empty());
             node.config.bootstrap_from_trusted_peers = Some(!trusted_peers.is_empty());
-            node.config.p2p.trusted_peers = trusted_peers;
+            node.config.p2p.bootstrap.trusted_peers = trusted_peers;
         }
     }
 

src/jormungandr/testing/hersir/src/config/spawn_params.rs

@@ -281,31 +281,31 @@ impl SpawnParams {
         }
 
         if let Some(public_address) = &self.public_address {
-            node_config.p2p.public_address = public_address.clone();
+            node_config.p2p.connection.public_address = public_address.clone();
         }
 
         if let Some(max_inbound_connections) = &self.max_inbound_connections {
-            node_config.p2p.max_inbound_connections = Some(*max_inbound_connections);
+            node_config.p2p.connection.max_inbound_connections = Some(*max_inbound_connections);
         }
 
         if let Some(allow_private_addresses) = &self.allow_private_addresses {
-            node_config.p2p.allow_private_addresses = *allow_private_addresses;
+            node_config.p2p.connection.allow_private_addresses = *allow_private_addresses;
         }
 
         if let Some(whitelist) = &self.whitelist {
-            node_config.p2p.whitelist = Some(whitelist.clone());
+            node_config.p2p.connection.whitelist = Some(whitelist.clone());
         }
 
         if let Some(max_connections) = &self.max_connections {
-            node_config.p2p.max_connections = Some(*max_connections);
+            node_config.p2p.connection.max_connections = Some(*max_connections);
         }
 
         if let Some(listen_address_option) = &self.listen_address {
-            node_config.p2p.listen = *listen_address_option;
+            node_config.p2p.connection.listen = *listen_address_option;
         }
 
         if let Some(trusted_peers) = &self.trusted_peers {
-            node_config.p2p.trusted_peers = trusted_peers.clone();
+            node_config.p2p.bootstrap.trusted_peers = trusted_peers.clone();
         }
 
         if let Some(preferred_layer) = &self.preferred_layer {
@@ -328,19 +328,19 @@ impl SpawnParams {
         }
 
         if let Some(node_key_file) = &self.node_key_file {
-            node_config.p2p.node_key_file = Some(node_key_file.clone());
+            node_config.p2p.bootstrap.node_key_file = Some(node_key_file.clone());
         }
 
         if self.gossip_interval.is_some() {
-            node_config.p2p.gossip_interval = self.gossip_interval;
+            node_config.p2p.connection.gossip_interval = self.gossip_interval;
         }
 
         if let Some(max_bootstrap_attempts) = self.max_bootstrap_attempts {
-            node_config.p2p.max_bootstrap_attempts = Some(max_bootstrap_attempts);
+            node_config.p2p.bootstrap.max_bootstrap_attempts = Some(max_bootstrap_attempts);
         }
 
         if let Some(network_stuck_check) = self.network_stuck_check {
-            node_config.p2p.network_stuck_check = Some(network_stuck_check);
+            node_config.p2p.connection.network_stuck_check = Some(network_stuck_check);
         }
         node_config.mempool.as_mut().unwrap().persistent_log = self
             .persistent_fragment_log

src/jormungandr/testing/hersir/src/controller/mod.rs

@@ -254,7 +254,7 @@ impl Controller {
 
         spawn_params.override_settings(&mut config);
 
-        for peer in config.p2p.trusted_peers.iter_mut() {
+        for peer in config.p2p.bootstrap.trusted_peers.iter_mut() {
             peer.id = None;
         }