use std::io;
use std::process::{ChildStderr, ChildStdin, ChildStdout, Command, ExitStatus};
use crate::sys;
#[cfg(test)]
mod tests;
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
#[non_exhaustive]
pub enum Scope {
#[default]
Group,
Child,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[non_exhaustive]
pub enum Signal {
Interrupt,
Terminate,
Hangup,
Kill,
}
#[derive(Debug)]
pub(crate) struct Group {
child: sys::Child,
status: Option<ExitStatus>,
}
impl Group {
pub(crate) fn start(command: Command, scope: Scope) -> io::Result<Self> {
Ok(Self {
child: sys::Child::spawn(command, scope)?,
status: None,
})
}
pub(crate) fn others_alive(&self) -> bool {
self.child.others_alive()
}
#[cfg(all(test, unix))]
pub(crate) fn id(&self) -> u32 {
self.child.id()
}
pub(crate) fn take_stdin(&mut self) -> Option<ChildStdin> {
self.child.take_stdin()
}
pub(crate) fn take_stdout(&mut self) -> Option<ChildStdout> {
self.child.take_stdout()
}
pub(crate) fn take_stderr(&mut self) -> Option<ChildStderr> {
self.child.take_stderr()
}
pub(crate) fn signal(&self, signal: Signal) -> io::Result<()> {
if self.status.is_some() {
return Err(io::Error::other("the child has been reaped"));
}
self.child.signal(signal)
}
pub(crate) fn has_exited(&self) -> io::Result<bool> {
if self.status.is_some() {
return Ok(true);
}
self.child.has_exited()
}
#[cfg(all(test, unix))]
pub(crate) fn wait_exit(&self) -> io::Result<()> {
if self.status.is_some() {
return Ok(());
}
self.child.waiter().wait()
}
pub(crate) fn waiter(&self) -> sys::Waiter {
self.child.waiter()
}
pub(crate) fn reap(&mut self) -> io::Result<ExitStatus> {
if let Some(status) = self.status {
return Ok(status);
}
let status = self.child.reap()?;
self.status = Some(status);
Ok(status)
}
}
impl Drop for Group {
fn drop(&mut self) {
if self.status.is_none() {
let _ = self.child.signal(Signal::Kill);
let _ = self.reap();
}
}
}