process cleanup: simplify wait structure

use CmdChildren for waiting

Author: tao-guo

README.md

@@ -227,14 +227,13 @@ println!("get result: {}", run_fun!(my_cmd)?);
 #### Low-level process spawning macros
 
 `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 capture the output, you
-can use `spawn_with_output!()` macro instead.
+default, stdin, stdout and stderr are inherited from the parent.
 
-To get result, you can call `wait_result()` to get CmdResult/FunResult.
+To get result, you can call `wait_cmd()` or `wait_fun()` to get CmdResult/FunResult.
 
 ```rust
-spawn!(ping -c 10 192.168.0.1)?.wait_result()?;
-let output = spawn_with_output!(/bin/cat file.txt | sed s/a/b/)?.wait_result();
+spawn!(ping -c 10 192.168.0.1)?.wait_cmd()?;
+let output = spawn!(/bin/cat file.txt | sed s/a/b/)?.wait_fun()?;
 ```
 
 

macros/src/lib.rs

@@ -167,13 +167,13 @@ pub fn run_fun(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
 }
 
 /// Run commands with/without pipes as a child process, returning a handle to check the final
-/// status
+/// result
 /// ```no_run
 /// # use cmd_lib::*;
 ///
 /// let handle = spawn!(ping -c 10 192.168.0.1)?;
 /// // ...
-/// if handle.wait_result().is_err() {
+/// if handle.wait_cmd().is_err() {
 ///     // ...
 /// }
 /// # Ok::<(), std::io::Error>(())
@@ -187,34 +187,6 @@ pub fn spawn(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
     .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_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! ({
-        #cmds.spawn_with_output()
-    })
-    .into()
-}
-
 /// Logs a message at the error level with interpolation support
 #[proc_macro]
 #[proc_macro_error]

src/lib.rs

@@ -252,15 +252,14 @@
 //! ### Low-level process spawning macros
 //!
 //! `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 capture the output, you
-//! can use `spawn_with_output!()` macro instead.
+//! default, stdin, stdout and stderr are inherited from the parent.
 //!
-//! To get result, you can call `wait_result()` to get CmdResult/FunResult.
+//! To get result, you can call `wait_cmd()` or `wait_fun()` to get CmdResult/FunResult.
 //!
 //! ```no_run
-//! # use cmd_lib::{spawn, spawn_with_output};
-//! spawn!(ping -c 10 192.168.0.1)?.wait_result()?;
-//! let output = spawn_with_output!(/bin/cat file.txt | sed s/a/b/)?.wait_result();
+//! # use cmd_lib::spawn;
+//! spawn!(ping -c 10 192.168.0.1)?.wait_cmd()?;
+//! let output = spawn!(/bin/cat file.txt | sed s/a/b/)?.wait_fun()?;
 //! # Ok::<(), std::io::Error>(())
 //! ```
 //!
@@ -322,7 +321,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, spawn_with_output, use_builtin_cmd, use_custom_cmd,
+    run_fun, spawn, use_builtin_cmd, use_custom_cmd,
 };
 /// Return type for run_fun!() macro
 pub type FunResult = std::io::Result<String>;

src/process.rs

@@ -137,7 +137,7 @@ impl GroupCmds {
         }
     }
 
-    pub fn spawn(mut self) -> Result<WaitCmd> {
+    pub fn spawn(mut self) -> 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);
@@ -146,18 +146,6 @@ impl GroupCmds {
         }
         ret
     }
-
-    pub fn spawn_with_output(mut self) -> Result<WaitFun> {
-        assert_eq!(self.group_cmds.len(), 1);
-        let mut cmds = self.group_cmds.pop().unwrap().0;
-        match cmds.spawn(&mut self.current_dir) {
-            Ok(ret) => Ok(WaitFun(ret.0)),
-            Err(err) => {
-                error!("Spawning {} failed, Error: {}", cmds.get_full_cmds(), err);
-                Err(err)
-            }
-        }
-    }
 }
 
 #[doc(hidden)]
@@ -181,7 +169,7 @@ impl Cmds {
         &self.full_cmds
     }
 
-    fn spawn(&mut self, current_dir: &mut String) -> Result<WaitCmd> {
+    fn spawn(&mut self, current_dir: &mut String) -> Result<CmdChildren> {
         if std::env::var("CMD_LIB_DEBUG") == Ok("1".into()) {
             debug!("Running {} ...", self.get_full_cmds());
         }
@@ -204,22 +192,22 @@ impl Cmds {
             children.push(child);
         }
 
-        Ok(WaitCmd(children))
+        Ok(CmdChildren(children))
     }
 
     fn run_cmd(&mut self, current_dir: &mut String) -> CmdResult {
-        self.spawn(current_dir)?.wait_result_nolog()
+        self.spawn(current_dir)?.wait_cmd_nolog()
     }
 
     fn run_fun(&mut self, current_dir: &mut String) -> FunResult {
-        WaitFun(self.spawn(current_dir)?.0).wait_result_nolog()
+        self.spawn(current_dir)?.wait_fun_nolog()
     }
 }
 
-pub struct WaitCmd(Vec<CmdChild>);
-impl WaitCmd {
-    pub fn wait_result(&mut self) -> CmdResult {
-        let ret = self.wait_result_nolog();
+pub struct CmdChildren(Vec<CmdChild>);
+impl CmdChildren {
+    pub fn wait_cmd(&mut self) -> CmdResult {
+        let ret = self.wait_cmd_nolog();
         if let Err(ref err) = ret {
             error!(
                 "Running {} failed, Error: {}",
@@ -230,7 +218,7 @@ impl WaitCmd {
         ret
     }
 
-    fn wait_result_nolog(&mut self) -> CmdResult {
+    fn wait_cmd_nolog(&mut self) -> CmdResult {
         // wait last process result
         let handle = self.0.pop().unwrap();
         handle.wait(true)?;
@@ -244,10 +232,7 @@ impl WaitCmd {
         }
         Ok(())
     }
-}
 
-pub struct WaitFun(Vec<CmdChild>);
-impl WaitFun {
     pub fn wait_raw_result(&mut self) -> Result<Vec<u8>> {
         let ret = self.wait_raw_result_nolog();
         if let Err(ref err) = ret {
@@ -265,18 +250,18 @@ impl WaitFun {
         let wait_last = handle.wait_with_output();
         match wait_last {
             Err(e) => {
-                let _ = WaitCmd::wait_children(&mut self.0);
+                let _ = Self::wait_children(&mut self.0);
                 Err(e)
             }
             Ok(output) => {
-                WaitCmd::wait_children(&mut self.0)?;
+                Self::wait_children(&mut self.0)?;
                 Ok(output)
             }
         }
     }
 
-    pub fn wait_result(&mut self) -> FunResult {
-        let ret = self.wait_result_nolog();
+    pub fn wait_fun(&mut self) -> FunResult {
+        let ret = self.wait_fun_nolog();
         if let Err(ref err) = ret {
             error!(
                 "Running {} failed, Error: {}",
@@ -287,21 +272,21 @@ impl WaitFun {
         ret
     }
 
-    fn wait_result_nolog(&mut self) -> FunResult {
+    fn wait_fun_nolog(&mut self) -> FunResult {
         // wait last process result
         let handle = self.0.pop().unwrap();
         let wait_last = handle.wait_with_output();
         match wait_last {
             Err(e) => {
-                let _ = WaitCmd::wait_children(&mut self.0);
+                let _ = CmdChildren::wait_children(&mut self.0);
                 Err(e)
             }
             Ok(output) => {
                 let mut ret = String::from_utf8_lossy(&output).to_string();
                 if ret.ends_with('\n') {
                     ret.pop();
                 }
-                WaitCmd::wait_children(&mut self.0)?;
+                CmdChildren::wait_children(&mut self.0)?;
                 Ok(ret)
             }
         }