diff --git a/src/boot_model/job_ingestion.rs b/src/boot_model/job_ingestion.rs index ae727f0..48e25e6 100644 --- a/src/boot_model/job_ingestion.rs +++ b/src/boot_model/job_ingestion.rs @@ -293,7 +293,7 @@ mod tests { } #[test] - fn display_manager_activation_does_not_hand_the_console_over() { + 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()); diff --git a/src/console_session/watch_screen.rs b/src/console_session/watch_screen.rs index 51c4ab6..b328a8a 100644 --- a/src/console_session/watch_screen.rs +++ b/src/console_session/watch_screen.rs @@ -147,16 +147,20 @@ impl WatchScreen { { self.origin = origin; } - if !self.state.is_complete() { - return ControlFlow::Continue(()); + if self.state.display_manager_started() { + let display_manager = self + .state + .handoff_unit + .as_deref() + .unwrap_or("display manager"); + self.desk + .begin_handover(display_manager, now + self.timing.wait_for_display_manager); + } else if self.state.is_complete() { + self.desk.begin_handover( + self.state.root.unit().unwrap_or("boot"), + now + self.timing.keep_final_frame_for, + ); } - let hold_for = if self.state.display_manager_started() { - self.timing.wait_for_display_manager - } else { - self.timing.keep_final_frame_for - }; - self.desk - .begin_handover(self.state.root.unit().unwrap_or("boot"), now + hold_for); ControlFlow::Continue(()) } @@ -261,3 +265,84 @@ fn drop_bold(frame: &mut Buffer) { .iter_mut() .for_each(|cell| cell.modifier.remove(Modifier::BOLD)); } + +#[cfg(test)] +mod tests { + use super::*; + use crate::{ + boot_model::{ActiveState, Activity, HANDOFF_UNIT}, + demo_script::boot_test_fixtures::{MS, nested_boot_sample, queue_unit, waiting}, + }; + + #[derive(Default)] + struct HandoverRecorder { + glyphs: Glyphs, + handovers: Vec, + } + + impl ConsoleDesk for HandoverRecorder { + fn glyphs(&self) -> &Glyphs { + &self.glyphs + } + + fn drops_bold(&self) -> bool { + false + } + + fn prompt(&self, _now: Duration) -> Option> { + None + } + + fn press_key(&mut self, _event: &Event, _now: Duration) -> ControlFlow { + ControlFlow::Continue(()) + } + + fn frame_passed( + &mut self, + _state: &mut BootState, + _now: Duration, + ) -> ControlFlow { + ControlFlow::Continue(()) + } + + fn begin_handover(&mut self, reached: &str, _deadline: Duration) { + self.handovers.push(reached.to_owned()); + } + } + + fn screen_watching(state: BootState) -> WatchScreen { + let origin = BootOrigin { + host: "test".to_owned(), + system: None, + generation: None, + kernel: "Linux".to_owned(), + }; + WatchScreen::new( + state, + HandoverRecorder::default(), + origin, + Colors::default(), + Timing::default(), + Duration::ZERO, + ) + } + + #[test] + fn display_manager_start_hands_over_before_the_boot_completes() { + let mut state = nested_boot_sample(); + queue_unit(&mut state, 20, waiting(HANDOFF_UNIT, &[]), 500 * MS); + let mut screen = screen_watching(state); + let _ = screen.apply_boot_changes(Vec::new(), 1000 * MS); + assert!(screen.desk.handovers.is_empty()); + let started = BootChange::UpdateActivity { + unit: HANDOFF_UNIT.to_owned(), + activity: Activity { + state: Some(ActiveState::Active), + ..Activity::default() + }, + }; + let _ = screen.apply_boot_changes(vec![started], 6000 * MS); + assert!(!screen.state.is_complete()); + assert_eq!(screen.desk.handovers, [HANDOFF_UNIT]); + } +} diff --git a/src/systemd_link/systemd_bus.rs b/src/systemd_link/systemd_bus.rs index fdc682b..291aac6 100644 --- a/src/systemd_link/systemd_bus.rs +++ b/src/systemd_link/systemd_bus.rs @@ -389,7 +389,7 @@ fn parse_signal(message: &Message) -> Option { let member = message.member()?; match (&*interface, &*member) { (MANAGER_INTERFACE, "JobNew" | "JobRemoved") => parse_job_signal(message, &member), - (MANAGER_INTERFACE, "PropertiesChanged") => parse_manager_change(message), + (MANAGER_INTERFACE, "StartupFinished") => Some(Signal::BootFinished), (PROPERTIES_INTERFACE, "PropertiesChanged") => parse_unit_change(message), _ => None, } @@ -425,24 +425,6 @@ fn parse_unit_change(message: &Message) -> Option { }) } -fn parse_manager_change(message: &Message) -> Option { - let (changed_interface, changed, _invalidated): (String, PropMap, Vec) = - message.read3().ok()?; - if changed_interface != MANAGER_INTERFACE { - return None; - } - finish_timestamp(&changed) - .is_some() - .then_some(Signal::BootFinished) -} - -fn finish_timestamp(properties: &PropMap) -> Option { - properties - .get("FinishTimestampMonotonic") - .and_then(|value| value.0.as_u64()) - .filter(|micros| *micros != 0) -} - fn activity_from(properties: &PropMap) -> Activity { let monotonic = |property: &str| { properties @@ -461,3 +443,23 @@ fn activity_from(properties: &PropMap) -> Activity { active_exit: monotonic("ActiveExitTimestampMonotonic"), } } + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn startup_finished_signal_marks_the_boot_finished() { + let startup_finished = Message::signal( + &Path::from(MANAGER_PATH), + &MANAGER_INTERFACE.into(), + &"StartupFinished".into(), + ) + .append3(0_u64, 0_u64, 0_u64) + .append3(0_u64, 0_u64, 0_u64); + assert!(matches!( + parse_signal(&startup_finished), + Some(Signal::BootFinished) + )); + } +} diff --git a/tests/vm-checks/boot.nix b/tests/vm-checks/boot.nix index ee19522..768351a 100644 --- a/tests/vm-checks/boot.nix +++ b/tests/vm-checks/boot.nix @@ -17,6 +17,14 @@ settings.Manager.ShowStatus = lib.mkForce true; services.demo-db.serviceConfig.ExecStop = lib.mkForce (waitFor "release-demo-db"); services.backdoor.before = [ "demo-db.service" ]; + services.demo-late-sensor = { + wantedBy = [ "graphical.target" ]; + after = [ "greetd.service" ]; + serviceConfig = { + Type = "oneshot"; + ExecStart = waitFor "release-late-sensor"; + }; + }; }; virtualisation = { memorySize = 2048; diff --git a/tests/vm-checks/boot.py b/tests/vm-checks/boot.py index eb8f54b..e8bd0ee 100644 --- a/tests/vm-checks/boot.py +++ b/tests/vm-checks/boot.py @@ -23,6 +23,10 @@ assert console_level() == "1", f"stage 2 sysctl reopened the kernel console: {co machine.wait_for_unit("greetd.service") retry(lambda _: unit_state("bootvine") == "inactive", timeout_seconds=60) +assert unit_state("demo-late-sensor") == "activating", "the boot finished before the display manager took over" +assert foreground_terminal() != f"tty{BOOTVINE_TERMINAL}", "bootvine took the console back from the display manager" +machine.succeed("touch /run/release-late-sensor") +machine.wait_for_unit("graphical.target") journal = bootvine_journal() print(journal)