add streaming command struct for (spawn + piping scenario)

Author: Shourya742

src/bootstrap/src/utils/exec.rs

@@ -13,7 +13,9 @@ use std::fmt::{Debug, Formatter};
 use std::hash::Hash;
 use std::panic::Location;
 use std::path::Path;
-use std::process::{Child, Command, CommandArgs, CommandEnvs, ExitStatus, Output, Stdio};
+use std::process::{
+    Child, ChildStderr, ChildStdout, Command, CommandArgs, CommandEnvs, ExitStatus, Output, Stdio,
+};
 use std::sync::{Arc, Mutex};
 
 use build_helper::ci::CiEnv;
@@ -449,6 +451,12 @@ enum CommandState<'a> {
     },
 }
 
+pub struct CommandStreaming {
+    child: Child,
+    pub stdout: Option<ChildStdout>,
+    pub stderr: Option<ChildStderr>,
+}
+
 #[must_use]
 pub struct DeferredCommand<'a> {
     state: CommandState<'a>,
@@ -625,7 +633,48 @@ impl AsRef<ExecutionContext> for ExecutionContext {
     }
 }
 
+impl CommandStreaming {
+    pub fn wait(mut self) -> Result<ExitStatus, std::io::Error> {
+        self.child.wait()
+    }
+
+    pub fn wait_with_output(self) -> Result<Output, std::io::Error> {
+        self.child.wait_with_output()
+    }
+}
+
 impl<'a> DeferredCommand<'a> {
+    pub fn stream(self) -> Option<CommandStreaming> {
+        if let CommandState::Deferred {
+            process,
+            command,
+            stdout: _,
+            stderr: _,
+            executed_at: _,
+            cache_key: _,
+        } = self.state
+        {
+            command.mark_as_executed();
+
+            let child = match process {
+                Some(child) => child,
+                None => {
+                    return None;
+                }
+            };
+
+            let mut child = match child {
+                Ok(child) => child,
+                Err(e) => panic!("failed to execute command: {:?}\nERROR: {e}", command),
+            };
+
+            let stdout = child.stdout.take();
+            let stderr = child.stderr.take();
+            return Some(CommandStreaming { child, stdout, stderr });
+        }
+        None
+    }
+
     pub fn wait_for_output(self, exec_ctx: impl AsRef<ExecutionContext>) -> CommandOutput {
         match self.state {
             CommandState::Cached(output) => output,