feat: implement run_script for Docker provider

Author: mchristou

crates/examples/examples/test_run_script.rs

@@ -0,0 +1,66 @@
+use std::path::PathBuf;
+
+use zombienet_sdk::{NetworkConfigBuilder, NetworkConfigExt, RunScriptOptions};
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    tracing_subscriber::fmt::init();
+
+    // Build a simple network configuration
+    let network = NetworkConfigBuilder::new()
+        .with_relaychain(|r| {
+            r.with_chain("rococo-local")
+                .with_default_command("polkadot")
+                .with_default_image("docker.io/parity/polkadot:v1.20.2")
+                .with_validator(|node| node.with_name("alice"))
+        })
+        .build()
+        .unwrap()
+        .spawn_docker()
+        .await?;
+
+    println!("🚀🚀🚀🚀 network deployed");
+
+    let alice = network.get_node("alice")?;
+
+    // Create test script if it doesn't exist
+    let script_path = PathBuf::from("./test_script.sh");
+    if !script_path.exists() {
+        println!("Creating test_script.sh...");
+        std::fs::write(
+            &script_path,
+            r#"#!/bin/bash
+                        echo "✅ Script executed successfully!"
+                        echo "Arguments: $@"
+                        echo "NODE_NAME env: $NODE_NAME"
+                        echo "Working dir: $(pwd)"
+                        echo "Hostname: $(hostname)"
+                        exit 0
+                    "#,
+        )?;
+    }
+
+    println!("Running test_script.sh with args and env vars");
+    let options = RunScriptOptions::new(&script_path)
+        .args(vec!["arg1".to_string(), "arg2".to_string()])
+        .env(vec![("NODE_NAME".to_string(), "alice".to_string())]);
+
+    println!("Executing script...");
+    match alice.run_script(options).await? {
+        Ok(stdout) => {
+            println!("\n✅ Script executed successfully!");
+            println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+            println!("STDOUT:\n{}", stdout);
+            println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+        },
+        Err((status, stderr)) => {
+            println!("\n❌ Script failed with exit code: {:?}", status.code());
+            println!("STDERR:\n{}", stderr);
+            return Err("Script execution failed".into());
+        },
+    }
+
+    network.destroy().await?;
+
+    Ok(())
+}

crates/orchestrator/src/network/node.rs

@@ -273,6 +273,22 @@ impl NetworkNode {
         Ok(())
     }
 
+    /// Run a script inside the node's container/environment
+    ///
+    /// The script will be uploaded to the node, made executable, and executed with
+    /// the provided arguments and environment variables.
+    ///
+    /// Returns `Ok(stdout)` on success, or `Err((exit_status, stderr))` on failure.
+    pub async fn run_script(
+        &self,
+        options: provider::types::RunScriptOptions,
+    ) -> Result<provider::types::ExecutionResult, anyhow::Error> {
+        self.inner
+            .run_script(options)
+            .await
+            .map_err(|e| anyhow!("Failed to run script: {}", e))
+    }
+
     // Metrics assertions
 
     /// Get metric value 'by name' from Prometheus (exposed by the node)

crates/provider/src/docker/node.rs

@@ -501,9 +501,30 @@ where
 
     async fn run_script(
         &self,
-        _options: RunScriptOptions,
+        options: RunScriptOptions,
     ) -> Result<ExecutionResult, ProviderError> {
-        todo!()
+        let file_name = options
+            .local_script_path
+            .file_name()
+            .expect(&format!(
+                "file name should be present at this point {THIS_IS_A_BUG}"
+            ))
+            .to_string_lossy();
+
+        let remote_script_path = PathBuf::from(format!("/tmp/{file_name}"));
+
+        // Upload the script to the container and make it executable
+        self.send_file(&options.local_script_path, &remote_script_path, "0755")
+            .await?;
+
+        // Run the script with provided arguments and environment
+        self.run_command(RunCommandOptions {
+            program: remote_script_path.to_string_lossy().to_string(),
+            args: options.args,
+            env: options.env,
+        })
+        .await
+        .map_err(|err| ProviderError::RunScriptError(self.name.to_string(), err.into()))
     }
 
     async fn send_file(
@@ -524,8 +545,7 @@ where
             mode
         );
 
-        let _ = self
-            .docker_client
+        self.docker_client
             .container_cp(&self.container_name, local_file_path, remote_file_path)
             .await
             .map_err(|err| {
@@ -534,15 +554,14 @@ where
                     self.name.clone(),
                     err.into(),
                 )
-            });
+            })?;
 
-        let _ = self
-            .docker_client
+        self.docker_client
             .container_exec(
                 &self.container_name,
                 vec!["chmod", mode, &remote_file_path.to_string_lossy()],
                 None,
-                None,
+                Some("root"),
             )
             .await
             .map_err(|err| {
@@ -551,6 +570,13 @@ where
                     local_file_path.to_string_lossy().to_string(),
                     err.into(),
                 )
+            })?
+            .map_err(|err| {
+                ProviderError::SendFile(
+                    self.name.clone(),
+                    local_file_path.to_string_lossy().to_string(),
+                    anyhow!("chmod failed: status {}: {}", err.0, err.1),
+                )
             })?;
 
         Ok(())

crates/sdk/src/lib.rs

@@ -10,6 +10,7 @@ pub use orchestrator::{
     network::{node::NetworkNode, Network},
     sc_chain_spec, AddCollatorOptions, AddNodeOptions, Orchestrator,
 };
+pub use provider::types::{ExecutionResult, RunScriptOptions};
 
 // Helpers used for interact with the network
 pub mod tx_helper {