use crate::channel::{ChildMessage, ShepherdMessage};
use crate::runner::{ExitOutcome, LogLine, RunnerError, RunningProcess, StopSignal};
use core::fmt;
use shep_core::signals::OperatorSignal;
use std::sync::atomic::{AtomicU32, Ordering};
use std::sync::{Arc, Mutex};
use tokio::sync::{Notify, mpsc, watch};
use tokio::time::{Instant, sleep_until};
#[derive(Debug)]
pub struct FakeIo {
pub logs_tx: mpsc::Sender<LogLine>,
pub from_child_tx: mpsc::Sender<ChildMessage>,
pub to_child_rx: mpsc::Receiver<ShepherdMessage>,
}
pub(super) struct ProcState {
pub(super) exit_deadline: Instant,
pub(super) outcome: ExitOutcome,
pub(super) obeys_signal: bool,
pub(super) obeys_kill: bool,
pub(super) signal_notify: Notify,
pub(super) pending_signal: Mutex<Option<i32>>,
pub(super) signals: Mutex<Vec<i32>>,
pub(super) process_signals: Mutex<Vec<OperatorSignal>>,
pub(super) kill_notify: Notify,
pub(super) kill_count: AtomicU32,
pub(super) resolved: Mutex<Option<ExitOutcome>>,
pub(super) exited: watch::Sender<bool>,
}
impl fmt::Debug for ProcState {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("ProcState")
.field("exit_deadline", &self.exit_deadline)
.field("outcome", &self.outcome)
.field("obeys_signal", &self.obeys_signal)
.field("kill_count", &self.kill_count.load(Ordering::SeqCst))
.finish_non_exhaustive()
}
}
#[derive(Debug, Clone)]
pub struct FakeProc {
pub(super) pid: u32,
pub(super) state: Arc<ProcState>,
}
impl ProcState {
fn record_signal(&self, raw: i32) {
self.signals.lock().unwrap().push(raw);
*self.pending_signal.lock().unwrap() = Some(raw);
self.signal_notify.notify_one();
}
pub(super) fn record_shutdown(&self) {
self.signal_notify.notify_one();
}
fn record_kill(&self) {
self.kill_count.fetch_add(1, Ordering::SeqCst);
self.kill_notify.notify_one();
}
fn record_process_signal(&self, sig: OperatorSignal) {
self.process_signals.lock().unwrap().push(sig);
}
}
impl RunningProcess for FakeProc {
fn pid(&self) -> u32 {
self.pid
}
async fn wait(&mut self) -> ExitOutcome {
if let Some(outcome) = *self.state.resolved.lock().unwrap() {
return outcome;
}
let outcome = tokio::select! {
() = sleep_until(self.state.exit_deadline) => self.state.outcome,
() = self.state.signal_notify.notified(), if self.state.obeys_signal => {
let raw = self.state.pending_signal.lock().unwrap().take();
ExitOutcome {
code: None,
signal: Some(raw.unwrap_or_else(|| StopSignal::Term.as_raw())),
}
}
() = self.state.kill_notify.notified(), if self.state.obeys_kill => {
ExitOutcome { code: None, signal: Some(StopSignal::Kill.as_raw()) }
}
};
*self.state.resolved.lock().unwrap() = Some(outcome);
self.state.exited.send_replace(true);
outcome
}
fn signal(&mut self, sig: StopSignal) -> Result<(), RunnerError> {
self.state.record_signal(sig.as_raw());
Ok(())
}
fn kill_tree(&mut self) -> Result<(), RunnerError> {
self.state.record_kill();
Ok(())
}
fn signal_process(&mut self, sig: OperatorSignal) -> Result<(), RunnerError> {
self.state.record_process_signal(sig);
Ok(())
}
}
#[cfg(test)]
mod tests {
use super::super::proc_script::ProcScript;
use super::super::scripted_runner::ScriptedRunner;
use shep_core::signals::OperatorSignal;
use tokio::time::Duration;
use crate::runner::{ExitOutcome, ProcessRunner, RunningProcess};
use super::super::testing::*;
#[tokio::test(start_paused = true)]
async fn a_process_signal_is_recorded_apart_from_a_group_signal() {
let runner = ScriptedRunner::new(vec![ProcScript::never_exits()]);
let (mut proc, _io) = runner.spawn(&spec()).unwrap();
proc.signal_process(OperatorSignal::Hup).unwrap();
proc.signal_process(OperatorSignal::Usr1).unwrap();
assert_eq!(
runner.process_signals(0),
vec![OperatorSignal::Hup, OperatorSignal::Usr1]
);
assert!(
runner.signals(0).is_empty(),
"a per-process signal must not be counted as a group signal"
);
}
#[tokio::test(start_paused = true)]
async fn a_process_signal_does_not_end_the_scripted_proc() {
let runner = ScriptedRunner::new(vec![ProcScript::never_exits()]);
let (proc, _io) = runner.spawn(&spec()).unwrap();
let mut waiter = proc.clone();
let mut signaller = proc;
let waiting = tokio::spawn(async move { waiter.wait().await });
tokio::time::advance(Duration::from_millis(1)).await;
signaller.signal_process(OperatorSignal::Hup).unwrap();
tokio::time::advance(Duration::from_secs(1)).await;
assert!(!waiting.is_finished(), "signal_process resolved the wait");
waiting.abort();
}
#[tokio::test(start_paused = true)]
async fn cancel_safety_deadline_survives_drop_and_reawait() {
let runner = ScriptedRunner::new(vec![ProcScript::stable_then_exit(5_000, 7)]);
let (mut proc, _io) = runner.spawn(&spec()).unwrap();
let mut first_wait = proc.clone();
let handle = tokio::spawn(async move { first_wait.wait().await });
tokio::time::advance(Duration::from_secs(1)).await;
assert!(
!handle.is_finished(),
"wait() must still be pending 1s into a 5s delay"
);
handle.abort();
tokio::time::advance(Duration::from_secs(4)).await;
let outcome = proc.wait().await;
assert_eq!(
outcome,
ExitOutcome {
code: Some(7),
signal: None
}
);
}
#[tokio::test(start_paused = true)]
async fn repeated_wait_returns_the_same_cached_outcome() {
let runner = ScriptedRunner::new(vec![ProcScript::const_exit(3)]);
let (mut proc, _io) = runner.spawn(&spec()).unwrap();
let first = proc.wait().await;
let second = proc.wait().await;
assert_eq!(first, second);
assert_eq!(
first,
ExitOutcome {
code: Some(3),
signal: None
}
);
}
}