Allow start_chain to return multiple child processes (#591)

soareschen · web-flow · commit fdaa818a5173 · 2025-04-14T10:51:33.000+02:00
* Allow start_chain to return multiple child processes

* Debug log command when starting child process
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/crates/cli/cli-components/src/impls/commands/bootstrap/chain.rs b/crates/cli/cli-components/src/impls/commands/bootstrap/chain.rs
@@ -80,18 +80,27 @@ where
         )
         .await;
 
-        let m_chain_process = chain_driver.take_chain_process();
+        let chain_processes = chain_driver.take_chain_process();
 
-        if let Some(chain_process) = m_chain_process {
-            app.log(&format!("running chain {} running in the background. Press Ctrl+C to stop then chain...", chain_driver.chain().chain_id()), &LevelInfo).await;
+        if !chain_processes.is_empty() {
+            app.log(
+                &format!(
+                    "running chain {} in the background. Press Ctrl+C to stop then chain...",
+                    chain_driver.chain().chain_id()
+                ),
+                &LevelInfo,
+            )
+            .await;
 
-            Runtime::wait_child_process(chain_process)
-                .await
-                .map_err(|e| {
-                    App::wrap_error(App::raise_error(e), "chain process exited with error")
-                })?;
+            for chain_process in chain_processes {
+                Runtime::wait_child_process(chain_process)
+                    .await
+                    .map_err(|e| {
+                        App::wrap_error(App::raise_error(e), "chain process exited with error")
+                    })?;
+            }
 
-            app.log("chain process exited with no error", &LevelInfo)
+            app.log("chain processes exited with no error", &LevelInfo)
                 .await;
         }
 
diff --git a/crates/cosmos/cosmos-integration-tests/src/contexts/chain_driver.rs b/crates/cosmos/cosmos-integration-tests/src/contexts/chain_driver.rs
@@ -59,7 +59,7 @@ use toml::to_string_pretty;
 pub struct CosmosChainDriver {
     pub chain: CosmosChain,
     pub chain_command_path: PathBuf,
-    pub chain_process: Option<Child>,
+    pub chain_processes: Vec<Child>,
     pub chain_node_config: CosmosChainNodeConfig,
     pub genesis_config: CosmosGenesisConfig,
     pub validator_wallet: CosmosTestWallet,
@@ -158,8 +158,8 @@ impl ChainCommandPathGetter<CosmosChainDriver> for CosmosChainDriverComponents {
 
 #[cgp_provider(ChainProcessTakerComponent)]
 impl ChainProcessTaker<CosmosChainDriver> for CosmosChainDriverComponents {
-    fn take_chain_process(chain_driver: &mut CosmosChainDriver) -> Option<Child> {
-        chain_driver.chain_process.take()
+    fn take_chain_process(chain_driver: &mut CosmosChainDriver) -> Vec<Child> {
+        core::mem::take(&mut chain_driver.chain_processes)
     }
 }
 
diff --git a/crates/cosmos/cosmos-integration-tests/src/impls/bootstrap/build_cosmos_chain_driver.rs b/crates/cosmos/cosmos-integration-tests/src/impls/bootstrap/build_cosmos_chain_driver.rs
@@ -25,9 +25,7 @@ use tokio::process::Child;
 use crate::contexts::chain_driver::CosmosChainDriver;
 use crate::traits::bootstrap::build_chain::CanBuildChainWithNodeConfig;
 
-pub struct BuildCosmosChainDriver;
-
-#[cgp_provider(ChainDriverBuilderComponent)]
+#[cgp_new_provider(ChainDriverBuilderComponent)]
 impl<Bootstrap, Runtime> ChainDriverBuilder<Bootstrap> for BuildCosmosChainDriver
 where
     Bootstrap: HasChainDriverType<ChainDriver = CosmosChainDriver>
@@ -47,7 +45,7 @@ where
         genesis_config: CosmosGenesisConfig,
         chain_node_config: CosmosChainNodeConfig,
         wallets: BTreeMap<String, CosmosTestWallet>,
-        chain_process: Child,
+        chain_processes: Vec<Child>,
     ) -> Result<CosmosChainDriver, Bootstrap::Error> {
         let validator_wallet = wallets
             .get("validator")
@@ -96,7 +94,7 @@ where
             chain_command_path,
             chain_node_config,
             genesis_config,
-            chain_process: Some(chain_process),
+            chain_processes,
             validator_wallet,
             relayer_wallet,
             user_wallet_a,
diff --git a/crates/cosmos/cosmos-test-components/src/bootstrap/impls/chain/bootstrap_chain.rs b/crates/cosmos/cosmos-test-components/src/bootstrap/impls/chain/bootstrap_chain.rs
@@ -13,7 +13,7 @@ use hermes_test_components::chain_driver::traits::types::chain::HasChainType;
 use hermes_test_components::driver::traits::types::chain_driver::HasChainDriverType;
 
 use crate::bootstrap::traits::chain::build_chain_driver::CanBuildChainDriver;
-use crate::bootstrap::traits::chain::start_chain::CanStartChainFullNode;
+use crate::bootstrap::traits::chain::start_chain::CanStartChainFullNodes;
 use crate::bootstrap::traits::generator::generate_chain_id::CanGenerateChainId;
 use crate::bootstrap::traits::generator::generate_wallet_config::CanGenerateWalletConfigs;
 use crate::bootstrap::traits::genesis::add_genesis_wallet::CanAddWalletToGenesis;
@@ -40,7 +40,7 @@ where
         + CanAddWalletToGenesis
         + CanCollectGenesisTransactions
         + CanInitChainNodeConfig
-        + CanStartChainFullNode
+        + CanStartChainFullNodes
         + CanBuildChainDriver,
     Runtime: HasFilePathType + HasChildProcessType + HasAsyncErrorType,
     Chain: HasChainIdType + HasWalletType,
@@ -92,7 +92,7 @@ where
 
         // Start the chain full node in the background, and return the child process handle
         let chain_process = bootstrap
-            .start_chain_full_node(&chain_home_dir, &chain_config, &genesis_config)
+            .start_chain_full_nodes(&chain_home_dir, &chain_config, &genesis_config)
             .await?;
 
         // Build the chain context from the bootstrap parameters
diff --git a/crates/cosmos/cosmos-test-components/src/bootstrap/impls/chain/build_wait.rs b/crates/cosmos/cosmos-test-components/src/bootstrap/impls/chain/build_wait.rs
@@ -35,7 +35,7 @@ where
         genesis_config: Bootstrap::ChainGenesisConfig,
         chain_node_config: Bootstrap::ChainNodeConfig,
         wallets: BTreeMap<String, Wallet<Bootstrap::Chain>>,
-        chain_process: ChildProcessOf<Bootstrap::Runtime>,
+        chain_process: Vec<ChildProcessOf<Bootstrap::Runtime>>,
     ) -> Result<ChainDriver, Bootstrap::Error> {
         let chain_driver = InBuilder::build_chain_driver(
             bootstrap,
diff --git a/crates/cosmos/cosmos-test-components/src/bootstrap/impls/chain/start_chain.rs b/crates/cosmos/cosmos-test-components/src/bootstrap/impls/chain/start_chain.rs
@@ -12,9 +12,7 @@ use crate::bootstrap::traits::types::genesis_config::HasChainGenesisConfigType;
 use crate::bootstrap::types::chain_node_config::CosmosChainNodeConfig;
 use crate::bootstrap::types::genesis_config::CosmosGenesisConfig;
 
-pub struct StartCosmosChain;
-
-#[cgp_provider(ChainFullNodeStarterComponent)]
+#[cgp_new_provider(ChainFullNodeStarterComponent)]
 impl<Bootstrap, Runtime> ChainFullNodeStarter<Bootstrap> for StartCosmosChain
 where
     Bootstrap: HasRuntime<Runtime = Runtime>
@@ -25,12 +23,12 @@ where
         + CanRaiseAsyncError<Runtime::Error>,
     Runtime: HasFilePathType + CanStartChildProcess,
 {
-    async fn start_chain_full_node(
+    async fn start_chain_full_nodes(
         bootstrap: &Bootstrap,
         chain_home_dir: &Runtime::FilePath,
         chain_config: &CosmosChainNodeConfig,
         _chain_genesis_config: &CosmosGenesisConfig,
-    ) -> Result<Runtime::ChildProcess, Bootstrap::Error> {
+    ) -> Result<Vec<Runtime::ChildProcess>, Bootstrap::Error> {
         let chain_command = bootstrap.chain_command_path();
 
         let args = [
@@ -69,6 +67,6 @@ where
             .await
             .map_err(Bootstrap::raise_error)?;
 
-        Ok(child_process)
+        Ok(vec![child_process])
     }
 }
diff --git a/crates/cosmos/cosmos-test-components/src/bootstrap/traits/chain/build_chain_driver.rs b/crates/cosmos/cosmos-test-components/src/bootstrap/traits/chain/build_chain_driver.rs
@@ -28,6 +28,6 @@ pub trait CanBuildChainDriver:
         genesis_config: Self::ChainGenesisConfig,
         chain_node_config: Self::ChainNodeConfig,
         wallets: BTreeMap<String, Wallet<Self::Chain>>,
-        chain_process: ChildProcessOf<Self::Runtime>,
+        chain_processes: Vec<ChildProcessOf<Self::Runtime>>,
     ) -> Result<Self::ChainDriver, Self::Error>;
 }
diff --git a/crates/cosmos/cosmos-test-components/src/bootstrap/traits/chain/start_chain.rs b/crates/cosmos/cosmos-test-components/src/bootstrap/traits/chain/start_chain.rs
@@ -11,16 +11,16 @@ use crate::bootstrap::traits::types::genesis_config::HasChainGenesisConfigType;
   context: Bootstrap,
 }]
 #[async_trait]
-pub trait CanStartChainFullNode:
+pub trait CanStartChainFullNodes:
     HasChainNodeConfigType
     + HasChainGenesisConfigType
     + HasRuntime<Runtime: HasChildProcessType + HasFilePathType>
     + HasAsyncErrorType
 {
-    async fn start_chain_full_node(
+    async fn start_chain_full_nodes(
         &self,
         chain_home_dir: &FilePathOf<Self::Runtime>,
         chain_node_config: &Self::ChainNodeConfig,
         chain_genesis_config: &Self::ChainGenesisConfig,
-    ) -> Result<ChildProcessOf<Self::Runtime>, Self::Error>;
+    ) -> Result<Vec<ChildProcessOf<Self::Runtime>>, Self::Error>;
 }
diff --git a/crates/runtime/runtime/Cargo.toml b/crates/runtime/runtime/Cargo.toml
@@ -16,5 +16,7 @@ cgp                                 = { workspace = true }
 hermes-runtime-components           = { workspace = true }
 hermes-async-runtime-components     = { workspace = true }
 hermes-tokio-runtime-components     = { workspace = true }
+hermes-logging-components           = { workspace = true }
+hermes-tracing-logging-components   = { workspace = true }
 
-tokio                               = { workspace = true }
+tokio                               = { workspace = true }
diff --git a/crates/runtime/runtime/src/types/runtime.rs b/crates/runtime/runtime/src/types/runtime.rs
@@ -1,7 +1,9 @@
 use alloc::sync::Arc;
 
 use cgp::prelude::*;
+use hermes_logging_components::traits::logger::LoggerComponent;
 use hermes_tokio_runtime_components::components::parallel::*;
+use hermes_tracing_logging_components::contexts::logger::TracingLogger;
 use tokio::runtime::Runtime;
 
 #[cgp_context(HermesRuntimeComponents: TokioParallelRuntimeComponents)]
@@ -10,6 +12,12 @@ pub struct HermesRuntime {
     pub runtime: Arc<Runtime>,
 }
 
+delegate_components! {
+    HermesRuntimeComponents {
+        LoggerComponent: TracingLogger,
+    }
+}
+
 impl HermesRuntime {
     pub fn new(runtime: Arc<Runtime>) -> Self {
         Self { runtime }
diff --git a/crates/runtime/tokio-runtime-components/Cargo.toml b/crates/runtime/tokio-runtime-components/Cargo.toml
@@ -15,8 +15,10 @@ description  = """
 cgp                                 = { workspace = true }
 hermes-runtime-components           = { workspace = true }
 hermes-async-runtime-components     = { workspace = true }
+hermes-logging-components           = { workspace = true }
 
-tokio           = { workspace = true, features = ["full"] }
 futures         = { workspace = true }
+itertools       = { workspace = true }
 rand            = { workspace = true }
-tokio-stream    = { version = "0.1" }
+tokio           = { workspace = true, features = ["full"] }
+tokio-stream    = { version = "0.1" }
diff --git a/crates/runtime/tokio-runtime-components/src/impls/os/child_process.rs b/crates/runtime/tokio-runtime-components/src/impls/os/child_process.rs
@@ -5,6 +5,8 @@ use std::process::{ExitStatus, Stdio};
 
 use cgp::prelude::*;
 use hermes_async_runtime_components::task::types::future_task::FutureTask;
+use hermes_logging_components::traits::logger::CanLog;
+use hermes_logging_components::types::level::LevelDebug;
 use hermes_runtime_components::traits::fs::file_path::HasFilePathType;
 use hermes_runtime_components::traits::fs::read_file::CanReadFileAsString;
 use hermes_runtime_components::traits::os::child_process::{
@@ -13,6 +15,7 @@ use hermes_runtime_components::traits::os::child_process::{
 };
 use hermes_runtime_components::traits::sleep::CanSleep;
 use hermes_runtime_components::traits::spawn::CanSpawnTask;
+use itertools::Itertools;
 use tokio::fs::OpenOptions;
 use tokio::io::{copy, AsyncRead};
 use tokio::process::{Child, Command};
@@ -42,6 +45,7 @@ where
         + CanSleep
         + CanPipeReaderToFile
         + CanReadFileAsString
+        + CanLog<LevelDebug>
         + CanRaiseAsyncError<IoError>
         + CanRaiseAsyncError<PrematureChildProcessExitError>,
     Runtime::FilePath: AsRef<Path>,
@@ -53,7 +57,21 @@ where
         envs: &[(&str, &str)],
         stdout_path: Option<&Runtime::FilePath>,
         stderr_path: Option<&Runtime::FilePath>,
-    ) -> Result<Runtime::ChildProcess, Runtime::Error> {
+    ) -> Result<Child, Runtime::Error> {
+        runtime
+            .log(
+                &format!(
+                    "starting child process with the command: {} {}",
+                    command_path.as_ref().display(),
+                    command_args
+                        .iter()
+                        .map(|arg| format!("\"{arg}\""))
+                        .join(" "),
+                ),
+                &LevelDebug,
+            )
+            .await;
+
         let mut child_process = Command::new(command_path.as_ref())
             .args(command_args)
             .envs(Vec::from(envs))
diff --git a/crates/test/test-components/src/chain_driver/traits/chain_process.rs b/crates/test/test-components/src/chain_driver/traits/chain_process.rs
@@ -1,3 +1,5 @@
+use alloc::vec::Vec;
+
 use cgp::prelude::*;
 use hermes_runtime_components::traits::os::child_process::{ChildProcessOf, HasChildProcessType};
 use hermes_runtime_components::traits::runtime::HasRuntime;
@@ -8,5 +10,5 @@ use hermes_runtime_components::traits::runtime::HasRuntime;
 }]
 #[async_trait]
 pub trait CanTakeChainProcess: HasRuntime<Runtime: HasChildProcessType> {
-    fn take_chain_process(&mut self) -> Option<ChildProcessOf<Self::Runtime>>;
+    fn take_chain_process(&mut self) -> Vec<ChildProcessOf<Self::Runtime>>;
 }
diff --git a/crates/wasm/wasm-test-components/src/impls/bootstrap/build_chain_driver.rs b/crates/wasm/wasm-test-components/src/impls/bootstrap/build_chain_driver.rs
@@ -70,7 +70,7 @@ where
         genesis_config: Bootstrap::ChainGenesisConfig,
         chain_node_config: Bootstrap::ChainNodeConfig,
         wallets: BTreeMap<String, Chain::Wallet>,
-        chain_process: Runtime::ChildProcess,
+        chain_process: Vec<Runtime::ChildProcess>,
     ) -> Result<Bootstrap::ChainDriver, Bootstrap::Error> {
         let chain_driver = InBuilder::build_chain_driver(
             bootstrap,

Original file line number	Diff line number	Diff line change
`@@ -28,6 +28,6 @@ pub trait CanBuildChainDriver:`
`28`	`28`	`genesis_config: Self::ChainGenesisConfig,`
`29`	`29`	`chain_node_config: Self::ChainNodeConfig,`
`30`	`30`	`wallets: BTreeMap<String, Wallet<Self::Chain>>,`
`31`		`- chain_process: ChildProcessOf<Self::Runtime>,`
	`31`	`+ chain_processes: Vec<ChildProcessOf<Self::Runtime>>,`
`32`	`32`	`) -> Result<Self::ChainDriver, Self::Error>;`
`33`	`33`	`}`