143 lines
4.6 KiB
Rust
143 lines
4.6 KiB
Rust
use std::time::Duration;
|
|
|
|
use super::{ActiveState, BootState, Outcome, Progress};
|
|
|
|
#[derive(Clone, Debug, PartialEq, Eq)]
|
|
pub struct MilestoneRow {
|
|
pub label: String,
|
|
pub finished_units: usize,
|
|
pub started_at: Duration,
|
|
pub reached_at: Duration,
|
|
}
|
|
|
|
struct ReachedMilestone<'a> {
|
|
target: &'a str,
|
|
reached_at: Duration,
|
|
}
|
|
|
|
struct MilestoneWalk {
|
|
rows: Vec<MilestoneRow>,
|
|
previous: Duration,
|
|
consumed: usize,
|
|
}
|
|
|
|
impl MilestoneWalk {
|
|
fn advance(mut self, reached: &ReachedMilestone, succeeded_sorted: &[Duration]) -> Self {
|
|
let upto = succeeded_sorted.partition_point(|at| *at <= reached.reached_at);
|
|
self.rows.push(MilestoneRow {
|
|
label: reached.target.to_owned(),
|
|
finished_units: upto.saturating_sub(self.consumed),
|
|
started_at: self.previous.min(reached.reached_at),
|
|
reached_at: reached.reached_at,
|
|
});
|
|
self.consumed = self.consumed.max(upto);
|
|
self.previous = reached.reached_at;
|
|
self
|
|
}
|
|
}
|
|
|
|
impl BootState {
|
|
fn milestone_reached_at(&self, target: &str) -> Option<Duration> {
|
|
let record = self.units.get(target)?;
|
|
match record.progress {
|
|
Progress::Finished(Outcome::Succeeded { at }) => Some(at),
|
|
Progress::Untouched => record.activity.active_enter.filter(|entered| {
|
|
record.activity.state == Some(ActiveState::Active) && *entered >= self.origin
|
|
}),
|
|
Progress::Pending(_) | Progress::Finished(Outcome::Failed | Outcome::Abandoned) => None,
|
|
}
|
|
}
|
|
|
|
#[must_use]
|
|
pub fn milestones(&self) -> Vec<MilestoneRow> {
|
|
let mut succeeded: Vec<Duration> = self
|
|
.units
|
|
.values()
|
|
.filter_map(|record| match record.progress {
|
|
Progress::Finished(Outcome::Succeeded { at }) => Some(at),
|
|
_ => None,
|
|
})
|
|
.collect();
|
|
succeeded.sort_unstable();
|
|
let start = MilestoneWalk {
|
|
rows: self
|
|
.finished_stages
|
|
.iter()
|
|
.map(|stage| MilestoneRow {
|
|
label: stage.label.to_owned(),
|
|
finished_units: stage.finished_units,
|
|
started_at: stage.started_at,
|
|
reached_at: stage.reached_at,
|
|
})
|
|
.collect(),
|
|
previous: self
|
|
.finished_stages
|
|
.last()
|
|
.map_or(self.origin, |stage| stage.reached_at),
|
|
consumed: 0,
|
|
};
|
|
self.milestone_targets
|
|
.iter()
|
|
.filter_map(|target| {
|
|
self.milestone_reached_at(target)
|
|
.map(|reached_at| ReachedMilestone { target, reached_at })
|
|
})
|
|
.fold(start, |walk, reached| walk.advance(&reached, &succeeded))
|
|
.rows
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use crate::{
|
|
boot_model::{Activity, JobResult, Phase},
|
|
boot_test_fixtures::{MS, nested_boot_sample, queued_boot, waiting, waiting_rows},
|
|
};
|
|
|
|
#[test]
|
|
fn finished_jobs_leave_the_tree_and_count_toward_their_milestone() {
|
|
let mut state = nested_boot_sample();
|
|
state.finish_job(6, JobResult::Done, 3500 * MS);
|
|
state.finish_job(7, JobResult::Done, 4000 * MS);
|
|
state.update_activity(
|
|
"basic.target",
|
|
Activity {
|
|
state: Some(ActiveState::Active),
|
|
inactive_exit: None,
|
|
active_enter: Some(4000 * MS),
|
|
active_exit: None,
|
|
},
|
|
);
|
|
assert!(
|
|
waiting_rows(&state)
|
|
.iter()
|
|
.all(|row| row.label != "containerd" && row.label != "basic.target")
|
|
);
|
|
let milestones = state.milestones();
|
|
assert_eq!(milestones.len(), 1);
|
|
assert_eq!(milestones[0].label, "basic.target");
|
|
assert_eq!(milestones[0].finished_units, 2);
|
|
}
|
|
|
|
#[test]
|
|
fn shutdown_counts_toward_its_own_milestones_and_never_completes() {
|
|
let mut state = queued_boot(
|
|
Phase::Shutdown,
|
|
Duration::ZERO,
|
|
[
|
|
waiting("poweroff.target", &[]),
|
|
waiting("shutdown.target", &[]),
|
|
waiting("db.service", &[]).stopping(),
|
|
],
|
|
);
|
|
state.finish_job(3, JobResult::Done, 500 * MS);
|
|
state.finish_job(2, JobResult::Done, 600 * MS);
|
|
state.finish_job(1, JobResult::Done, 700 * MS);
|
|
let milestones = state.milestones();
|
|
assert_eq!(milestones[0].label, "shutdown.target");
|
|
assert_eq!(milestones[0].finished_units, 2);
|
|
assert!(!state.is_complete());
|
|
}
|
|
}
|