From d3fcd6f08524d1f8ac7a538138426e3c6bad748f Mon Sep 17 00:00:00 2001 From: Willem Vanhulle Date: Sun, 25 Oct 2026 13:17:27 +0100 Subject: [PATCH] refactor: drop single-use wrappers in the boot model, view and installer --- src/boot_model.rs | 2 - src/boot_model/boot_change.rs | 8 ++- src/boot_model/boot_projection.rs | 21 -------- src/boot_model/job_ingestion.rs | 39 +++++--------- src/boot_model/reached_milestones.rs | 67 ++++++++++-------------- src/boot_model/unit_facts.rs | 25 ++++----- src/boot_view.rs | 15 ++++-- src/boot_view/frame_cost_bench.rs | 4 +- src/console_session/watch_screen.rs | 11 ++-- src/main.rs | 33 +++--------- src/system_install/install_files.rs | 77 +++++++++++++++------------- 11 files changed, 121 insertions(+), 181 deletions(-) delete mode 100644 src/boot_model/boot_projection.rs diff --git a/src/boot_model.rs b/src/boot_model.rs index 749ba17..785c55a 100644 --- a/src/boot_model.rs +++ b/src/boot_model.rs @@ -1,6 +1,5 @@ mod boot_change; pub mod boot_origin; -mod boot_projection; mod job_ingestion; mod reached_milestones; mod unit_facts; @@ -10,7 +9,6 @@ use std::{collections::HashMap, time::Duration}; pub use self::{ boot_change::BootChange, - boot_projection::BootProjection, reached_milestones::MilestoneRow, unit_facts::{ActiveState, Activity, JobKind, JobResult, UnitFacts, UnitKind, UnitTimeouts}, waiting_tree::{RowStatus, TreeNode, TreeRow, flatten_forest}, diff --git a/src/boot_model/boot_change.rs b/src/boot_model/boot_change.rs index edbff13..1c63e08 100644 --- a/src/boot_model/boot_change.rs +++ b/src/boot_model/boot_change.rs @@ -43,12 +43,16 @@ impl BootState { BootChange::QueueJob { id, unit, kind, at } => self.queue_job(id, &unit, kind, at), BootChange::FinishJob { id, result, at } => self.finish_job(id, result, at), BootChange::SetRoot(root) => self.set_root(root), - BootChange::SetHandoff(unit) => self.set_handoff(unit), + BootChange::SetHandoff(unit) => { + if let Some(handoff) = &mut self.handoff_unit { + *handoff = unit; + } + } BootChange::SetOrigin(origin) => self.origin = origin, BootChange::SwitchRoot { at } => self.switch_root(at), BootChange::ForgetJobs => self.forget_jobs(), BootChange::ManagerExited { at } => self.manager_exited_at = Some(at), - BootChange::BootFinished => self.mark_boot_finished(), + BootChange::BootFinished => self.boot_finished = true, } } } diff --git a/src/boot_model/boot_projection.rs b/src/boot_model/boot_projection.rs deleted file mode 100644 index 708989e..0000000 --- a/src/boot_model/boot_projection.rs +++ /dev/null @@ -1,21 +0,0 @@ -use std::time::Duration; - -use super::{BootState, MilestoneRow, Tally, TreeNode}; - -#[derive(Clone, Debug)] -pub struct BootProjection { - pub forest: Vec, - pub milestones: Vec, - pub tally: Tally, -} - -impl BootState { - #[must_use] - pub fn project(&self, finished_since: Duration) -> BootProjection { - BootProjection { - forest: self.waiting_forest(finished_since), - milestones: self.milestones(), - tally: self.tally(), - } - } -} diff --git a/src/boot_model/job_ingestion.rs b/src/boot_model/job_ingestion.rs index 47fd2dd..0d8811a 100644 --- a/src/boot_model/job_ingestion.rs +++ b/src/boot_model/job_ingestion.rs @@ -103,16 +103,6 @@ impl BootState { } } - pub fn set_handoff(&mut self, unit: String) { - if self.handoff_unit.is_some() { - self.handoff_unit = Some(unit); - } - } - - pub fn mark_boot_finished(&mut self) { - self.boot_finished = true; - } - pub fn track_unit(&mut self, facts: UnitFacts, activity: Activity) { let record = self .units @@ -133,21 +123,20 @@ impl BootState { } pub fn queue_job(&mut self, id: u32, unit: &str, kind: JobKind, at: Duration) { - self.enqueue(id, unit, kind, at); - if kind == JobKind::BringsUp - && self.jobs.get(&id).is_some_and(|tracked| tracked == unit) + if self.enqueue(id, unit, kind, at) + && kind == JobKind::BringsUp && self.root == Root::Awaiting(unit.to_owned()) { self.root = Root::Queued(unit.to_owned()); } } - fn enqueue(&mut self, id: u32, unit: &str, kind: JobKind, at: Duration) { - if self.jobs.contains_key(&id) { - return; + fn enqueue(&mut self, id: u32, unit: &str, kind: JobKind, at: Duration) -> bool { + if let Some(tracked) = self.jobs.get(&id) { + return tracked == unit; } let Some(record) = self.units.get_mut(unit) else { - return; + return false; }; record.progress = Progress::Pending(PendingJob { id, @@ -155,6 +144,7 @@ impl BootState { kind, }); self.jobs.insert(id, unit.to_owned()); + true } pub fn finish_job(&mut self, id: u32, result: JobResult, at: Duration) { @@ -252,11 +242,6 @@ impl BootState { }) } - #[must_use] - pub fn display_manager_started(&self) -> bool { - self.started_display_manager().is_some() - } - #[must_use] pub fn tally(&self) -> Tally { let carried = Tally { @@ -287,7 +272,7 @@ impl BootState { mod tests { use super::*; use crate::{ - boot_model::{RowStatus, UnitTimeouts}, + boot_model::{BootChange, RowStatus, UnitTimeouts}, demo_script::boot_test_fixtures::{ MS, activating, facts, nested_boot_sample as sample, queue_unit, queued_boot, running, waiting, waiting_rows, @@ -335,24 +320,24 @@ mod tests { fn display_manager_activation_does_not_complete_the_boot() { let mut state = sample(); queue_unit(&mut state, 20, waiting(HANDOFF_UNIT, &[]), 500 * MS); - assert!(!state.display_manager_started()); + assert_eq!(state.started_display_manager(), None); state.update_activity(HANDOFF_UNIT, activating(6000 * MS)); assert!(!state.is_complete()); - assert!(state.display_manager_started()); + assert_eq!(state.started_display_manager(), Some(HANDOFF_UNIT)); } #[test] fn boot_finished_hands_the_console_over() { let mut state = sample(); queue_unit(&mut state, 20, waiting(HANDOFF_UNIT, &[]), 500 * MS); - state.mark_boot_finished(); + state.apply(BootChange::BootFinished); assert!(state.is_complete()); } #[test] fn boot_finished_is_ignored_in_the_initrd() { let mut state = BootState::new(Phase::Initrd); - state.mark_boot_finished(); + state.apply(BootChange::BootFinished); assert!(!state.is_complete()); } diff --git a/src/boot_model/reached_milestones.rs b/src/boot_model/reached_milestones.rs index 680445d..48cfa16 100644 --- a/src/boot_model/reached_milestones.rs +++ b/src/boot_model/reached_milestones.rs @@ -10,32 +10,11 @@ pub struct MilestoneRow { pub reached_at: Duration, } -struct ReachedMilestone<'a> { - target: &'a str, - reached_at: Duration, -} - -struct MilestoneWalk { - rows: Vec, +struct MilestoneCursor { 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 { let record = self.units.get(target)?; @@ -59,31 +38,41 @@ impl BootState { }) .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(), + let start = MilestoneCursor { previous: self .finished_stages .last() .map_or(self.origin, |stage| stage.reached_at), consumed: 0, }; - self.milestone_targets + let reached_rows = self + .milestone_targets .iter() - .filter_map(|target| { - self.milestone_reached_at(target) - .map(|reached_at| ReachedMilestone { target, reached_at }) + .scan(start, |cursor, target| { + Some(self.milestone_reached_at(target).map(|reached_at| { + let upto = succeeded.partition_point(|at| *at <= reached_at); + let row = MilestoneRow { + label: target.clone(), + finished_units: upto.saturating_sub(cursor.consumed), + started_at: cursor.previous.min(reached_at), + reached_at, + }; + cursor.consumed = cursor.consumed.max(upto); + cursor.previous = reached_at; + row + })) }) - .fold(start, |walk, reached| walk.advance(&reached, &succeeded)) - .rows + .flatten(); + 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, + }) + .chain(reached_rows) + .collect() } } diff --git a/src/boot_model/unit_facts.rs b/src/boot_model/unit_facts.rs index 5ea288a..d986ffc 100644 --- a/src/boot_model/unit_facts.rs +++ b/src/boot_model/unit_facts.rs @@ -113,25 +113,20 @@ impl UnitKind { Self::Scope => Some("Scope"), } } - - fn labelled_by_description(self) -> bool { - matches!( - self, - Self::Device | Self::Mount | Self::Swap | Self::Automount - ) - } } -fn labelled_by_description(facts: &UnitFacts) -> bool { - facts.description.is_some() && UnitKind::of(&facts.name).labelled_by_description() +fn description_label(facts: &UnitFacts) -> Option<&String> { + facts.description.as_ref().filter(|_| { + matches!( + UnitKind::of(&facts.name), + UnitKind::Device | UnitKind::Mount | UnitKind::Swap | UnitKind::Automount + ) + }) } pub(super) fn display_label(facts: &UnitFacts) -> String { - if labelled_by_description(facts) { - return facts - .description - .clone() - .unwrap_or_else(|| facts.name.clone()); + if let Some(description) = description_label(facts) { + return description.clone(); } match UnitKind::of(&facts.name) { UnitKind::Target | UnitKind::Other => facts.name.clone(), @@ -146,7 +141,7 @@ pub(super) fn summary(facts: &UnitFacts) -> Option { let repeats_the_name = facts.description.as_deref().is_some_and(|description| { description == facts.name || description.eq_ignore_ascii_case(&display_label(facts)) }); - if labelled_by_description(facts) || repeats_the_name { + if description_label(facts).is_some() || repeats_the_name { return None; } facts.description.clone() diff --git a/src/boot_view.rs b/src/boot_view.rs index d410641..488f292 100644 --- a/src/boot_view.rs +++ b/src/boot_view.rs @@ -35,7 +35,7 @@ use self::{ }; use crate::{ boot_model::{ - BootProjection, BootState, RowStatus, TreeRow, UnitKind, boot_origin::BootOrigin, + BootState, MilestoneRow, RowStatus, TreeNode, TreeRow, UnitKind, boot_origin::BootOrigin, flatten_forest, }, screen_settings::{color_scheme::Colors, config_file::Timing, font_glyphs::Glyphs}, @@ -136,7 +136,7 @@ impl Widget for BootView<'_> { }; let timeline = self.timeline(&all_rows); let footer = Footer { - tally: self.projection.tally, + tally: self.state.tally(), colors: &self.colors.footer, glyphs: self.glyphs, }; @@ -218,9 +218,18 @@ impl Heights { } } +#[derive(Clone, Debug)] +pub struct BootProjection { + pub forest: Vec, + pub milestones: Vec, +} + #[must_use] pub fn project_boot(state: &BootState, timing: &Timing, now: Duration) -> BootProjection { - state.project(now.saturating_sub(timing.keep_finished_units_for)) + BootProjection { + forest: state.waiting_forest(now.saturating_sub(timing.keep_finished_units_for)), + milestones: state.milestones(), + } } fn rule(color: Color, left: Line<'static>) -> Block<'static> { diff --git a/src/boot_view/frame_cost_bench.rs b/src/boot_view/frame_cost_bench.rs index edc864d..f2d1efd 100644 --- a/src/boot_view/frame_cost_bench.rs +++ b/src/boot_view/frame_cost_bench.rs @@ -6,9 +6,9 @@ use std::{ use ratatui::{Terminal, backend::TestBackend}; -use super::{BootView, project_boot, screen_render_fixtures::ryzen_origin}; +use super::{BootProjection, BootView, project_boot, screen_render_fixtures::ryzen_origin}; use crate::{ - boot_model::{BootProjection, BootState, JobResult, Phase, flatten_forest}, + boot_model::{BootState, JobResult, Phase, flatten_forest}, demo_script::boot_test_fixtures::{MS, QueuedUnit, queued_boot, running, waiting}, screen_settings::{color_scheme::Colors, config_file::Timing, font_glyphs::Glyphs}, }; diff --git a/src/console_session/watch_screen.rs b/src/console_session/watch_screen.rs index f4d2dfe..270b91d 100644 --- a/src/console_session/watch_screen.rs +++ b/src/console_session/watch_screen.rs @@ -9,8 +9,8 @@ use ratatui::{ }; use crate::{ - boot_model::{BootChange, BootProjection, BootState, boot_origin::BootOrigin}, - boot_view::{BootView, PasswordPrompt, project_boot}, + boot_model::{BootChange, BootState, boot_origin::BootOrigin}, + boot_view::{BootProjection, BootView, PasswordPrompt, project_boot}, console_session::console_palette::ConsoleLook, screen_settings::{color_scheme::Colors, config_file::Timing}, systemd_link::{link_error::Error, monotonic_clock::monotonic_now}, @@ -162,12 +162,7 @@ impl WatchScreen { if self.state.phase != phase_before { self.origin = (self.read_origin)(); } - if self.state.display_manager_started() { - let display_manager = self - .state - .handoff_unit - .as_deref() - .unwrap_or("display manager"); + if let Some(display_manager) = self.state.started_display_manager() { self.desk .begin_handover(display_manager, now + self.timing.wait_for_display_manager); } else if self.state.is_complete() { diff --git a/src/main.rs b/src/main.rs index 6b0ebc1..0ba8af1 100644 --- a/src/main.rs +++ b/src/main.rs @@ -92,8 +92,14 @@ enum DefaultsFormat { fn main() -> ExitCode { let cli = Cli::parse(); match cli.command { - Some(Command::Defaults(options)) => print_defaults(options.format), - Some(Command::Check(options)) => check_config_file(&options), + Some(Command::Defaults(options)) => report_outcome( + render_defaults(options.format).map(|text| println!("{}", text.trim_end())), + ), + Some(Command::Check(options)) => report_outcome( + read_config_file(&options.path) + .map(|_| ()) + .map_err(|error| format!("{}: {error}", options.path.display())), + ), Some(Command::Install(options)) => report_outcome(install_files(&options)), Some(Command::Uninstall(options)) => report_outcome(uninstall_files(&options)), None => watch_boot(cli.watch), @@ -118,29 +124,6 @@ fn render_defaults(format: DefaultsFormat) -> Result> { }) } -fn print_defaults(format: DefaultsFormat) -> ExitCode { - match render_defaults(format) { - Ok(text) => { - println!("{}", text.trim_end()); - ExitCode::SUCCESS - } - Err(error) => { - eprintln!("bootvine: {error}"); - ExitCode::FAILURE - } - } -} - -fn check_config_file(options: &CheckOptions) -> ExitCode { - match read_config_file(&options.path) { - Ok(_) => ExitCode::SUCCESS, - Err(error) => { - eprintln!("bootvine: {}: {error}", options.path.display()); - ExitCode::FAILURE - } - } -} - fn watch_boot(options: WatchOptions) -> ExitCode { let config = match read_config_file(&options.config) { Ok(config) => config, diff --git a/src/system_install/install_files.rs b/src/system_install/install_files.rs index 8ffd299..e5573a9 100644 --- a/src/system_install/install_files.rs +++ b/src/system_install/install_files.rs @@ -38,6 +38,8 @@ const DRACUT_MODULE_SETUP: &str = include_str!("../../system-files/dracut/90bootvine/module-setup.sh"); const MKINITCPIO_INSTALL_HOOK: &str = include_str!("../../system-files/mkinitcpio/install/sd-bootvine"); +const INITRD_GENERATORS: [InitrdGenerator; 2] = + [InitrdGenerator::Dracut, InitrdGenerator::Mkinitcpio]; #[derive(Args)] pub struct InstallTarget { @@ -114,16 +116,41 @@ impl InstallTarget { fn every_installed_path(&self) -> Vec { once(self.binary_path()) - .chain(unit_names().map(|unit| self.unit_path(unit))) - .chain([ - Path::new(DRACUT_MODULE_DIR).join("module-setup.sh"), - PathBuf::from(DRACUT_CONF), - PathBuf::from(MKINITCPIO_HOOK), - ]) + .chain(unit_files(self).map(|file| file.destination)) + .chain( + INITRD_GENERATORS + .into_iter() + .flat_map(initrd_hook_files) + .map(|file| file.destination), + ) .collect() } } +impl InitrdGenerator { + fn install_hint(self) -> Option<&'static str> { + match self { + Self::None => None, + Self::Dracut => Some("rebuild the initramfs: sudo dracut --force"), + Self::Mkinitcpio => Some( + "add sd-bootvine after systemd in HOOKS in /etc/mkinitcpio.conf, then run: sudo \ + mkinitcpio -P", + ), + } + } + + fn removal_hint(self) -> Option<&'static str> { + match self { + Self::None => None, + Self::Dracut => Some("rebuild the initramfs without bootvine: sudo dracut --force"), + Self::Mkinitcpio => Some( + "remove sd-bootvine from HOOKS in /etc/mkinitcpio.conf, then run: sudo mkinitcpio \ + -P", + ), + } + } +} + fn running_binary() -> Result { env::current_exe().map_err(|source| InstallError::File { path: PathBuf::from("/proc/self/exe"), @@ -131,14 +158,10 @@ fn running_binary() -> Result { }) } -fn is_running_binary(path: &Path, running: &Path) -> bool { - fs::canonicalize(path).is_ok_and(|resolved| resolved == running) -} - fn binary_file(target: &InstallTarget) -> Result, InstallError> { let running = running_binary()?; let destination = target.binary_path(); - if is_running_binary(&target.staged(&destination), &running) { + if fs::canonicalize(target.staged(&destination)).is_ok_and(|resolved| resolved == running) { return Ok(None); } let contents = fs::read(&running).map_err(|source| InstallError::File { @@ -244,17 +267,6 @@ fn rerun_with_sudo() -> Result<(), InstallError> { ) } -fn print_initramfs_hint(initrd: InitrdGenerator) { - match initrd { - InitrdGenerator::None => {} - InitrdGenerator::Dracut => println!("rebuild the initramfs: sudo dracut --force"), - InitrdGenerator::Mkinitcpio => println!( - "add sd-bootvine after systemd in HOOKS in /etc/mkinitcpio.conf, then run: sudo \ - mkinitcpio -P" - ), - } -} - pub fn install_files(options: &InstallOptions) -> Result<(), InstallError> { let target = &options.target; if target.needs_sudo() { @@ -270,25 +282,15 @@ pub fn install_files(options: &InstallOptions) -> Result<(), InstallError> { if !options.no_enable { systemctl(once("enable").chain(unit_names()))?; } - print_initramfs_hint(options.initrd); + if let Some(hint) = options.initrd.install_hint() { + println!("{hint}"); + } } Ok(()) } -fn print_initramfs_removal_hint(initrd: InitrdGenerator) { - match initrd { - InitrdGenerator::None => {} - InitrdGenerator::Dracut => { - println!("rebuild the initramfs without bootvine: sudo dracut --force"); - } - InitrdGenerator::Mkinitcpio => println!( - "remove sd-bootvine from HOOKS in /etc/mkinitcpio.conf, then run: sudo mkinitcpio -P" - ), - } -} - fn installed_initrd_hooks(target: &InstallTarget) -> Vec { - [InitrdGenerator::Dracut, InitrdGenerator::Mkinitcpio] + INITRD_GENERATORS .into_iter() .filter(|generator| { initrd_hook_files(*generator) @@ -330,7 +332,8 @@ pub fn uninstall_files(options: &UninstallOptions) -> Result<(), InstallError> { systemctl(["daemon-reload"])?; removed_initrd_hooks .into_iter() - .for_each(print_initramfs_removal_hint); + .filter_map(InitrdGenerator::removal_hint) + .for_each(|hint| println!("{hint}")); } Ok(()) }