Do not capture output for run_cmd!() and spawn!()

Or output from long running process would be blocked
Fixed #30

Author: tao-guo

README.md

@@ -230,11 +230,11 @@ println!("get result: {}", run_fun!(my_cmd)?);
 `spawn!()` macro executes the whole command as a child process, returning a handle to it. By
 default, stdin, stdout and stderr are inherited from the parent.
 
-To get result, you can call `wait_cmd_result()` or `wait_fun_result()` to get CmdResult/FunResult.
+With `spawn_with_output!()` you can get output result by calling `wait_fun_result()`.
 
 ```rust
 spawn!(ping -c 10 192.168.0.1)?.wait_cmd_result()?;
-let output = spawn!(/bin/cat file.txt | sed s/a/b/)?.wait_fun_result()?;
+let output = spawn_with_output!(/bin/cat file.txt | sed s/a/b/)?.wait_fun_result()?;
 ```
 
 

examples/rust_cookbook.rs

@@ -27,7 +27,7 @@ fn main() -> CmdResult {
     run_cmd!(rm -f out.txt)?;
 
     // Continuously process child process' outputs
-    spawn!(journalctl)?.wait_with_pipe(&mut |pipe| {
+    spawn_with_output!(journalctl)?.wait_with_pipe(&mut |pipe| {
         BufReader::new(pipe)
             .lines()
             .filter_map(|line| line.ok())

macros/src/lib.rs

@@ -185,7 +185,36 @@ pub fn spawn(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
     let cmds = lexer::Lexer::new(input.into()).scan().parse(true);
     quote! ({
         use ::cmd_lib::AsOsStr;
-        #cmds.spawn()
+        #cmds.spawn(false)
+    })
+    .into()
+}
+
+/// Run commands with/without pipes as a child process, returning a handle to capture the
+/// final output
+/// ```no_run
+/// # use cmd_lib::*;
+/// // from examples/dd_test.rs:
+/// let mut procs = vec![];
+/// for _ in 0..4 {
+///     let proc = spawn_with_output!(
+///         sudo bash -c "dd if=$file of=/dev/null bs=$block_size skip=$off count=$cnt 2>&1"
+///     )?;
+/// }
+///
+/// for (i, mut proc) in procs.into_iter().enumerate() {
+///     let output = proc.wait_fun_result()?;
+///     run_cmd!(info "thread $i bandwidth: $bandwidth MB/s")?;
+/// }
+/// # Ok::<(), std::io::Error>(())
+/// ```
+#[proc_macro]
+#[proc_macro_error]
+pub fn spawn_with_output(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    let cmds = lexer::Lexer::new(input.into()).scan().parse(true);
+    quote! ({
+        use ::cmd_lib::AsOsStr;
+        #cmds.spawn(true)
     })
     .into()
 }

src/lib.rs

@@ -255,12 +255,12 @@
 //! `spawn!()` macro executes the whole command as a child process, returning a handle to it. By
 //! default, stdin, stdout and stderr are inherited from the parent.
 //!
-//! To get result, you can call `wait_cmd_result()` or `wait_fun_result()` to get CmdResult/FunResult.
+//! With `spawn_with_output!()` you can get output result by calling `wait_fun_result()`.
 //!
 //! ```no_run
-//! # use cmd_lib::spawn;
+//! # use cmd_lib::*;
 //! spawn!(ping -c 10 192.168.0.1)?.wait_cmd_result()?;
-//! let output = spawn!(/bin/cat file.txt | sed s/a/b/)?.wait_fun_result()?;
+//! let output = spawn_with_output!(/bin/cat file.txt | sed s/a/b/)?.wait_fun_result()?;
 //! # Ok::<(), std::io::Error>(())
 //! ```
 //!
@@ -322,7 +322,7 @@
 
 pub use cmd_lib_macros::{
     cmd_debug, cmd_die, cmd_echo, cmd_error, cmd_info, cmd_trace, cmd_warn, export_cmd, run_cmd,
-    run_fun, spawn, use_builtin_cmd, use_custom_cmd,
+    run_fun, spawn, spawn_with_output, use_builtin_cmd, use_custom_cmd,
 };
 /// Return type for run_fun!() macro
 pub type FunResult = std::io::Result<String>;

src/process.rs

@@ -138,10 +138,10 @@ impl GroupCmds {
         }
     }
 
-    pub fn spawn(mut self) -> Result<CmdChildren> {
+    pub fn spawn(mut self, with_output: bool) -> Result<CmdChildren> {
         assert_eq!(self.group_cmds.len(), 1);
         let mut cmds = self.group_cmds.pop().unwrap().0;
-        let ret = cmds.spawn(&mut self.current_dir);
+        let ret = cmds.spawn(&mut self.current_dir, with_output);
         if let Err(ref err) = ret {
             error!("Spawning {} failed, Error: {}", cmds.get_full_cmds(), err);
         }
@@ -170,7 +170,7 @@ impl Cmds {
         &self.full_cmds
     }
 
-    fn spawn(&mut self, current_dir: &mut PathBuf) -> Result<CmdChildren> {
+    fn spawn(&mut self, current_dir: &mut PathBuf, with_output: bool) -> Result<CmdChildren> {
         if std::env::var("CMD_LIB_DEBUG") == Ok("1".into()) {
             debug!("Running {} ...", self.get_full_cmds());
         }
@@ -189,19 +189,19 @@ impl Cmds {
             } else {
                 cmd.setup_redirects(&mut last_pipe_in, None)?;
             }
-            let child = cmd.spawn(current_dir)?;
+            let child = cmd.spawn(current_dir, with_output)?;
             children.push(child);
         }
 
         Ok(CmdChildren::from(children))
     }
 
     fn run_cmd(&mut self, current_dir: &mut PathBuf) -> CmdResult {
-        self.spawn(current_dir)?.wait_cmd_result_nolog()
+        self.spawn(current_dir, false)?.wait_cmd_result_nolog()
     }
 
     fn run_fun(&mut self, current_dir: &mut PathBuf) -> FunResult {
-        self.spawn(current_dir)?.wait_fun_result_nolog()
+        self.spawn(current_dir, true)?.wait_fun_result_nolog()
     }
 }
 
@@ -337,7 +337,7 @@ impl Cmd {
         self
     }
 
-    fn spawn(mut self, current_dir: &mut PathBuf) -> Result<CmdChild> {
+    fn spawn(mut self, current_dir: &mut PathBuf, with_output: bool) -> Result<CmdChild> {
         let arg0 = self.arg0();
         let full_cmd = self.debug_str();
         if arg0 == "cd" {
@@ -411,7 +411,7 @@ impl Cmd {
             // update stdout
             if let Some(redirect_out) = self.stdout_redirect.take() {
                 cmd.stdout(redirect_out);
-            } else {
+            } else if with_output {
                 cmd.stdout(Stdio::piped());
             }