use super::*;
#[cfg(unix)]
pub(super) type Snapshot = (Vec<OwnedCandidate>, Handover, ParkedPumps);
#[cfg(unix)]
#[derive(Debug, Default)]
pub(crate) struct ParkedPumps {
pumps: Vec<mpsc::Sender<LogCtl>>,
_listeners: Vec<HeldListener>,
}
#[cfg(unix)]
impl ParkedPumps {
pub(crate) async fn resume(&self) {
for pump in &self.pumps {
let _ = pump.send(LogCtl::Resume).await;
}
}
}
#[cfg(unix)]
#[derive(Debug)]
pub(super) struct HandoverDraft {
pub(super) entry: ProcessEntry,
pub(super) manual: Option<PendingManual>,
pub(super) pending_delete: bool,
pub(super) epoch: u64,
pub(super) ready_failed: bool,
pub(super) disabled: bool,
pub(super) restart_due: Option<SystemTime>,
pub(super) log_ctl: Option<mpsc::Sender<LogCtl>>,
pub(super) channel_open: bool,
}
#[cfg(unix)]
pub(super) fn spawn_handover_task(
drafts: Vec<HandoverDraft>,
fds: DaemonFds,
counters: Counters,
reloads: Vec<CarriedReload>,
listeners: Vec<HeldListener>,
reply: oneshot::Sender<Result<Snapshot, SupervisorError>>,
) {
tokio::spawn(async move {
let visited = futures_util::future::join_all(drafts.into_iter().map(|draft| async move {
let (mut fds, pump_unresponsive, parked_pump) = match &draft.log_ctl {
Some(log_ctl) => match report_fds(log_ctl).await {
PumpReport::Parked(fds) => (fds, false, Some(log_ctl.clone())),
PumpReport::Gone => (CarriedFds::none(), false, None),
PumpReport::Unresponsive => (CarriedFds::none(), true, None),
},
None => (CarriedFds::none(), false, None),
};
if !draft.channel_open {
fds.channel = None;
}
let carried = CarriedSheep::from_entry(
&draft.entry,
draft.epoch,
fds,
draft.pending_delete,
draft.manual,
draft.ready_failed,
draft.restart_due,
)
.with_disabled(draft.disabled);
let candidate = OwnedCandidate {
entry: draft.entry,
pump_unresponsive,
};
(candidate, carried, parked_pump)
}))
.await;
let mut candidates = Vec::with_capacity(visited.len());
let mut carried = Vec::with_capacity(visited.len());
let mut parked = ParkedPumps::default();
for (candidate, sheep, parked_pump) in visited {
candidates.push(candidate);
carried.push(sheep);
if let Some(log_ctl) = parked_pump {
parked.pumps.push(log_ctl);
}
}
let mut blob = Handover::new(carried, fds, counters, reloads);
blob.carry_listeners(&listeners);
parked._listeners = listeners;
let _ = reply.send(Ok((candidates, blob, parked)));
});
}
#[cfg(unix)]
#[derive(Debug)]
pub(super) enum PumpReport {
Parked(CarriedFds),
Gone,
Unresponsive,
}
#[cfg(unix)]
pub(super) const REPORT_DEADLINE: Duration = Duration::from_secs(2);
#[cfg(unix)]
pub(super) async fn report_fds(log_ctl: &mpsc::Sender<LogCtl>) -> PumpReport {
let (done, ack) = oneshot::channel();
let answer = async {
if log_ctl.send(LogCtl::ReportFds { done }).await.is_err() {
return PumpReport::Gone;
}
ack.await.map_or(PumpReport::Gone, PumpReport::Parked)
};
tokio::time::timeout(REPORT_DEADLINE, answer)
.await
.unwrap_or(PumpReport::Unresponsive)
}