use std::collections::BTreeMap;
use std::time::SystemTime;
use tokio::task::JoinHandle;
use tokio::time::Instant;
use super::caches::MEASURE_EVERY;
use crate::cache;
use crate::docker;
pub(super) type MeasureTask = JoinHandle<Result<cache::Measured, docker::Error>>;
pub(super) type ReseedTask = JoinHandle<Result<String, docker::Error>>;
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub(super) enum Due {
Changed,
Oversized,
Requested,
}
impl Due {
pub(super) fn forces(self) -> bool {
self != Due::Changed
}
}
#[derive(Debug, Default)]
enum Activity {
#[default]
Idle,
Measuring(MeasureTask),
Reseeding {
task: ReseedTask,
memory: u64,
},
}
#[derive(Debug, Default)]
struct ProfileUpkeep {
activity: Activity,
due: Option<Due>,
measure_due: bool,
measured_at: Option<Instant>,
reseeded_at: Option<SystemTime>,
}
impl ProfileUpkeep {
fn mark(&mut self, reason: Due) {
self.due = self.due.max(Some(reason));
}
fn slot_one_ran(&mut self) {
self.measure_due = true;
}
fn take_due(&mut self) -> Option<Due> {
self.measure_due = false;
self.due.take()
}
fn measure_started(&mut self, task: MeasureTask, now: Instant) {
self.measure_due = false;
self.measured_at = Some(now);
self.activity = Activity::Measuring(task);
}
fn reseed_started(&mut self, task: ReseedTask, memory: u64) {
self.activity = Activity::Reseeding { task, memory };
}
fn take_finished_measure(&mut self) -> Option<MeasureTask> {
match std::mem::take(&mut self.activity) {
Activity::Measuring(task) if task.is_finished() => Some(task),
other => {
self.activity = other;
None
}
}
}
fn take_finished_reseed(&mut self) -> Option<ReseedTask> {
match std::mem::take(&mut self.activity) {
Activity::Reseeding { task, .. } if task.is_finished() => {
self.reseeded_at = Some(SystemTime::now());
Some(task)
}
other => {
self.activity = other;
None
}
}
}
fn forget_due(&mut self) {
self.due = None;
self.measure_due = false;
}
}
#[derive(Debug, Default)]
pub(super) struct Upkeep {
profiles: BTreeMap<String, ProfileUpkeep>,
}
impl Upkeep {
fn profile(&mut self, profile: &str) -> &mut ProfileUpkeep {
self.profiles.entry(profile.to_owned()).or_default()
}
pub(super) fn request(&mut self, profile: &str) {
self.mark(profile, Due::Requested);
}
pub(super) fn mark(&mut self, profile: &str, reason: Due) {
self.profile(profile).mark(reason);
}
pub(super) fn slot_one_ran(&mut self, profile: &str) {
self.profile(profile).slot_one_ran();
}
pub(super) fn take_due(&mut self, profile: &str) -> Option<Due> {
self.profile(profile).take_due()
}
pub(super) fn measure_started(&mut self, profile: &str, task: MeasureTask, now: Instant) {
self.profile(profile).measure_started(task, now);
}
pub(super) fn reseed_started(&mut self, profile: &str, task: ReseedTask, memory: u64) {
self.profile(profile).reseed_started(task, memory);
}
pub(super) fn finished_measures(&mut self) -> BTreeMap<String, MeasureTask> {
let mut finished = BTreeMap::new();
for (name, upkeep) in &mut self.profiles {
if let Some(task) = upkeep.take_finished_measure() {
finished.insert(name.clone(), task);
}
}
finished
}
pub(super) fn finished_reseeds(&mut self) -> BTreeMap<String, ReseedTask> {
let mut finished = BTreeMap::new();
for (name, upkeep) in &mut self.profiles {
if let Some(task) = upkeep.take_finished_reseed() {
finished.insert(name.clone(), task);
}
}
finished
}
pub(super) fn forget_removed(&mut self, kept: impl Fn(&str) -> bool) {
for (name, upkeep) in &mut self.profiles {
if !kept(name) {
upkeep.forget_due();
}
}
}
pub(super) fn due(&self, profile: &str) -> Option<Due> {
self.profiles.get(profile)?.due
}
pub(super) fn due_to_reseed(&self) -> impl Iterator<Item = &String> {
self.profiles
.iter()
.filter(|(_, upkeep)| upkeep.due.is_some() && matches!(upkeep.activity, Activity::Idle))
.map(|(name, _)| name)
}
pub(super) fn due_to_measure(&self, now: Instant) -> impl Iterator<Item = &String> {
self.profiles
.iter()
.filter(move |(_, upkeep)| {
upkeep.measure_due
&& upkeep.due.is_none()
&& matches!(upkeep.activity, Activity::Idle)
&& upkeep
.measured_at
.is_none_or(|at| now.duration_since(at) >= MEASURE_EVERY)
})
.map(|(name, _)| name)
}
pub(super) fn requested(&self) -> impl Iterator<Item = &String> {
self.profiles
.iter()
.filter(|(_, upkeep)| upkeep.due == Some(Due::Requested))
.map(|(name, _)| name)
}
pub(super) fn is_requested(&self, profile: &str) -> bool {
self.due(profile) == Some(Due::Requested)
}
pub(super) fn reseed_runs(&self, profile: &str) -> bool {
self.profiles
.get(profile)
.is_some_and(|upkeep| matches!(upkeep.activity, Activity::Reseeding { .. }))
}
pub(super) fn reseed_runs_or_is_requested(&self, profile: &str) -> bool {
self.reseed_runs(profile) || self.is_requested(profile)
}
pub(super) fn requested_reseed_waits(&self, profile: &str) -> bool {
self.is_requested(profile) && !self.reseed_runs(profile)
}
pub(super) fn snapshot_unchanged_since(&self, profile: &str, check_began: SystemTime) -> bool {
!self.reseed_runs(profile)
&& self
.profiles
.get(profile)
.and_then(|upkeep| upkeep.reseeded_at)
.is_none_or(|at| at < check_began)
}
pub(super) fn seed_memories(&self) -> BTreeMap<String, u64> {
self.profiles
.iter()
.filter_map(|(name, upkeep)| match upkeep.activity {
Activity::Reseeding { memory, .. } => Some((name.clone(), memory)),
Activity::Idle | Activity::Measuring(_) => None,
})
.collect()
}
pub(super) fn seeds_memory(&self) -> u64 {
self.seed_memories().values().sum()
}
#[cfg(test)]
pub(super) fn measure_is_due(&self, profile: &str) -> bool {
self.profiles
.get(profile)
.is_some_and(|upkeep| upkeep.measure_due)
}
#[cfg(test)]
pub(super) fn oversized(&self) -> usize {
self.profiles
.values()
.filter(|upkeep| upkeep.due == Some(Due::Oversized))
.count()
}
}