feat: run polygon edge from topos cli

crates/topos/Cargo.toml

@@ -52,10 +52,11 @@ assert_cmd = "2.0.6"
 insta = { version = "1.21", features = ["json", "redactions"] }
 
 [features]
-default = ["tce", "sequencer", "network", "setup"]
+default = ["tce", "sequencer", "network", "setup", "subnet"]
 tce = ["topos-tce", "topos-tce-transport"]
 sequencer = ["topos-sequencer"]
 network = ["topos-certificate-spammer"]
 setup = []
+subnet = []
 
 tce-direct = ["tce", "topos-tce-broadcast/direct"]

crates/topos/src/components/mod.rs

@@ -4,5 +4,7 @@ pub(crate) mod network;
 pub(crate) mod sequencer;
 #[cfg(feature = "setup")]
 pub(crate) mod setup;
+#[cfg(feature = "subnet")]
+pub(crate) mod subnet;
 #[cfg(feature = "tce")]
 pub(crate) mod tce;

crates/topos/src/components/network/commands.rs

@@ -4,6 +4,7 @@ mod spam;
 
 pub(crate) use spam::Spam;
 
+/// Topos CLI subcommand for network related functionalities (e.g., running the certificate spammer)
 #[derive(Args, Debug)]
 pub(crate) struct NetworkCommand {
     #[clap(from_global)]

crates/topos/src/components/sequencer/commands.rs

@@ -4,6 +4,7 @@ mod run;
 
 pub(crate) use run::Run;
 
+/// Topos CLI subcommand for the Sequencer components
 #[derive(Args, Debug)]
 pub(crate) struct SequencerCommand {
     #[clap(from_global)]

crates/topos/src/components/setup/commands.rs

@@ -4,6 +4,7 @@ mod subnet;
 
 pub(crate) use subnet::Subnet;
 
+/// Topos CLI subcommand for the setup of various Topos related components (e.g., installation of Polygon Edge binary)
 #[derive(Args, Debug)]
 pub(crate) struct SetupCommand {
     #[clap(from_global)]

crates/topos/src/components/subnet/commands.rs

@@ -0,0 +1,30 @@
+use clap::{Args, Subcommand};
+
+mod subnet;
+
+pub(crate) use subnet::Run;
+
+/// Topos CLI subcommand for the Polygon Edge related functionalities
+#[derive(Args, Debug)]
+pub(crate) struct SubnetCommand {
+    #[clap(from_global)]
+    pub(crate) verbose: u8,
+
+    #[clap(subcommand)]
+    pub(crate) subcommands: Option<SubnetCommands>,
+}
+
+#[derive(Subcommand, Debug)]
+pub(crate) enum SubnetCommands {
+    Run(Run),
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_run() {
+        assert!(SubnetCommands::has_subcommand("run"));
+    }
+}

crates/topos/src/components/subnet/commands/subnet.rs

@@ -0,0 +1,17 @@
+use clap::{ArgGroup, Args, Parser};
+use std::path::PathBuf;
+
+#[derive(Parser, Debug)]
+#[clap(about = "Run Polygon Edge", trailing_var_arg = true)]
+pub struct Run {
+    /// Installation directory path for Polygon Edge binary.
+    /// If not provided, Polygon Edge binary will be expected in the current directory
+    #[arg(long, env = "TOPOS_POLYGON_EDGE_BIN_PATH", default_value = ".")]
+    pub path: PathBuf,
+
+    /// Polygon Edge command line arguments
+    #[clap(allow_hyphen_values = true)]
+    pub polygon_edge_arguments: Vec<String>,
+}
+
+impl Run {}

crates/topos/src/components/subnet/mod.rs

@@ -0,0 +1,65 @@
+use self::commands::{Run, SubnetCommand, SubnetCommands};
+use clap::Parser;
+use std::process::Stdio;
+use tokio::{io::AsyncReadExt, io::BufReader, process, process::Command};
+use tokio::{signal, spawn};
+use tracing::{error, info};
+
+use crate::tracing::setup_tracing;
+
+pub(crate) mod commands;
+
+pub(crate) async fn handle_command(
+    SubnetCommand {
+        subcommands,
+        verbose,
+    }: SubnetCommand,
+) -> Result<(), Box<dyn std::error::Error>> {
+    match subcommands {
+        Some(SubnetCommands::Run(cmd)) => {
+            setup_tracing(verbose, None, None)?;
+
+            let binary_name =
+                "polygon-edge-".to_string() + std::env::consts::ARCH + "-" + std::env::consts::OS;
+            let polygon_edge_path = cmd.path.join(&binary_name);
+
+            info!(
+                "Running binary {} with arguments:{:?}",
+                polygon_edge_path.display(),
+                cmd.polygon_edge_arguments
+            );
+
+            spawn(async move {
+                // Run Polygon Edge command. Pass all parameters.
+                match Command::new(polygon_edge_path)
+                    .args(cmd.polygon_edge_arguments)
+                    .stderr(Stdio::inherit())
+                    .stdout(Stdio::inherit())
+                    .stdin(Stdio::inherit())
+                    .spawn()
+                {
+                    Ok(mut child) => {
+                        if let Some(pid) = child.id() {
+                            info!("Polygon Edge child process with pid {pid} successfully started");
+                        }
+                        if let Err(e) = child.wait().await {
+                            info!("Polygon Edge child process finished with error: {e}");
+                        }
+                        std::process::exit(0);
+                    }
+                    Err(e) => {
+                        error!("Error executing Polygon Edge: {e}");
+                        std::process::exit(1);
+                    }
+                }
+            });
+
+            signal::ctrl_c()
+                .await
+                .expect("failed to listen for signals");
+
+            Ok(())
+        }
+        None => Ok(()),
+    }
+}

crates/topos/src/components/tce/commands.rs

@@ -21,6 +21,7 @@ pub(crate) struct NodeArgument {
     pub(crate) node: String,
 }
 
+/// Topos CLI subcommand for the TCE related functionalities
 #[derive(Args, Debug)]
 pub(crate) struct TceCommand {
     #[clap(from_global)]

crates/topos/src/main.rs

@@ -25,5 +25,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         options::ToposCommand::Network(cmd) => components::network::handle_command(cmd).await,
         #[cfg(feature = "setup")]
         options::ToposCommand::Setup(cmd) => components::setup::handle_command(cmd).await,
+        #[cfg(feature = "subnet")]
+        options::ToposCommand::Subnet(cmd) => components::subnet::handle_command(cmd).await,
     }
 }

crates/topos/src/options.rs

@@ -12,6 +12,9 @@ use crate::components::network::commands::NetworkCommand;
 #[cfg(feature = "setup")]
 use crate::components::setup::commands::SetupCommand;
 
+#[cfg(feature = "subnet")]
+use crate::components::subnet::commands::SubnetCommand;
+
 pub(crate) mod input_format;
 
 #[derive(Parser, Debug)]
@@ -40,4 +43,6 @@ pub(crate) enum ToposCommand {
     Network(NetworkCommand),
     #[cfg(feature = "setup")]
     Setup(SetupCommand),
+    #[cfg(feature = "subnet")]
+    Subnet(SubnetCommand),
 }