Add live command execution with real-time output

Author: lyskov

src/app.rs

@@ -48,6 +48,15 @@ pub enum App {
 
 pub struct Image(pub String);
 
+// enum IoLayout {
+//     Workdir(PathBuf),
+//     InputOutput { input: PathBuf, output: PathBuf },
+// }
+// struct ContainerMounts {
+//     io: IoLayout,
+//     scratch: Option<PathBuf>,
+// }
+
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub enum MountRole {
     WorkingDir,

src/executor/docker.rs

@@ -50,7 +50,7 @@ impl Executor {
 
         println!("Running {command}");
 
-        let result = command.call();
+        let result = command.live().call();
 
         // let command_line = format!(
         //     "docker run {options} {} {}",
@@ -60,8 +60,8 @@ impl Executor {
         // println!("Running {command_line}");
         // let result = util::Command::shell(&command_line).try_call();
 
-        println!("{}", result.stdout.bright_black());
-        eprintln!("{}", result.stderr.bright_red());
+        //println!("{}", result.stdout.bright_black());
+        //eprintln!("{}", result.stderr.bright_red());
 
         let logs = format!(
             "{command}\nprocess success: {}\n{}\n{}\n{}\n",

src/executor/hpc_container.rs

@@ -55,10 +55,10 @@ impl Executor {
 
         println!("Running {command}");
 
-        let result = command.call();
+        let result = command.live().call();
 
-        println!("{}", result.stdout.bright_black());
-        eprintln!("{}", result.stderr.bright_red());
+        // println!("{}", result.stdout.bright_black());
+        // eprintln!("{}", result.stderr.bright_red());
 
         let logs = format!(
             "{command}\nprocess success: {}\n{}\n{}\n{}\n",

src/util/command.rs

@@ -1,6 +1,9 @@
 use std::{
     fmt::{self},
+    io::{Read, Write},
     path::PathBuf,
+    process::Stdio,
+    thread,
 };
 
 use yansi::{Condition, Paint};
@@ -116,7 +119,44 @@ impl Command {
         self.execution_mode = ExecutionMode::PrintOutput { live: true };
         self
     }
+
     // maybe Result<CommandResults, std::io::Error> instead? ie Error::new(ErrorKind::Other, "something went wrong");
+    // pub fn try_call(&self) -> CommandResults {
+    //     println!("{self:#}");
+
+    //     let mut cmd = std::process::Command::new(self.command.clone());
+    //     cmd.args(self.args.clone());
+    //     if let Some(dir) = &self.cd {
+    //         cmd.current_dir(dir);
+    //     }
+
+    //     if let ExecutionMode::PrintOutput { live: true } = self.execution_mode {
+    //         let s = cmd
+    //             .spawn()
+    //             .unwrap_or_else(|_| panic!("command: {} failed to start", self.command.red()))
+    //             .wait()
+    //             .expect("failed to wait on child");
+    //         CommandResults {
+    //             stdout: "".into(),
+    //             stderr: "".into(),
+    //             success: s.success(),
+    //         }
+    //     } else {
+    //         let o = cmd.output().expect("failed to execute process");
+    //         let r = CommandResults {
+    //             stdout: String::from_utf8_lossy(&o.stdout).into(),
+    //             stderr: String::from_utf8_lossy(&o.stderr).into(),
+    //             success: o.status.success(),
+    //         };
+    //         if let ExecutionMode::PrintOutput { live: false } = self.execution_mode {
+    //             println!("{}", r.stdout);
+    //             eprintln!("{}", r.stderr);
+    //         }
+    //         r
+    //     }
+    // }
+
+    /// Execute the command and capture both stdout and stderr while simultaneously printing them live if live is true
     pub fn try_call(&self) -> CommandResults {
         println!("{self:#}");
 
@@ -127,15 +167,81 @@ impl Command {
         }
 
         if let ExecutionMode::PrintOutput { live: true } = self.execution_mode {
-            let s = cmd
+            cmd.stdout(Stdio::piped());
+            cmd.stderr(Stdio::piped());
+
+            let mut child = cmd
                 .spawn()
-                .unwrap_or_else(|_| panic!("command: {} failed to start", self.command.red()))
-                .wait()
-                .expect("failed to wait on child");
+                .unwrap_or_else(|_| panic!("command: {} failed to start", self.command.red()));
+
+            let stdout = child.stdout.take().expect("Failed to capture stdout");
+            let stderr = child.stderr.take().expect("Failed to capture stderr");
+
+            // Create channels to collect output
+            let (stdout_tx, stdout_rx) = std::sync::mpsc::channel();
+            let (stderr_tx, stderr_rx) = std::sync::mpsc::channel();
+
+            fn ssd() {}
+            // Spawn thread to read and print stdout
+            let stdout_thread = thread::spawn(move || {
+                let mut reader = stdout;
+                let mut output = Vec::new();
+                let mut buf = [0u8; 8192];
+
+                let mut out = std::io::stdout().lock();
+
+                loop {
+                    let n = match reader.read(&mut buf) {
+                        Ok(0) => break,
+                        Ok(n) => n,
+                        Err(_) => break,
+                    };
+
+                    output.extend_from_slice(&buf[..n]);
+                    let _ = out.write_all(&buf[..n]); // <-- bytes, not chars
+                    let _ = out.flush();
+                }
+
+                let _ = stdout_tx.send(output);
+            });
+
+            // Spawn thread to read and print stderr
+            let stderr_thread = thread::spawn(move || {
+                let mut reader = stderr;
+                let mut output = Vec::new();
+                let mut buf = [0u8; 8192];
+
+                let mut err = std::io::stderr().lock();
+
+                loop {
+                    let n = match reader.read(&mut buf) {
+                        Ok(0) => break,
+                        Ok(n) => n,
+                        Err(_) => break,
+                    };
+
+                    output.extend_from_slice(&buf[..n]);
+                    let _ = err.write_all(&buf[..n]);
+                    let _ = err.flush();
+                }
+
+                let _ = stderr_tx.send(output);
+            });
+
+            // Wait for the child process to complete
+            let status = child.wait().expect("Failed to wait on child process");
+
+            // Wait for threads to finish and collect output
+            stdout_thread.join().expect("Failed to join stdout thread");
+            stderr_thread.join().expect("Failed to join stderr thread");
+
+            let stdout_bytes = stdout_rx.recv().unwrap_or_default();
+            let stderr_bytes = stderr_rx.recv().unwrap_or_default();
+
             CommandResults {
-                stdout: "".into(),
-                stderr: "".into(),
-                success: s.success(),
+                stdout: String::from_utf8_lossy(&stdout_bytes).into(),
+                stderr: String::from_utf8_lossy(&stderr_bytes).into(),
+                success: status.success(),
             }
         } else {
             let o = cmd.output().expect("failed to execute process");
@@ -275,4 +381,39 @@ mod tests {
         assert!(alt_output.contains("echo"));
         assert!(alt_output.contains("hello world"));
     }
+
+    #[test]
+    fn test_call_live() {
+        let result = Command::shell("echo stdout_test && echo stderr_test >&2")
+            .live()
+            .try_call();
+
+        assert!(result.success);
+        assert_eq!(result.stdout.trim(), "stdout_test");
+        assert_eq!(result.stderr.trim(), "stderr_test");
+    }
+
+    #[test]
+    fn test_call_live_multiline() {
+        let result = Command::shell("echo line1 && echo line2 && echo line3")
+            .live()
+            .try_call();
+        assert!(result.success);
+        assert!(result.stdout.contains("line1"));
+        assert!(result.stdout.contains("line2"));
+        assert!(result.stdout.contains("line3"));
+    }
+
+    #[test]
+    fn test_call_live_utf8() {
+        // Test with various UTF-8 multi-byte characters
+        let result = Command::shell("echo こんにちは世界 🌸 おちゃ café")
+            .live()
+            .try_call();
+
+        assert!(result.success);
+        assert!(result.stdout.contains("こんにちは世界"));
+        assert!(result.stdout.contains("🌸"));
+        assert!(result.stdout.contains("café"));
+    }
 }