refactor(e2e): better naming for aggregators in e2e tests

Author: jpraynaud

mithril-relay/src/relay/signer.rs

@@ -19,7 +19,7 @@ use warp::Filter;
 /// Signer relay mode
 ///
 /// The relay mode defines how the relay will behave when it receives a message
-#[derive(Debug, Clone, Display, ValueEnum)]
+#[derive(Debug, Clone, Display, PartialEq, Eq, ValueEnum)]
 #[strum(serialize_all = "mixed_case")]
 pub enum SignerRelayMode {
     /// Passthrough relay mode

mithril-test-lab/mithril-end-to-end/src/mithril/aggregator.rs

@@ -17,7 +17,8 @@ use tokio::sync::RwLock;
 
 #[derive(Debug)]
 pub struct AggregatorConfig<'a> {
-    pub index: usize,
+    pub is_master: bool,
+    pub name: &'a str,
     pub server_port: u64,
     pub pool_node: &'a PoolNode,
     pub cardano_cli_path: &'a Path,
@@ -37,7 +38,8 @@ pub struct AggregatorConfig<'a> {
 
 #[derive(Debug)]
 pub struct Aggregator {
-    index: usize,
+    is_master: bool,
+    name_suffix: String,
     server_port: u64,
     db_directory: PathBuf,
     command: Arc<RwLock<MithrilCommand>>,
@@ -128,13 +130,11 @@ impl Aggregator {
             env,
             &args,
         )?;
-        command.set_log_name(&format!(
-            "mithril-aggregator-{}",
-            Self::name_suffix(aggregator_config.index),
-        ));
+        command.set_log_name(&format!("mithril-aggregator-{}", aggregator_config.name,));
 
         Ok(Self {
-            index: aggregator_config.index,
+            is_master: aggregator_config.is_master,
+            name_suffix: aggregator_config.name.to_string(),
             server_port: aggregator_config.server_port,
             db_directory: aggregator_config.pool_node.db_path.clone(),
             command: Arc::new(RwLock::new(command)),
@@ -144,32 +144,21 @@ impl Aggregator {
 
     pub fn copy_configuration(other: &Aggregator) -> Self {
         Self {
-            index: other.index,
+            is_master: other.is_master,
+            name_suffix: other.name_suffix.clone(),
             server_port: other.server_port,
             db_directory: other.db_directory.clone(),
             command: other.command.clone(),
             process: RwLock::new(None),
         }
     }
 
-    pub fn index(&self) -> usize {
-        self.index
-    }
-
     pub fn is_master(&self) -> bool {
-        self.index == 0
+        self.is_master
     }
 
     pub fn name(&self) -> String {
-        format!("mithril-aggregator-{}", Self::name_suffix(self.index))
-    }
-
-    pub fn name_suffix(index: usize) -> String {
-        if index == 0 {
-            "master".to_string()
-        } else {
-            format!("slave-{}", index)
-        }
+        format!("mithril-aggregator-{}", self.name_suffix)
     }
 
     pub fn endpoint(&self) -> String {
@@ -190,10 +179,7 @@ impl Aggregator {
     pub async fn bootstrap_genesis(&self) -> StdResult<()> {
         // Clone the command so we can alter it without affecting the original
         let mut command = self.command.write().await;
-        let command_name = &format!(
-            "mithril-aggregator-genesis-bootstrap-{}",
-            Self::name_suffix(self.index),
-        );
+        let command_name = &format!("mithril-aggregator-genesis-bootstrap-{}", self.name_suffix,);
         command.set_log_name(command_name);
 
         let exit_status = command

mithril-test-lab/mithril-end-to-end/src/mithril/infrastructure.rs

@@ -37,6 +37,63 @@ pub struct MithrilInfrastructureConfig {
     pub use_era_specific_work_dir: bool,
 }
 
+impl MithrilInfrastructureConfig {
+    pub fn is_master_aggregator(&self, index: usize) -> bool {
+        assert!(
+            index < self.number_of_aggregators as usize,
+            "Aggregator index out of bounds"
+        );
+
+        if self.relay_signer_registration_mode == SignerRelayMode::Passthrough {
+            self.number_of_aggregators > 1 && index == 0
+        } else {
+            false
+        }
+    }
+
+    pub fn aggregator_name_suffix(&self, index: usize) -> String {
+        assert!(
+            index < self.number_of_aggregators as usize,
+            "Aggregator index out of bounds"
+        );
+
+        if self.is_master_aggregator(0) {
+            if self.is_master_aggregator(index) {
+                "master".to_string()
+            } else {
+                format!("slave-{index}")
+            }
+        } else {
+            format!("{}", index + 1)
+        }
+    }
+
+    #[cfg(test)]
+    pub fn dummy() -> Self {
+        Self {
+            number_of_aggregators: 1,
+            number_of_signers: 1,
+            server_port: 8080,
+            devnet: Devnet::default(),
+            work_dir: PathBuf::from("/tmp/work"),
+            store_dir: PathBuf::from("/tmp/store"),
+            artifacts_dir: PathBuf::from("/tmp/artifacts"),
+            bin_dir: PathBuf::from("/tmp/bin"),
+            cardano_node_version: "1.0.0".to_string(),
+            mithril_run_interval: 10,
+            mithril_era: "era1".to_string(),
+            mithril_era_reader_adapter: "adapter1".to_string(),
+            signed_entity_types: vec!["type1".to_string()],
+            run_only_mode: false,
+            use_relays: false,
+            relay_signer_registration_mode: SignerRelayMode::Passthrough,
+            relay_signature_registration_mode: SignerRelayMode::Passthrough,
+            use_p2p_passive_relays: false,
+            use_era_specific_work_dir: false,
+        }
+    }
+}
+
 pub struct MithrilInfrastructure {
     artifacts_dir: PathBuf,
     bin_dir: PathBuf,
@@ -186,7 +243,8 @@ impl MithrilInfrastructure {
             };
 
             let aggregator = Aggregator::new(&AggregatorConfig {
-                index,
+                is_master: config.is_master_aggregator(index),
+                name: &config.aggregator_name_suffix(index),
                 server_port: config.server_port + index as u64,
                 pool_node,
                 cardano_cli_path: &config.devnet.cardano_cli_path(),
@@ -246,7 +304,7 @@ impl MithrilInfrastructure {
         let mut bootstrap_peer_addr = None;
         for (index, aggregator_endpoint) in aggregator_endpoints.iter().enumerate() {
             let mut relay_aggregator = RelayAggregator::new(
-                index,
+                config.aggregator_name_suffix(index),
                 config.server_port + index as u64 + 100,
                 bootstrap_peer_addr.clone(),
                 aggregator_endpoint,
@@ -424,10 +482,9 @@ impl MithrilInfrastructure {
 
     pub async fn build_client(&self, aggregator: &Aggregator) -> StdResult<Client> {
         let work_dir = {
-            let mut artifacts_dir = self.artifacts_dir.join(format!(
-                "mithril-client-aggregator-{}",
-                Aggregator::name_suffix(aggregator.index())
-            ));
+            let mut artifacts_dir = self
+                .artifacts_dir
+                .join(format!("mithril-client-aggregator-{}", aggregator.name()));
             if self.use_era_specific_work_dir {
                 let current_era = self.current_era.read().await;
                 artifacts_dir = artifacts_dir.join(format!("era.{}", current_era));
@@ -479,3 +536,93 @@ impl MithrilInfrastructure {
         Ok(())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::MithrilInfrastructureConfig;
+
+    use super::*;
+
+    #[test]
+    fn is_master_aggregator_succeeds() {
+        let config = MithrilInfrastructureConfig {
+            use_relays: true,
+            relay_signer_registration_mode: SignerRelayMode::Passthrough,
+            number_of_aggregators: 2,
+            ..MithrilInfrastructureConfig::dummy()
+        };
+
+        assert!(config.is_master_aggregator(0));
+        assert!(!config.is_master_aggregator(1));
+
+        let config = MithrilInfrastructureConfig {
+            use_relays: true,
+            relay_signer_registration_mode: SignerRelayMode::P2P,
+            number_of_aggregators: 2,
+            ..MithrilInfrastructureConfig::dummy()
+        };
+
+        assert!(!config.is_master_aggregator(0));
+        assert!(!config.is_master_aggregator(1));
+
+        let config = MithrilInfrastructureConfig {
+            use_relays: false,
+            number_of_aggregators: 1,
+            ..MithrilInfrastructureConfig::dummy()
+        };
+
+        assert!(!config.is_master_aggregator(0));
+    }
+
+    #[test]
+    #[should_panic]
+    fn is_master_aggregator_fails() {
+        let config = MithrilInfrastructureConfig {
+            number_of_aggregators: 1,
+            ..MithrilInfrastructureConfig::dummy()
+        };
+
+        config.is_master_aggregator(2);
+    }
+
+    #[test]
+    fn aggregator_name_suffix_succeeds() {
+        let config = MithrilInfrastructureConfig {
+            relay_signer_registration_mode: SignerRelayMode::Passthrough,
+            number_of_aggregators: 3,
+            ..MithrilInfrastructureConfig::dummy()
+        };
+
+        assert_eq!(config.aggregator_name_suffix(0), "master");
+        assert_eq!(config.aggregator_name_suffix(1), "slave-1");
+        assert_eq!(config.aggregator_name_suffix(2), "slave-2");
+
+        let config = MithrilInfrastructureConfig {
+            number_of_aggregators: 3,
+            relay_signer_registration_mode: SignerRelayMode::P2P,
+            ..MithrilInfrastructureConfig::dummy()
+        };
+
+        assert_eq!(config.aggregator_name_suffix(0), "1");
+        assert_eq!(config.aggregator_name_suffix(1), "2");
+        assert_eq!(config.aggregator_name_suffix(2), "3");
+
+        let config = MithrilInfrastructureConfig {
+            number_of_aggregators: 1,
+            ..MithrilInfrastructureConfig::dummy()
+        };
+
+        assert_eq!(config.aggregator_name_suffix(0), "1");
+    }
+
+    #[test]
+    #[should_panic]
+    fn aggregator_name_suffix_fails() {
+        let config = MithrilInfrastructureConfig {
+            number_of_aggregators: 1,
+            ..MithrilInfrastructureConfig::dummy()
+        };
+
+        config.aggregator_name_suffix(2);
+    }
+}

mithril-test-lab/mithril-end-to-end/src/mithril/relay_aggregator.rs

@@ -6,15 +6,15 @@ use tokio::process::Child;
 
 #[derive(Debug)]
 pub struct RelayAggregator {
-    index: usize,
+    name_suffix: String,
     listen_port: u64,
     command: MithrilCommand,
     process: Option<Child>,
 }
 
 impl RelayAggregator {
     pub fn new(
-        index: usize,
+        name: String,
         listen_port: u64,
         dial_to: Option<String>,
         aggregator_endpoint: &str,
@@ -32,13 +32,10 @@ impl RelayAggregator {
         let args = vec!["-vvv", "aggregator"];
 
         let mut command = MithrilCommand::new("mithril-relay", work_dir, bin_dir, env, &args)?;
-        command.set_log_name(&format!(
-            "mithril-relay-aggregator-{}",
-            Self::name_suffix(index),
-        ));
+        command.set_log_name(&format!("mithril-relay-aggregator-{}", name,));
 
         Ok(Self {
-            index,
+            name_suffix: name,
             listen_port,
             command,
             process: None,
@@ -49,12 +46,8 @@ impl RelayAggregator {
         format!("/ip4/127.0.0.1/tcp/{}", self.listen_port)
     }
 
-    pub fn name_suffix(index: usize) -> String {
-        if index == 0 {
-            "master".to_string()
-        } else {
-            format!("slave-{}", index)
-        }
+    pub fn name_suffix(&self) -> String {
+        self.name_suffix.clone()
     }
 
     pub fn start(&mut self) -> StdResult<()> {
@@ -65,10 +58,7 @@ impl RelayAggregator {
     pub async fn tail_logs(&self, number_of_line: u64) -> StdResult<()> {
         self.command
             .tail_logs(
-                Some(&format!(
-                    "mithril-relay-aggregator-{}",
-                    Self::name_suffix(self.index),
-                )),
+                Some(&format!("mithril-relay-aggregator-{}", self.name_suffix())),
                 number_of_line,
             )
             .await

mithril-test-lab/mithril-end-to-end/src/stress_test/aggregator_helpers.rs

@@ -19,7 +19,8 @@ pub async fn bootstrap_aggregator(
     let chain_observer_type = "cardano-cli";
 
     let mut aggregator = Aggregator::new(&AggregatorConfig {
-        index: 0,
+        is_master: false,
+        name: "genesis",
         server_port: args.server_port as u64,
         pool_node: &args.pool_node,
         cardano_cli_path: &args.cardano_cli_path,