From 4c8268a719459da841a9ace2a9d0b71679d7986b Mon Sep 17 00:00:00 2001 From: Willem Vanhulle Date: Wed, 21 Oct 2026 11:36:55 +0200 Subject: [PATCH] refactor: fit and fold the waiting forest in the view --- src/boot_model.rs | 283 +++------------------------ src/boot_test_fixtures.rs | 19 ++ src/boot_view.rs | 14 +- src/boot_view/tree_height_fitting.rs | 219 +++++++++++++++++++++ 4 files changed, 269 insertions(+), 266 deletions(-) create mode 100644 src/boot_view/tree_height_fitting.rs diff --git a/src/boot_model.rs b/src/boot_model.rs index f7415bf..57f6508 100644 --- a/src/boot_model.rs +++ b/src/boot_model.rs @@ -1,8 +1,6 @@ use std::{ collections::{HashMap, HashSet}, - iter::{self, Peekable}, time::Duration, - vec::IntoIter, }; use petgraph::{ @@ -621,7 +619,7 @@ impl BootState { } #[must_use] - pub fn tree_rows(&self, finished_since: Duration) -> Vec { + pub fn waiting_forest(&self, finished_since: Duration) -> Vec { let mut graph = WaitingGraph::new(); self.units .iter() @@ -668,7 +666,7 @@ impl BootState { } let mut space = DfsSpace::new(&graph); let mut visited = HashSet::new(); - let mut rows = Vec::new(); + let mut forest = Vec::new(); stages .iter() .copied() @@ -680,10 +678,10 @@ impl BootState { } let stage = self.grow(top, &graph, &mut space, &mut visited); if stage.row.status != RowStatus::Done || !stage.children.is_empty() { - stage.flatten_into(0, &mut rows); + forest.push(stage); } }); - rows + forest } fn grow<'a>( @@ -807,97 +805,13 @@ impl MilestoneWalk { } } -fn on_paths_to_running(rows: &[TreeRow]) -> Vec { - let mut kept_below: Vec = Vec::new(); - let mut kept: Vec = rows - .iter() - .rev() - .map(|row| { - let descendant_kept = kept_below.iter().skip(row.depth + 1).any(|kept| *kept); - kept_below.resize(row.depth + 1, false); - let anchors_the_tree = row.depth == 0 && row.kind == UnitKind::Target; - let keep = matches!(row.status, RowStatus::Running { .. } | RowStatus::Failed) - || descendant_kept - || anchors_the_tree; - kept_below[row.depth] |= keep; - keep - }) - .collect(); - kept.reverse(); - kept -} - -fn with_spare_rows(essential: &[bool], budget: usize) -> Vec { - let essential_count = essential.iter().filter(|keep| **keep).count(); - let spare = budget.saturating_sub(essential_count + 1); - let earliest_optional: HashSet = essential - .iter() - .enumerate() - .filter(|(_, keep)| !**keep) - .map(|(index, _)| index) - .take(spare) - .collect(); - (0..essential.len()) - .map(|index| essential[index] || earliest_optional.contains(&index)) - .collect() -} - -#[must_use] -pub fn fit_to_height(rows: Vec, budget: usize) -> Vec { - if rows.len() <= budget { - return rows; - } - let kept = with_spare_rows(&on_paths_to_running(&rows), budget); - rows.into_iter() - .zip(kept) - .filter_map(|(row, keep)| keep.then_some(row)) - .collect() -} - -const MIN_FOLDED_LINKS: usize = 2; - -struct TreeNode { - row: TreeRow, - children: Vec, +#[derive(Clone, Debug)] +pub struct TreeNode { + pub row: TreeRow, + pub children: Vec, } impl TreeNode { - fn is_chain_link(&self) -> bool { - self.row.status == RowStatus::Waiting && self.children.len() == 1 - } - - fn foldable_links(&self) -> usize { - let mut links = 0; - let mut cursor = self; - while cursor.is_chain_link() && cursor.children[0].is_chain_link() { - links += 1; - cursor = &cursor.children[0]; - } - links - } - - fn fold(mut self, may_absorb: bool) -> Self { - let links = if may_absorb { self.foldable_links() } else { 0 }; - if links >= MIN_FOLDED_LINKS { - let (chain, below) = (0..links).fold( - (Vec::new(), self.children), - |(mut chain, mut children), _| { - let only = children.remove(0); - chain.push(only.row.label); - (chain, only.children) - }, - ); - self.row.chain = chain; - self.children = below; - } - self.children = self - .children - .into_iter() - .map(|child| child.fold(true)) - .collect(); - self - } - fn flatten_into(self, depth: usize, rows: &mut Vec) { rows.push(TreeRow { depth, ..self.row }); self.children @@ -906,24 +820,13 @@ impl TreeNode { } } -fn grow_forest(rows: &mut Peekable>, depth: usize) -> Vec { - iter::from_fn(|| { - let row = rows.next_if(|row| row.depth == depth)?; - Some(TreeNode { - row, - children: grow_forest(rows, depth + 1), - }) - }) - .collect() -} - #[must_use] -pub fn fold_chains(rows: Vec) -> Vec { - let mut flattened = Vec::new(); - grow_forest(&mut rows.into_iter().peekable(), 0) +pub fn flatten_forest(forest: Vec) -> Vec { + let mut rows = Vec::new(); + forest .into_iter() - .for_each(|root| root.fold(false).flatten_into(0, &mut flattened)); - flattened + .for_each(|root| root.flatten_into(0, &mut rows)); + rows } fn labelled_by_description(facts: &UnitFacts) -> bool { @@ -958,30 +861,16 @@ fn summary(facts: &UnitFacts) -> String { mod tests { use super::*; use crate::boot_test_fixtures::{ - MS, activating, facts, queue_unit, queued_boot, running, tree_outline, waiting, + MS, activating, facts, nested_boot_sample as sample, queue_unit, queued_boot, tree_outline, + waiting, }; - fn sample() -> BootState { - queued_boot( - Phase::Host, - 500 * MS, - [ - waiting("graphical.target", &["multi-user.target"]), - waiting( - "multi-user.target", - &["docker.service", "nm-wait.service", "basic.target"], - ), - waiting("nm-wait.service", &["nm.service"]), - running("nm.service", &[], 1000 * MS), - running("docker.service", &["containerd.service"], 3000 * MS), - waiting("containerd.service", &[]), - waiting("basic.target", &[]), - ], - ) + fn rows(state: &BootState) -> Vec { + flatten_forest(state.waiting_forest(Duration::MAX)) } fn outline(state: &BootState) -> Vec { - tree_outline(&state.tree_rows(Duration::MAX)) + tree_outline(&rows(state)) } #[test] @@ -1000,41 +889,6 @@ mod tests { ); } - #[test] - fn only_chains_leading_to_running_units_stay_in_view() { - assert_eq!( - tree_outline(&fit_to_height(sample().tree_rows(Duration::MAX), 0)), - [ - "basic.target", - "multi-user.target", - " docker", - " nm-wait", - " nm", - "graphical.target", - ] - ); - } - - #[test] - fn spare_rows_bring_back_waiting_units_under_kept_parents() { - let state = chain_state( - &[ - ("root.target", &["a.service", "b.service"]), - ("a.service", &["a1.service"]), - ("a1.service", &["a2.service"]), - ("a2.service", &[]), - ("b.service", &[]), - ], - "b.service", - ); - let outline = |budget| tree_outline(&fit_to_height(state.tree_rows(Duration::MAX), budget)); - assert_eq!(outline(4), ["root.target", " b", " a"]); - assert_eq!( - outline(5), - ["root.target", " b", " a", " a1", " a2"] - ); - } - #[test] fn a_unit_sits_in_the_earliest_stage_that_waits_on_it() { let state = queued_boot( @@ -1082,92 +936,6 @@ mod tests { assert_eq!(described("demo.service", ""), ""); } - fn chain_state(waits: &[(&str, &[&str])], running_unit: &str) -> BootState { - queued_boot( - Phase::Host, - Duration::ZERO, - waits.iter().map(|(name, after)| { - if *name == running_unit { - running(name, after, Duration::ZERO) - } else { - waiting(name, after) - } - }), - ) - } - - fn folded_outline(state: &BootState) -> Vec { - tree_outline(&fold_chains(fit_to_height( - state.tree_rows(Duration::MAX), - 0, - ))) - } - - #[test] - fn single_child_waiting_chains_fold_into_one_row() { - let state = chain_state( - &[ - ("root.target", &["a.service"]), - ("a.service", &["b.target"]), - ("b.target", &["c.service"]), - ("c.service", &["d.service"]), - ("d.service", &[]), - ], - "d.service", - ); - assert_eq!( - folded_outline(&state), - ["root.target", " a > b.target > c", " d"] - ); - } - - #[test] - fn branches_and_short_chains_stay_unfolded() { - let state = chain_state( - &[ - ("root.target", &["a.service"]), - ("a.service", &["b.service", "c.service"]), - ("b.service", &["d.service"]), - ("c.service", &[]), - ("d.service", &[]), - ], - "d.service", - ); - let mut both = chain_state( - &[ - ("root.target", &["a.service"]), - ("a.service", &["b.service", "c.service"]), - ("b.service", &[]), - ("c.service", &[]), - ], - "b.service", - ); - both.update_activity("c.service", activating(Duration::ZERO)); - assert_eq!( - folded_outline(&state), - ["root.target", " a", " b", " d"] - ); - assert_eq!( - folded_outline(&both), - ["root.target", " a", " b", " c"] - ); - } - - #[test] - fn with_nothing_running_only_the_root_target_stays_in_view() { - let state = queued_boot( - Phase::Host, - Duration::ZERO, - [ - waiting("demo.target", &["idle.service"]), - waiting("idle.service", &[]), - ], - ); - let rows = fit_to_height(state.tree_rows(Duration::MAX), 0); - assert_eq!(rows.len(), 1); - assert_eq!(rows[0].label, "demo.target"); - } - #[test] fn finished_jobs_leave_the_tree_and_count_toward_their_milestone() { let mut state = sample(); @@ -1182,9 +950,9 @@ mod tests { active_exit: None, }, ); - let rows = state.tree_rows(Duration::MAX); assert!( - rows.iter() + rows(&state) + .iter() .all(|row| row.label != "containerd" && row.label != "basic.target") ); let milestones = state.milestones(); @@ -1264,7 +1032,7 @@ mod tests { ); assert_eq!(state.milestones()[0].reached_at, 2000 * MS); assert_eq!(state.tally().done, 2); - assert!(state.tree_rows(Duration::MAX).is_empty()); + assert!(rows(&state).is_empty()); } #[test] @@ -1274,10 +1042,7 @@ mod tests { Duration::ZERO, [waiting("dev-nvme1n1.device", &[]).described("Lexar SSD NM790 2TB")], ); - assert_eq!( - state.tree_rows(Duration::MAX)[0].label, - "Lexar SSD NM790 2TB" - ); + assert_eq!(rows(&state)[0].label, "Lexar SSD NM790 2TB"); } #[test] @@ -1354,7 +1119,7 @@ mod tests { }, ); assert_eq!( - state.tree_rows(Duration::MAX)[0].status, + rows(&state)[0].status, RowStatus::Running { queued_at: 1000 * MS, since: 1200 * MS @@ -1402,6 +1167,6 @@ mod tests { waiting("b.service", &["a.service"]), ], ); - assert_eq!(state.tree_rows(Duration::MAX).len(), 2); + assert_eq!(rows(&state).len(), 2); } } diff --git a/src/boot_test_fixtures.rs b/src/boot_test_fixtures.rs index 1d95fcd..b94c0d4 100644 --- a/src/boot_test_fixtures.rs +++ b/src/boot_test_fixtures.rs @@ -76,6 +76,25 @@ pub fn queued_boot( state } +pub fn nested_boot_sample() -> BootState { + queued_boot( + Phase::Host, + 500 * MS, + [ + waiting("graphical.target", &["multi-user.target"]), + waiting( + "multi-user.target", + &["docker.service", "nm-wait.service", "basic.target"], + ), + waiting("nm-wait.service", &["nm.service"]), + running("nm.service", &[], 1000 * MS), + running("docker.service", &["containerd.service"], 3000 * MS), + waiting("containerd.service", &[]), + waiting("basic.target", &[]), + ], + ) +} + pub fn queue_unit(state: &mut BootState, id: u32, unit: QueuedUnit, queued_at: Duration) { let name = unit.facts.name.clone(); state.track_unit(unit.facts, unit.activity); diff --git a/src/boot_view.rs b/src/boot_view.rs index 9d98ac0..9692609 100644 --- a/src/boot_view.rs +++ b/src/boot_view.rs @@ -1,6 +1,7 @@ mod run_timeline; mod screen_chrome; mod stage_summary; +mod tree_height_fitting; mod unit_tree; use std::time::Duration; @@ -21,10 +22,11 @@ use self::{ run_timeline::{RunningRun, Timeline}, screen_chrome::{FOOTER_HEIGHT, Footer, Header, PasswordPopup}, stage_summary::Stages, + tree_height_fitting::rows_within_height, unit_tree::UnitTree, }; use crate::{ - boot_model::{BootState, RowStatus, TreeRow, UnitKind, fit_to_height, fold_chains}, + boot_model::{BootState, RowStatus, TreeRow, UnitKind, flatten_forest}, boot_origin::BootOrigin, color_scheme::Colors, config_file::Timing, @@ -101,9 +103,10 @@ impl BootView<'_> { impl Widget for BootView<'_> { fn render(self, area: Rect, buf: &mut Buffer) { - let all_rows = self + let forest = self .state - .tree_rows(self.now.saturating_sub(self.timing.keep_finished_units_for)); + .waiting_forest(self.now.saturating_sub(self.timing.keep_finished_units_for)); + let all_rows = flatten_forest(forest.clone()); let pending_count = all_rows.len(); let header = Header { origin: self.origin, @@ -134,10 +137,7 @@ impl Widget for BootView<'_> { if fits_timeline { timeline.height() } else { 0 }, ); let budget = usize::from(heights.tree.saturating_sub(1)); - let rows = [all_rows.clone(), fold_chains(all_rows.clone())] - .into_iter() - .find(|rows| rows.len() <= budget) - .unwrap_or_else(|| fold_chains(fit_to_height(all_rows.clone(), budget))); + let rows = rows_within_height(&forest, budget); let tree = UnitTree { phase: stages.current_phase(), rows: &rows, diff --git a/src/boot_view/tree_height_fitting.rs b/src/boot_view/tree_height_fitting.rs new file mode 100644 index 0000000..54153ab --- /dev/null +++ b/src/boot_view/tree_height_fitting.rs @@ -0,0 +1,219 @@ +use crate::boot_model::{RowStatus, TreeNode, TreeRow, UnitKind, flatten_forest}; + +const MIN_FOLDED_LINKS: usize = 2; + +pub fn rows_within_height(forest: &[TreeNode], budget: usize) -> Vec { + [forest.to_vec(), fold_forest(forest.to_vec())] + .into_iter() + .map(flatten_forest) + .find(|rows| rows.len() <= budget) + .unwrap_or_else(|| { + let essential = flatten_forest(prune_to_running(forest.to_vec(), 0)).len(); + let spare = budget.saturating_sub(essential + 1); + flatten_forest(fold_forest(prune_to_running(forest.to_vec(), spare))) + }) +} + +fn fold_forest(forest: Vec) -> Vec { + forest.into_iter().map(|root| root.fold(false)).collect() +} + +fn prune_to_running(forest: Vec, mut spare: usize) -> Vec { + forest + .into_iter() + .filter_map(|root| { + let anchors_the_tree = root.row.kind == UnitKind::Target; + root.keep_on_paths_to_running(anchors_the_tree, &mut spare) + }) + .collect() +} + +impl TreeNode { + fn leads_to_running(&self) -> bool { + matches!( + self.row.status, + RowStatus::Running { .. } | RowStatus::Failed + ) || self.children.iter().any(Self::leads_to_running) + } + + fn keep_on_paths_to_running(self, anchored: bool, spare: &mut usize) -> Option { + if !anchored && !self.leads_to_running() { + *spare = spare.checked_sub(1)?; + } + Some(Self { + children: self + .children + .into_iter() + .filter_map(|child| child.keep_on_paths_to_running(false, spare)) + .collect(), + row: self.row, + }) + } + + fn is_chain_link(&self) -> bool { + self.row.status == RowStatus::Waiting && self.children.len() == 1 + } + + fn foldable_links(&self) -> usize { + let mut links = 0; + let mut cursor = self; + while cursor.is_chain_link() && cursor.children[0].is_chain_link() { + links += 1; + cursor = &cursor.children[0]; + } + links + } + + fn fold(mut self, may_absorb: bool) -> Self { + let links = if may_absorb { self.foldable_links() } else { 0 }; + if links >= MIN_FOLDED_LINKS { + let (chain, below) = (0..links).fold( + (Vec::new(), self.children), + |(mut chain, mut children), _| { + let only = children.remove(0); + chain.push(only.row.label); + (chain, only.children) + }, + ); + self.row.chain = chain; + self.children = below; + } + self.children = self + .children + .into_iter() + .map(|child| child.fold(true)) + .collect(); + self + } +} + +#[cfg(test)] +mod tests { + use std::time::Duration; + + use super::*; + use crate::{ + boot_model::{BootState, Phase}, + boot_test_fixtures::{ + activating, nested_boot_sample, queued_boot, running, tree_outline, waiting, + }, + }; + + fn chain_state(waits: &[(&str, &[&str])], running_unit: &str) -> BootState { + queued_boot( + Phase::Host, + Duration::ZERO, + waits.iter().map(|(name, after)| { + if *name == running_unit { + running(name, after, Duration::ZERO) + } else { + waiting(name, after) + } + }), + ) + } + + fn fitted_outline(state: &BootState, budget: usize) -> Vec { + tree_outline(&rows_within_height( + &state.waiting_forest(Duration::MAX), + budget, + )) + } + + #[test] + fn only_chains_leading_to_running_units_stay_in_view() { + assert_eq!( + fitted_outline(&nested_boot_sample(), 0), + [ + "basic.target", + "multi-user.target", + " docker", + " nm-wait", + " nm", + "graphical.target", + ] + ); + } + + #[test] + fn spare_rows_bring_back_waiting_units_under_kept_parents() { + let state = chain_state( + &[ + ("root.target", &["a.service", "b.service"]), + ("a.service", &["a1.service"]), + ("a1.service", &["a2.service"]), + ("a2.service", &[]), + ("b.service", &[]), + ], + "b.service", + ); + assert_eq!(fitted_outline(&state, 4), ["root.target", " b", " a"]); + assert_eq!( + fitted_outline(&state, 5), + ["root.target", " b", " a", " a1", " a2"] + ); + } + + #[test] + fn single_child_waiting_chains_fold_into_one_row() { + let state = chain_state( + &[ + ("root.target", &["a.service"]), + ("a.service", &["b.target"]), + ("b.target", &["c.service"]), + ("c.service", &["d.service"]), + ("d.service", &[]), + ], + "d.service", + ); + assert_eq!( + fitted_outline(&state, 0), + ["root.target", " a > b.target > c", " d"] + ); + } + + #[test] + fn branches_and_short_chains_stay_unfolded() { + let state = chain_state( + &[ + ("root.target", &["a.service"]), + ("a.service", &["b.service", "c.service"]), + ("b.service", &["d.service"]), + ("c.service", &[]), + ("d.service", &[]), + ], + "d.service", + ); + let mut both = chain_state( + &[ + ("root.target", &["a.service"]), + ("a.service", &["b.service", "c.service"]), + ("b.service", &[]), + ("c.service", &[]), + ], + "b.service", + ); + both.update_activity("c.service", activating(Duration::ZERO)); + assert_eq!( + fitted_outline(&state, 0), + ["root.target", " a", " b", " d"] + ); + assert_eq!( + fitted_outline(&both, 0), + ["root.target", " a", " b", " c"] + ); + } + + #[test] + fn with_nothing_running_only_the_root_target_stays_in_view() { + let state = queued_boot( + Phase::Host, + Duration::ZERO, + [ + waiting("demo.target", &["idle.service"]), + waiting("idle.service", &[]), + ], + ); + assert_eq!(fitted_outline(&state, 0), ["demo.target"]); + } +}