use super::*;
#[derive(Debug)]
pub(super) struct SignalRequest {
pub(super) sig: OperatorSignal,
pub(super) done: oneshot::Sender<Result<(), RunnerError>>,
}
pub(super) struct SheepHandles {
pub(super) ctl: mpsc::Sender<SheepCtl>,
pub(super) signals: mpsc::Sender<SignalRequest>,
}
pub(super) fn spawn_sheep_task<P: RunningProcess>(
id: u32,
proc: P,
io: ProcIo,
app: ResolvedApp,
events: Bus,
actor_tx: mpsc::Sender<Msg>,
) -> SheepHandles {
let (ctl_tx, ctl_rx) = mpsc::channel(SHEEP_CTL_CAPACITY);
let (signal_tx, signal_rx) = mpsc::channel(SIGNAL_CAPACITY);
tokio::spawn(run_sheep(
id, proc, io, app, ctl_rx, signal_rx, events, actor_tx,
));
SheepHandles {
ctl: ctl_tx,
signals: signal_tx,
}
}
#[allow(clippy::too_many_arguments)]
pub(super) async fn run_sheep<P: RunningProcess>(
id: u32,
mut proc: P,
io: ProcIo,
app: ResolvedApp,
mut ctl_rx: mpsc::Receiver<SheepCtl>,
mut signal_rx: mpsc::Receiver<SignalRequest>,
events: Bus,
actor_tx: mpsc::Sender<Msg>,
) {
let ProcIo {
mut logs,
mut from_child,
to_child,
log_ctl: _log_ctl,
to_stdin: _to_stdin,
} = io;
let mut ctl_open = true;
let mut logs_open = true;
let mut from_child_open = true;
let mut signals_open = true;
loop {
tokio::select! {
outcome = proc.wait() => {
let _ = actor_tx.send(Msg::Exited { id, outcome }).await;
break;
}
maybe_ctl = ctl_rx.recv(), if ctl_open => {
match maybe_ctl {
Some(SheepCtl::Kill { grace }) => {
let outcome =
kill_process(&mut proc, app.config(), Some(&to_child), grace).await;
let _ = actor_tx.send(Msg::Exited { id, outcome }).await;
break;
}
None => ctl_open = false,
}
}
maybe_signal = signal_rx.recv(), if signals_open => {
match maybe_signal {
Some(SignalRequest { sig, done }) => {
let _ = done.send(proc.signal_process(sig));
}
None => signals_open = false,
}
}
maybe_line = logs.recv(), if logs_open => {
match maybe_line {
Some(line) => {
events.publish_log(if line.err {
BusEvent::LogErr { id, line: line.line }
} else {
BusEvent::LogOut { id, line: line.line }
});
}
None => logs_open = false,
}
}
maybe_msg = from_child.recv(), if from_child_open => {
match maybe_msg {
Some(message) => {
let _ = events.send(SharedEvent::new(BusEvent::Channel {
id,
message: message.clone(),
}));
match message {
ChildMessage::Ready => {
let _ = actor_tx.send(Msg::Ready { id }).await;
}
ChildMessage::Metric { name, value } => {
tracing::debug!(
id,
name,
value,
"child metric forwarded to the bus as channel.metric"
);
}
ChildMessage::ActionReply {
action,
body,
id: stamp,
} => {
let _ = actor_tx
.send(Msg::ActionReply { id, action, body, stamp })
.await;
}
}
}
None => from_child_open = false,
}
}
}
}
}