use std::collections::BTreeSet;
use std::time::{Duration, SystemTime};
use super::runner_exit::Logged;
use super::runners::backoff;
use crate::api::HoldCause;
use crate::scheduler::Hold;
#[derive(Debug, Default)]
enum IdleStreak {
#[default]
Quiet,
Once {
beside: BTreeSet<String>,
},
Repeated {
beside: BTreeSet<String>,
},
}
impl IdleStreak {
fn lets_go(&mut self, runner: &str) -> bool {
match self {
Self::Quiet => false,
Self::Once { beside } | Self::Repeated { beside } => beside.remove(runner),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(super) struct NewHold {
pub(super) wait: Duration,
pub(super) first: bool,
}
#[derive(Debug, Clone, Copy)]
struct Backoff {
hold: Hold,
failures: u32,
}
#[derive(Debug, Default)]
pub(super) struct PoolHealth {
held: Option<Backoff>,
idle: IdleStreak,
}
impl PoolHealth {
pub(super) fn runner_left(
&mut self,
logged: Logged,
runner: &str,
beside: BTreeSet<String>,
) -> Option<HoldCause> {
match logged {
Logged::TookJob => {
*self = Self::default();
None
}
Logged::NoJob { connected: true } => self.left_idle(runner, beside),
Logged::NoJob { connected: false } => Some(HoldCause::NoJob),
Logged::Unread => None,
}
}
fn left_idle(&mut self, runner: &str, beside: BTreeSet<String>) -> Option<HoldCause> {
if self.idle.lets_go(runner) {
return None;
}
if matches!(self.idle, IdleStreak::Quiet) {
if let Some(held) = self.held.as_mut() {
held.failures = 0;
}
self.idle = IdleStreak::Once { beside };
return None;
}
self.idle = IdleStreak::Repeated { beside };
Some(HoldCause::IdleExits)
}
pub(super) fn hold(&mut self, cause: HoldCause, now: SystemTime) -> Option<NewHold> {
if self.holding(now) {
return None;
}
let failures = self.failures() + 1;
let wait = backoff(failures);
self.held = Some(Backoff {
hold: Hold {
until: now + wait,
cause,
},
failures,
});
Some(NewHold {
wait,
first: failures == 1,
})
}
pub(super) fn held(&self) -> Option<Hold> {
self.held.map(|held| held.hold)
}
pub(super) fn holding(&self, now: SystemTime) -> bool {
self.held.is_some_and(|held| held.hold.until > now)
}
pub(super) fn failures(&self) -> u32 {
self.held.map_or(0, |held| held.failures)
}
#[cfg(test)]
pub(super) fn idle_exits(&self) -> u32 {
match self.idle {
IdleStreak::Quiet => 0,
IdleStreak::Once { .. } => 1,
IdleStreak::Repeated { .. } => 2,
}
}
#[cfg(test)]
pub(super) fn set_streaks(&mut self, failures: u32, idle_exits: u32) {
let beside = BTreeSet::new();
self.held = match (self.held(), failures) {
(None, 0) => None,
(hold, failures) => Some(Backoff {
hold: hold.unwrap_or(Hold {
until: SystemTime::UNIX_EPOCH,
cause: HoldCause::Start,
}),
failures,
}),
};
self.idle = match idle_exits {
0 => IdleStreak::Quiet,
1 => IdleStreak::Once { beside },
_ => IdleStreak::Repeated { beside },
};
}
#[cfg(test)]
pub(super) fn set_held(&mut self, hold: Hold) {
self.held = Some(Backoff {
hold,
failures: self.failures(),
});
}
#[cfg(test)]
pub(super) fn expire(&mut self, past: SystemTime) {
if let Some(held) = self.held.as_mut() {
held.hold.until = past;
}
}
}