Parse the output from nix.

src/nix_util/output_stream.rs

@@ -0,0 +1,85 @@
+use tokio::io::AsyncBufReadExt;
+use tokio::io::BufReader;
+use tokio::io::Lines;
+use tokio::process::Child;
+use tokio::process::ChildStderr;
+use tokio::process::ChildStdout;
+
+use crate::Result;
+
+pub(crate) struct OutputStream {
+    stdout: Option<Lines<BufReader<ChildStdout>>>,
+    stderr: Option<Lines<BufReader<ChildStderr>>>,
+}
+
+impl OutputStream {
+    pub(crate) fn from_child(child: &mut Child) -> Result<Self> {
+        let stdout = child
+            .stdout
+            .take()
+            .expect("child did not have a handle to stdout");
+        let stderr = child
+            .stderr
+            .take()
+            .expect("child did not have a handle to stderr");
+        let stdout = BufReader::new(stdout).lines();
+        let stderr = BufReader::new(stderr).lines();
+        Ok(OutputStream {
+            stdout: Some(stdout),
+            stderr: Some(stderr),
+        })
+    }
+
+    pub(crate) async fn next_line(&mut self) -> Result<OutputLine> {
+        loop {
+            match (&mut self.stdout, &mut self.stderr) {
+                (None, None) => {
+                    return Ok(OutputLine::Done);
+                }
+                (None, Some(err)) => {
+                    if let Some(line) = err.next_line().await? {
+                        return Ok(OutputLine::Stderr(line));
+                    } else {
+                        return Ok(OutputLine::Done);
+                    }
+                }
+                (Some(out), None) => {
+                    if let Some(line) = out.next_line().await? {
+                        return Ok(OutputLine::Stdout(line));
+                    } else {
+                        return Ok(OutputLine::Done);
+                    }
+                }
+                (Some(out), Some(err)) => {
+                    tokio::select! {
+                        Ok(line) = out.next_line() => match line {
+                            Some(line) => {
+                                return Ok(OutputLine::Stdout(line));
+                            },
+                            None => {
+                                self.stdout.take();
+                            },
+                        },
+                        Ok(line) = err.next_line() => match line {
+                            Some(line) => {
+                                return Ok(OutputLine::Stderr(line));
+                            },
+                            None => {
+                                self.stderr.take();
+                            },
+                        },
+                        else => {
+                            return Ok(OutputLine::Done);
+                        },
+                    };
+                }
+            };
+        }
+    }
+}
+
+pub(crate) enum OutputLine {
+    Stdout(String),
+    Stderr(String),
+    Done,
+}