Defaulting to mix layer with fewest node if no argument provided (#353)

* Defaulting to mix layer with fewest node if no argument provided

* cargo fmt

Author: jstuczyn

mixnode/src/commands/init.rs

@@ -17,6 +17,12 @@ use crate::config::persistence::pathfinder::MixNodePathfinder;
 use clap::{App, Arg, ArgMatches};
 use config::NymConfig;
 use crypto::asymmetric::encryption;
+use directory_client::DirectoryClient;
+use log::*;
+use nymsphinx::params::DEFAULT_NUM_MIX_HOPS;
+use std::convert::TryInto;
+use tokio::runtime::Runtime;
+use topology::NymTopology;
 
 pub fn command_args<'a, 'b>() -> clap::App<'a, 'b> {
     App::new("init")
@@ -38,8 +44,7 @@ pub fn command_args<'a, 'b>() -> clap::App<'a, 'b> {
             Arg::with_name("layer")
                 .long("layer")
                 .help("The mixnet layer of this particular node")
-                .takes_value(true)
-                .required(true),
+                .takes_value(true),
         )
         .arg(
             Arg::with_name("host")
@@ -82,35 +87,78 @@ fn show_incentives_url() {
     println!("\n\n");
 }
 
-pub fn execute(matches: &ArgMatches) {
-    let id = matches.value_of("id").unwrap();
-    println!("Initialising mixnode {}...", id);
-
-    let layer = matches.value_of("layer").unwrap().parse().unwrap();
-    let mut config = crate::config::Config::new(id, layer);
+async fn choose_layer(matches: &ArgMatches<'_>, directory_server: String) -> u64 {
+    let max_layer = DEFAULT_NUM_MIX_HOPS;
+    if let Some(layer) = matches.value_of("layer").map(|layer| layer.parse::<u64>()) {
+        if let Err(err) = layer {
+            // if layer was overridden, it must be parsable
+            panic!("Invalid layer value provided - {:?}", err);
+        }
+        let layer = layer.unwrap();
+        if layer <= max_layer as u64 && layer > 0 {
+            return layer;
+        }
+    }
 
-    config = override_config(config, matches);
+    let directory_client_config = directory_client::Config::new(directory_server);
+    let directory_client = directory_client::Client::new(directory_client_config);
+    let topology: NymTopology = directory_client
+        .get_topology()
+        .await
+        .expect("failed to obtain initial network topology!")
+        .try_into()
+        .unwrap();
 
-    let sphinx_keys = encryption::KeyPair::new();
-    let pathfinder = MixNodePathfinder::new_from_config(&config);
-    pemstore::store_keypair(
-        &sphinx_keys,
-        &pemstore::KeyPairPath::new(
-            pathfinder.private_encryption_key().to_owned(),
-            pathfinder.public_encryption_key().to_owned(),
-        ),
-    )
-    .expect("Failed to save sphinx keys");
+    let mut lowest_layer = (0, usize::max_value());
 
-    println!("Saved mixnet sphinx keypair");
+    for layer in 1..=max_layer {
+        let nodes_count = topology
+            .mixes()
+            .get(&layer)
+            .map(|layer_mixes| layer_mixes.len())
+            .unwrap_or_else(|| 0);
+        trace!("There are {} nodes on layer {}", nodes_count, layer);
+        if nodes_count < lowest_layer.1 {
+            lowest_layer.0 = layer;
+            lowest_layer.1 = nodes_count;
+        }
+    }
 
-    let config_save_location = config.get_config_file_save_location();
-    config
-        .save_to_file(None)
-        .expect("Failed to save the config file");
-    println!("Saved configuration file to {:?}", config_save_location);
+    lowest_layer.0 as u64
+}
 
-    println!("Mixnode configuration completed.\n\n\n");
+pub fn execute(matches: &ArgMatches) {
+    // TODO: this should probably be made implicit by slapping `#[tokio::main]` on our main method
+    // and then removing runtime from mixnode itself in `run`
+    let mut rt = Runtime::new().unwrap();
+    rt.block_on(async {
+        let id = matches.value_of("id").unwrap();
+        println!("Initialising mixnode {}...", id);
+        let mut config = crate::config::Config::new(id);
+        config = override_config(config, matches);
+        let layer = choose_layer(matches, config.get_presence_directory_server()).await;
+        // TODO: I really don't like how we override config and are presumably done with it
+        // only to change it here
+        config = config.with_layer(layer);
+        debug!("Choosing layer {}", config.get_layer());
 
-    show_incentives_url();
+        let sphinx_keys = encryption::KeyPair::new();
+        let pathfinder = MixNodePathfinder::new_from_config(&config);
+        pemstore::store_keypair(
+            &sphinx_keys,
+            &pemstore::KeyPairPath::new(
+                pathfinder.private_encryption_key().to_owned(),
+                pathfinder.public_encryption_key().to_owned(),
+            ),
+        )
+        .expect("Failed to save sphinx keys");
+        println!("Saved mixnet sphinx keypair");
+        let config_save_location = config.get_config_file_save_location();
+        config
+            .save_to_file(None)
+            .expect("Failed to save the config file");
+        println!("Saved configuration file to {:?}", config_save_location);
+        println!("Mixnode configuration completed.\n\n\n");
+        show_incentives_url();
+    })
 }

mixnode/src/commands/mod.rs

@@ -14,17 +14,30 @@
 
 use crate::config::Config;
 use clap::ArgMatches;
+use nymsphinx::params::DEFAULT_NUM_MIX_HOPS;
 
 pub mod init;
 pub mod run;
 
 pub(crate) fn override_config(mut config: Config, matches: &ArgMatches) -> Config {
+    let max_layer = DEFAULT_NUM_MIX_HOPS;
     let mut was_host_overridden = false;
     if let Some(host) = matches.value_of("host") {
         config = config.with_listening_host(host);
         was_host_overridden = true;
     }
 
+    if let Some(layer) = matches.value_of("layer").map(|layer| layer.parse::<u64>()) {
+        if let Err(err) = layer {
+            // if layer was overridden, it must be parsable
+            panic!("Invalid layer value provided - {:?}", err);
+        }
+        let layer = layer.unwrap();
+        if layer <= max_layer as u64 && layer > 0 {
+            config = config.with_layer(layer)
+        }
+    }
+
     if let Some(port) = matches.value_of("port").map(|port| port.parse::<u16>()) {
         if let Err(err) = port {
             // if port was overridden, it must be parsable

mixnode/src/config/mod.rs

@@ -84,8 +84,8 @@ impl NymConfig for Config {
 }
 
 impl Config {
-    pub fn new<S: Into<String>>(id: S, layer: u64) -> Self {
-        Config::default().with_id(id).with_layer(layer)
+    pub fn new<S: Into<String>>(id: S) -> Self {
+        Config::default().with_id(id)
     }
 
     // builder methods