128 lines
3.8 KiB
Rust
128 lines
3.8 KiB
Rust
|
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;
|
||
|
|
use crate::database::db_handle::DbHandle;
|
||
|
|
|
||
|
|
pub(crate) struct RunningBuild<'db> {
|
||
|
|
db_handle: &'db DbHandle,
|
||
|
|
}
|
||
|
|
|
||
|
|
impl<'db> RunningBuild<'db> {
|
||
|
|
pub(crate) fn new(db_handle: &'db DbHandle) -> Result<Self> {
|
||
|
|
Ok(RunningBuild { db_handle })
|
||
|
|
}
|
||
|
|
|
||
|
|
pub(crate) async fn run_to_completion(&mut self, mut child: Child) -> Result<()> {
|
||
|
|
let mut output_stream = OutputStream::from_child(&mut child)?;
|
||
|
|
|
||
|
|
let exit_status_handle = tokio::spawn(async move {
|
||
|
|
let status = child
|
||
|
|
.wait()
|
||
|
|
.await
|
||
|
|
.expect("nixos-rebuild encountered an error");
|
||
|
|
status
|
||
|
|
});
|
||
|
|
|
||
|
|
loop {
|
||
|
|
let next_line = output_stream.next_line().await?;
|
||
|
|
match next_line {
|
||
|
|
OutputLine::Stdout(line) | OutputLine::Stderr(line) => {
|
||
|
|
self.handle_line(line)?;
|
||
|
|
}
|
||
|
|
OutputLine::Done => break,
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
let exit_status = exit_status_handle.await?;
|
||
|
|
println!("nixos-rebuild status was: {}", exit_status);
|
||
|
|
|
||
|
|
Ok(())
|
||
|
|
}
|
||
|
|
|
||
|
|
fn handle_line(&mut self, line: String) -> Result<()> {
|
||
|
|
Ok(())
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
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);
|
||
|
|
},
|
||
|
|
};
|
||
|
|
}
|
||
|
|
};
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
enum OutputLine {
|
||
|
|
Stdout(String),
|
||
|
|
Stderr(String),
|
||
|
|
Done,
|
||
|
|
}
|