Merge pull request #10 from dreadnode/bugfix/variable_substitutions

Fixing variable interpolation in cmd.rs

Author: evilsocket

robopages

@@ -0,0 +1 @@
+Subproject commit d24c9c9284ec38fef14d529ba5b038d9553644dd

src/runtime/cmd.rs

@@ -12,9 +12,25 @@ pub struct CommandLine {
     pub temp_env_file: Option<tempfile::NamedTempFile>,
 }
 
+impl Clone for CommandLine {
+    fn clone(&self) -> Self {
+        Self {
+            sudo: self.sudo,
+            app: self.app.clone(),
+            app_in_path: self.app_in_path,
+            args: self.args.clone(),
+            env: self.env.clone(),
+            temp_env_file: None,  // Don't clone the temp file, create a new one if needed
+        }
+    }
+}
+
 impl CommandLine {
     pub fn from_vec(vec: &Vec<String>) -> anyhow::Result<Self> {
+        log::debug!("Creating CommandLine from vector: {:?}", vec);
+        
         if vec.is_empty() {
+            log::error!("Empty command line vector provided");
             return Err(anyhow::anyhow!("empty command line"));
         }
 
@@ -23,29 +39,39 @@ impl CommandLine {
         let mut args = Vec::new();
 
         for arg in vec {
+            log::trace!("Processing argument: {}", arg);
             if arg == "sudo" {
+                log::debug!("Sudo flag detected");
                 sudo = true;
             } else if app.is_empty() {
+                log::debug!("Setting application name: {}", arg);
                 app = arg.to_string();
             } else {
+                log::trace!("Adding argument: {}", arg);
                 args.push(arg.to_string());
             }
         }
 
         if app.is_empty() {
+            log::error!("Could not determine application name from: {:?}", vec);
             return Err(anyhow::anyhow!(
                 "could not determine application name from command line: {:?}",
                 vec
             ));
         }
 
         let app_in_path = if let Ok(path) = which::which(&app) {
+            log::debug!("Found application in path: {}", path.display());
             app = path.to_string_lossy().to_string();
             true
         } else {
+            log::debug!("Application '{}' not found in PATH", app);
             false
         };
 
+        log::debug!("Created CommandLine: sudo={}, app={}, app_in_path={}, args={:?}", 
+            sudo, app, app_in_path, args);
+
         Ok(Self {
             sudo,
             app,
@@ -60,39 +86,82 @@ impl CommandLine {
         vec: &Vec<String>,
         env: BTreeMap<String, String>,
     ) -> anyhow::Result<Self> {
+        log::debug!("Creating CommandLine with environment variables");
+        log::trace!("Environment variables: {:?}", env);
         let mut cmd = Self::from_vec(vec)?;
         cmd.env = env;
         Ok(cmd)
     }
 
+    fn interpolate_variables(&mut self) -> anyhow::Result<()> {
+        log::debug!("Interpolating variables from environment: {:?}", self.env);
+        
+        self.args = self.args.iter().map(|arg| {
+            let mut result = arg.clone();
+            for (key, value) in &self.env {
+                let pattern = format!("${{{}}}", key);
+                if result.contains(&pattern) {
+                    log::debug!("Replacing {} with {}", pattern, value);
+                    result = result.replace(&pattern, value);
+                }
+            }
+            result
+        }).collect();
+
+        log::debug!("After interpolation: {:?}", self.args);
+        Ok(())
+    }
+
     pub async fn execute(&self) -> anyhow::Result<String> {
-        let output = tokio::process::Command::new(&self.app)
-            .args(&self.args)
-            .output()
-            .await?;
+        log::info!("Executing command: {}", self);
+        log::debug!("Full command details: {:?}", self);
+
+        // Create a mutable copy for interpolation
+        let mut cmd = self.clone();
+        cmd.interpolate_variables()?;
+
+        let mut command = tokio::process::Command::new(&cmd.app);
+        command.args(&cmd.args);
+
+        // Log environment variables if present
+        if !cmd.env.is_empty() {
+            log::debug!("Setting environment variables: {:?}", cmd.env);
+            command.envs(&cmd.env);
+        }
+
+        let output = command.output().await?;
+        log::debug!("Command completed with status: {:?}", output.status);
 
         let mut parts = vec![];
 
         let stdout = String::from_utf8_lossy(&output.stdout);
         let stderr = String::from_utf8_lossy(&output.stderr);
 
         if !output.status.success() {
+            log::warn!("Command failed with exit code: {}", output.status);
             parts.push(format!("EXIT CODE: {}", &output.status));
         }
 
         if !stdout.is_empty() {
+            log::trace!("Command stdout: {}", stdout);
             parts.push(stdout.to_string());
         }
 
         if !stderr.is_empty() {
             if output.status.success() {
+                log::debug!("Command stderr (success): {}", stderr);
                 parts.push(stderr.to_string());
             } else {
+                log::error!("Command stderr (failure): {}", stderr);
                 parts.push(format!("ERROR: {}", stderr));
             }
         }
 
-        Ok(parts.join("\n"))
+        let result = parts.join("\n");
+        log::debug!("Command execution completed, output length: {}", result.len());
+        log::trace!("Command output: {}", result);
+
+        Ok(result)
     }
 }