feat(testing/cli): add cli command and logic to run/replay a scenario

re: #188

Author: binier

node/testing/Cargo.toml

@@ -17,6 +17,7 @@ lazy_static = "1.4.0"
 derive_more = "0.99.17"
 serde = "1.0.147"
 serde_json = { version = "1.0.82", features = ["unbounded_depth", "arbitrary_precision"] }
+thiserror = "1.0.37"
 anyhow = "1.0.70"
 bincode = "1.3.3"
 rand = "0.8"

node/testing/src/cluster/mod.rs

@@ -545,7 +545,7 @@ impl Cluster {
                     .nodes
                     .get_mut(node_id.index())
                     .ok_or_else(|| anyhow::anyhow!("node {node_id:?} not found"))?;
-                let timeout = tokio::time::sleep(Duration::from_secs(5));
+                let timeout = tokio::time::sleep(Duration::from_secs(60));
                 tokio::select! {
                     res = node.wait_for_event_and_dispatch(&event) => res,
                     _ = timeout => {

node/testing/src/main.rs

@@ -1,6 +1,7 @@
 use clap::Parser;
 
-use openmina_node_testing::cluster::ClusterConfig;
+use openmina_node_testing::cluster::{Cluster, ClusterConfig};
+use openmina_node_testing::scenario::Scenario;
 use openmina_node_testing::scenarios::Scenarios;
 use openmina_node_testing::{exit_with_error, server, setup};
 
@@ -18,6 +19,7 @@ pub enum Command {
     Server(CommandServer),
 
     ScenariosGenerate(CommandScenariosGenerate),
+    ScenariosRun(CommandScenariosRun),
 }
 
 #[derive(Debug, clap::Args)]
@@ -34,6 +36,16 @@ pub struct CommandScenariosGenerate {
     pub use_debugger: bool,
 }
 
+/// Run scenario located at `res/scenarios`.
+#[derive(Debug, clap::Args)]
+pub struct CommandScenariosRun {
+    /// Name of the scenario.
+    ///
+    /// Must match filename in `res/scenarios` (without an extension).
+    #[arg(long, short)]
+    pub name: String,
+}
+
 impl Command {
     pub fn run(self) -> Result<(), crate::CommandError> {
         let rt = setup();
@@ -101,6 +113,27 @@ impl Command {
                     .to_owned()
                     .into())
             }
+            Self::ScenariosRun(cmd) => {
+                let config = ClusterConfig::new(None).map_err(|err| {
+                    anyhow::anyhow!("failed to create cluster configuration: {err}")
+                })?;
+
+                let id = cmd.name.parse()?;
+                let fut = async move {
+                    let mut cluster = Cluster::new(config);
+                    cluster.start(Scenario::load(&id).await?).await?;
+                    cluster.exec_to_end().await?;
+                    Ok(())
+                };
+                rt.block_on(async {
+                    tokio::select! {
+                        res = fut => res,
+                        _ = shutdown_rx => {
+                            anyhow::bail!("Received ctrl-c signal! shutting down...");
+                        }
+                    }
+                })
+            }
         }
     }
 }

node/testing/src/scenario/id.rs

@@ -1,8 +1,18 @@
+use std::str::FromStr;
+
 use serde::{Deserialize, Deserializer, Serialize};
 
 #[derive(Serialize, Debug, Eq, PartialEq, Clone)]
 pub struct ScenarioId(String);
 
+#[derive(thiserror::Error, Debug)]
+pub enum ScenarioIdParseError {
+    #[error("scenario id can't contain upper-case characters")]
+    ContainsUpperCaseCharacters,
+    #[error("scenario id must match pattern /[a-z0-9_-]*/")]
+    AcceptedPatternMismatch,
+}
+
 #[cfg(feature = "scenario-generators")]
 impl From<crate::scenarios::Scenarios> for ScenarioId {
     fn from(value: crate::scenarios::Scenarios) -> Self {
@@ -16,26 +26,30 @@ impl std::fmt::Display for ScenarioId {
     }
 }
 
-impl<'de> Deserialize<'de> for ScenarioId {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        let s: String = Deserialize::deserialize(deserializer)?;
+impl FromStr for ScenarioId {
+    type Err = ScenarioIdParseError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
         for c in s.chars() {
             if ('A'..'Z').contains(&c) {
-                return Err(serde::de::Error::custom(
-                    "scenario id can't contain upper-case characters",
-                ));
+                return Err(ScenarioIdParseError::ContainsUpperCaseCharacters);
             }
             if ('a'..'z').contains(&c) || ('0'..'9').contains(&c) || c == '-' || c == '_' {
                 continue;
             }
-            return Err(serde::de::Error::custom(
-                "scenario id must match pattern /[a-z0-9_-]*/",
-            ));
+            return Err(ScenarioIdParseError::AcceptedPatternMismatch);
         }
+        Ok(Self(s.to_owned()))
+    }
+}
+
+impl<'de> Deserialize<'de> for ScenarioId {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: &str = Deserialize::deserialize(deserializer)?;
 
-        Ok(ScenarioId(s))
+        Self::from_str(s).map_err(|err| serde::de::Error::custom(err))
     }
 }