psimplified pipeline executor

1 files changed, 30 insertions, 71 deletions

diff --git a/src/run/mod.rs b/src/run/mod.rs
index c6d2363..994e222 100644
--- a/src/run/mod.rs
+++ b/src/run/mod.rs
@@ -16,33 +16,6 @@ struct Executor {
     se: Arc<Mutex<Session>>,
 }
 
-#[derive(Clone)]
-struct ArcWriter {
-    inner: Arc<Mutex<Vec<u8>>>,
-}
-
-impl ArcWriter {
-    pub fn new() -> Self {
-        Self {
-            inner: Arc::new(Mutex::new(Vec::new())),
-        }
-    }
-    pub fn into_inner(self) -> Vec<u8> {
-        self.inner.lock().unwrap().clone()
-    }
-}
-
-impl std::io::Write for ArcWriter {
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        self.inner.lock().unwrap().extend_from_slice(buf);
-        Ok(buf.len())
-    }
-
-    fn flush(&mut self) -> io::Result<()> {
-        Ok(())
-    }
-}
-
 impl Executor {
     fn execute_pipeline(
         &mut self,
@@ -54,12 +27,9 @@ impl Executor {
         let mut prev_reader = None;
         let mut spawn_error = false;
 
-        let last_output = ArcWriter::new();
-        let mut last_is_command = false;
-
         let pipelen = pipes.cmds.len();
         for (i, cmd) in pipes.cmds.into_iter().enumerate() {
-            let (reader, writer) = if i < pipelen - 1 {
+            let (reader, writer) = if i < pipelen - 1 || capture.is_some() {
                 let (r, w) = io::pipe().unwrap();
                 (Some(r), Some(w))
             } else {
@@ -70,8 +40,6 @@ impl Executor {
 
             match dc {
                 CommandKind::Path(path) => {
-                    last_is_command = true;
-
                     let mut command = Command::new(&path);
                     for arg in cmd.args.iter() {
                         command.arg(OsStr::from_bytes(arg));
@@ -123,8 +91,6 @@ impl Executor {
                 }
 
                 CommandKind::Builtin(builtin) => {
-                    last_is_command = false;
-
                     let mut input: Box<dyn io::Read + Send> = match prev_reader.take() {
                         Some(r) => Box::new(r),
                         None if capture.is_some() => Box::new(io::empty()),
@@ -133,7 +99,6 @@ impl Executor {
 
                     let mut output: Box<dyn io::Write + Send> = match writer {
                         Some(w) => Box::new(w),
-                        None if capture.is_some() => Box::new(last_output.clone()),
                         None => Box::new(io::stdout()),
                     };
 
@@ -162,47 +127,41 @@ impl Executor {
                     println!("failed to kill child - {e:?}");
                 }
             }
-            Err(ExecError::ExecError(127))
-        } else {
-            let mut code = 0;
-            for jh in threads {
-                match jh.join() {
-                    Ok(Ok(())) => (),
-                    Ok(Err(e)) => match e {
-                        BuiltinError::IO(_) => code = -1,
-                        BuiltinError::Exit(c) => code = c,
-                    },
-                    Err(_) => code = 127,
-                }
+            return Err(ExecError::ExecError(127));
+        }
+
+        if let (Some(cap), Some(mut reader)) = (capture, prev_reader) {
+            reader.read_to_end(cap).unwrap();
+        }
+
+        let mut code = 0;
+        for jh in threads {
+            match jh.join() {
+                Ok(Ok(())) => (),
+                Ok(Err(e)) => match e {
+                    BuiltinError::IO(_) => code = -1,
+                    BuiltinError::Exit(c) => code = c,
+                },
+                Err(_) => code = 127,
             }
-            for child in children.iter_mut() {
-                match child.wait() {
-                    Ok(ec) => {
-                        if let Some(c) = ec.code() {
-                            code = c;
-                        }
-                    }
-                    Err(e) => {
-                        println!("failed to wait for child - {e:?}")
+        }
+        for child in children.iter_mut() {
+            match child.wait() {
+                Ok(ec) => {
+                    if let Some(c) = ec.code() {
+                        code = c;
                     }
                 }
-            }
-
-            if let Some(cap) = capture {
-                if last_is_command {
-                    let child = children.into_iter().last().unwrap();
-                    let out = child.wait_with_output().unwrap();
-                    *cap = out.stdout;
-                } else {
-                    *cap = last_output.into_inner();
+                Err(e) => {
+                    println!("failed to wait for child - {e:?}")
                 }
             }
+        }
 
-            if code == 0 {
-                Ok(())
-            } else {
-                Err(ExecError::ExecError(code))
-            }
+        if code == 0 {
+            Ok(())
+        } else {
+            Err(ExecError::ExecError(code))
         }
     }