fix: add luks prompt to fix broken on external keyboard

This commit is contained in:
Willem Vanhulle committed 2026-10-14 18:44:08 +02:00
1 parent 0c30e71261
commit d0bffd5dac
19 files changed
+574 -105

No files matched your search

+57
View File
@@ -0,0 +1,57 @@
use std::time::Duration;
use serde::Deserialize;
use crate::palette::Palette;
#[derive(Clone, Copy, Debug, Default, Deserialize, PartialEq, Eq)]
#[serde(default, deny_unknown_fields)]
pub struct Config {
pub palette: Palette,
pub timing: Timing,
}
#[derive(Clone, Copy, Debug, Deserialize, PartialEq, Eq)]
#[serde(default, deny_unknown_fields)]
pub struct Timing {
#[serde(with = "jiff::fmt::serde::unsigned_duration::friendly::compact::required")]
pub keep_finished_units_for: Duration,
#[serde(with = "jiff::fmt::serde::unsigned_duration::friendly::compact::required")]
pub hide_runs_shorter_than: Duration,
#[serde(with = "jiff::fmt::serde::unsigned_duration::friendly::compact::required")]
pub keep_final_frame_for: Duration,
}
impl Default for Timing {
fn default() -> Self {
Self {
keep_finished_units_for: Duration::from_secs(2),
hide_runs_shorter_than: Duration::from_secs(1),
keep_final_frame_for: Duration::from_secs(1),
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn timing_reads_friendly_durations_and_keeps_unset_defaults() {
let config: Config = toml::from_str("[timing]\nkeep_finished_units_for = \"500ms\"\n")
.expect("valid config");
assert_eq!(
config.timing.keep_finished_units_for,
Duration::from_millis(500)
);
assert_eq!(
config.timing.keep_final_frame_for,
Timing::default().keep_final_frame_for
);
}
#[test]
fn nonsense_durations_are_rejected() {
assert!(toml::from_str::<Config>("[timing]\nkeep_final_frame_for = \"soon\"\n").is_err());
}
}
+19 -36
View File
@@ -8,6 +8,8 @@ use rustix::{
termios::ttyname,
};
use crate::password;
const GIO_UNIMAP: Opcode = 0x4B66;
const VT_GETSTATE: Opcode = 0x5603;
const VT_ACTIVATE: Opcode = 0x5606;
@@ -15,56 +17,44 @@ const VT_WAITACTIVE: Opcode = 0x5607;
const VIRTUAL_TERMINAL_PREFIX: &str = "/dev/tty";
const KERNEL_PRINTK: &str = "/proc/sys/kernel/printk";
const ALERTS_ONLY: &str = "1";
const PASSWORD_REQUESTS: &str = "/run/systemd/ask-password";
const PASSWORD_REQUEST_PREFIX: &str = "ask.";
pub struct Console {
quiet_kernel: Option<QuietKernelConsole>,
foreground: Option<ForegroundVt>,
yields_to_password_prompts: bool,
for_system: bool,
pub glyphs: Glyphs,
}
impl Console {
pub fn take(for_system: bool) -> Self {
let prompt_showing = for_system && password_requested();
let prompt_elsewhere = for_system && password::requested();
if prompt_elsewhere {
eprintln!("bootvine: a password prompt is already showing, staying behind it");
}
Self {
quiet_kernel: for_system.then(QuietKernelConsole::take).flatten(),
foreground: if prompt_showing {
foreground: if prompt_elsewhere {
None
} else {
ForegroundVt::take()
},
yields_to_password_prompts: for_system,
for_system,
glyphs: font_glyphs(),
}
}
pub fn make_way_for_password_prompts(&mut self) {
if !self.yields_to_password_prompts {
return;
}
if password_requested() {
self.step_aside();
} else {
self.come_forward();
}
pub fn answers_password_prompts(&self) -> bool {
self.for_system && self.foreground.is_some()
}
fn step_aside(&mut self) {
if self.foreground.take().is_some() {
eprintln!("bootvine: stepping aside for a password prompt");
}
}
fn come_forward(&mut self) {
if self.foreground.is_some() {
return;
pub fn come_forward_once_prompts_are_gone(&mut self) -> bool {
if !self.for_system || self.foreground.is_some() || password::requested() {
return false;
}
self.foreground = ForegroundVt::take();
if self.foreground.is_some() {
eprintln!("bootvine: password prompt answered, taking the console back");
}
self.foreground.is_some()
}
pub fn keep_up(&mut self) {
@@ -101,17 +91,6 @@ impl QuietKernelConsole {
}
}
fn password_requested() -> bool {
fs::read_dir(PASSWORD_REQUESTS).is_ok_and(|entries| {
entries.flatten().any(|entry| {
entry
.file_name()
.to_string_lossy()
.starts_with(PASSWORD_REQUEST_PREFIX)
})
})
}
fn font_glyphs() -> Glyphs {
font_characters().map_or_else(Glyphs::default, |characters| {
Glyphs::fitting(|symbol| symbol.is_ascii() || characters.contains(&symbol))
@@ -199,6 +178,10 @@ impl ForegroundVt {
impl Drop for ForegroundVt {
fn drop(&mut self) {
if password::requested() {
eprintln!("bootvine: leaving a password prompt to the console agent on this terminal");
return;
}
let _ = activate(self.previous);
}
}
+1
View File
@@ -1,3 +1,4 @@
pub mod config;
pub mod glyphs;
pub mod model;
pub mod origin;
+12 -13
View File
@@ -2,15 +2,16 @@ mod clock;
mod console;
mod error;
mod feed;
mod password;
mod run;
mod sysroot;
mod systemd;
use std::{fs, io::ErrorKind, path::PathBuf, process::ExitCode, time::Duration};
use bootvine::palette::Config;
use bootvine::config::{Config, Timing};
use clap::Parser;
use jiff::SignedDuration;
use jiff::fmt::friendly::SpanParser;
use crate::{
run::{Options, run},
@@ -34,24 +35,19 @@ struct Cli {
target: Option<String>,
#[arg(
long,
default_value = "1s",
value_parser = parse_duration,
help = "How long the final frame stays on screen, e.g. 1s or 500ms"
value_parser = |raw: &str| SpanParser::new().parse_unsigned_duration(raw),
help = "How long the final frame stays on screen, e.g. 1s or 500ms; overrides \
timing.keep_final_frame_for"
)]
hold: Duration,
hold: Option<Duration>,
#[arg(
long,
default_value = "/etc/bootvine.toml",
help = "TOML file with a [palette] table"
help = "TOML file with [palette] and [timing] tables"
)]
config: PathBuf,
}
fn parse_duration(raw: &str) -> Result<Duration, String> {
let signed: SignedDuration = raw.parse().map_err(|error| format!("{error}"))?;
Duration::try_from(signed).map_err(|error| format!("{error}"))
}
fn main() -> ExitCode {
let cli = Cli::parse();
let config = match fs::read_to_string(&cli.config) {
@@ -69,7 +65,10 @@ fn main() -> ExitCode {
scope: if cli.user { Scope::User } else { Scope::System },
shutdown: cli.shutdown,
target: cli.target,
hold: cli.hold,
timing: Timing {
keep_final_frame_for: cli.hold.unwrap_or(config.timing.keep_final_frame_for),
..config.timing
},
palette: config.palette,
};
match run(&options) {
+29 -15
View File
@@ -588,12 +588,17 @@ impl BootState {
}
#[must_use]
pub fn tree_rows(&self) -> Vec<TreeRow> {
pub fn tree_rows(&self, finished_since: Duration) -> Vec<TreeRow> {
let pending: HashSet<&str> = self
.units
.iter()
.filter(|(name, record)| {
let finished_recently = matches!(
record.outcome,
Some(Outcome::Succeeded { at }) if at >= finished_since
);
record.job.is_some()
|| finished_recently
|| record.outcome == Some(Outcome::Failed)
|| (self.is_milestone(name) && record.outcome.is_some())
})
@@ -752,6 +757,9 @@ impl BootState {
let record = &self.units[name];
match (record.running_since(), record.outcome) {
(Some(since), _) => SiblingRank::RunningSince(since),
(None, Some(Outcome::Succeeded { at })) => {
SiblingRank::RunningSince(record.inactive_exit.unwrap_or(at))
}
(None, Some(Outcome::Failed)) => SiblingRank::Failed,
(None, _) => SiblingRank::Waiting,
}
@@ -1035,7 +1043,7 @@ mod tests {
#[test]
fn pending_units_nest_under_what_waits_on_them() {
let outline: Vec<String> = sample()
.tree_rows()
.tree_rows(Duration::MAX)
.into_iter()
.map(|row| format!("{}{}", " ".repeat(row.depth), row.label))
.collect();
@@ -1055,7 +1063,7 @@ mod tests {
#[test]
fn only_chains_leading_to_running_units_stay_in_view() {
let rows = fit_to_height(sample().tree_rows(), 0);
let rows = fit_to_height(sample().tree_rows(Duration::MAX), 0);
let outline: Vec<String> = rows
.iter()
.map(|row| format!("{}{}", " ".repeat(row.depth), row.label))
@@ -1091,7 +1099,7 @@ mod tests {
"b.service",
);
let outline = |budget| -> Vec<String> {
fit_to_height(state.tree_rows(), budget)
fit_to_height(state.tree_rows(Duration::MAX), budget)
.into_iter()
.map(|row| format!("{}{}", " ".repeat(row.depth), row.label))
.collect()
@@ -1124,7 +1132,7 @@ mod tests {
state.queue_job(id, &name, JobKind::BringsUp, Duration::ZERO);
});
let outline: Vec<String> = state
.tree_rows()
.tree_rows(Duration::MAX)
.into_iter()
.map(|row| format!("{}{}", " ".repeat(row.depth), row.label))
.collect();
@@ -1181,7 +1189,7 @@ mod tests {
}
fn folded_outline(state: &BootState) -> Vec<String> {
fold_chains(fit_to_height(state.tree_rows(), 0))
fold_chains(fit_to_height(state.tree_rows(Duration::MAX), 0))
.into_iter()
.map(|row| {
let chain = once(row.label.as_str())
@@ -1237,7 +1245,7 @@ mod tests {
folded_outline(&state),
["root.target", " a", " b", " d"]
);
let rows = fold_chains(fit_to_height(both.tree_rows(), 0));
let rows = fold_chains(fit_to_height(both.tree_rows(Duration::MAX), 0));
let lasts: Vec<bool> = rows
.iter()
.map(|row| *row.is_last_sibling.last().unwrap())
@@ -1253,7 +1261,7 @@ mod tests {
state.track_unit(facts("idle.service", &[]), Activity::default());
state.queue_job(1, "demo.target", JobKind::BringsUp, Duration::ZERO);
state.queue_job(2, "idle.service", JobKind::BringsUp, Duration::ZERO);
let rows = fit_to_height(state.tree_rows(), 0);
let rows = fit_to_height(state.tree_rows(Duration::MAX), 0);
assert_eq!(rows.len(), 1);
assert_eq!(rows[0].label, "demo.target");
}
@@ -1272,7 +1280,7 @@ mod tests {
active_exit: None,
},
);
let rows = state.tree_rows();
let rows = state.tree_rows(Duration::MAX);
assert!(
rows.iter()
.all(|row| row.label != "containerd" && row.label != "basic.target")
@@ -1338,7 +1346,7 @@ mod tests {
);
assert_eq!(state.milestones()[0].reached_at, Some(2000 * MS));
assert_eq!(state.tally().done, 2);
assert!(state.tree_rows().is_empty());
assert!(state.tree_rows(Duration::MAX).is_empty());
}
#[test]
@@ -1354,7 +1362,10 @@ mod tests {
Activity::default(),
);
state.queue_job(1, "dev-nvme1n1.device", JobKind::BringsUp, Duration::ZERO);
assert_eq!(state.tree_rows()[0].label, "Lexar SSD NM790 2TB");
assert_eq!(
state.tree_rows(Duration::MAX)[0].label,
"Lexar SSD NM790 2TB"
);
}
#[test]
@@ -1378,7 +1389,7 @@ mod tests {
state.queue_job(id, &name, JobKind::BringsUp, Duration::ZERO);
});
let outline: Vec<String> = state
.tree_rows()
.tree_rows(Duration::MAX)
.into_iter()
.map(|row| format!("{}{}", " ".repeat(row.depth), row.label))
.collect();
@@ -1394,7 +1405,7 @@ mod tests {
fn outline(state: &BootState) -> Vec<String> {
state
.tree_rows()
.tree_rows(Duration::MAX)
.into_iter()
.map(|row| format!("{}{}", " ".repeat(row.depth), row.label))
.collect()
@@ -1478,7 +1489,10 @@ mod tests {
..Activity::default()
},
);
assert_eq!(state.tree_rows()[0].running_since, Some(1200 * MS));
assert_eq!(
state.tree_rows(Duration::MAX)[0].running_since,
Some(1200 * MS)
);
state.finish_job(1, JobResult::Done, 1700 * MS);
assert_eq!(
state.finished_runs,
@@ -1517,6 +1531,6 @@ mod tests {
state.track_unit(facts("b.service", &["a.service"]), Activity::default());
state.queue_job(1, "a.service", JobKind::BringsUp, Duration::ZERO);
state.queue_job(2, "b.service", JobKind::BringsUp, Duration::ZERO);
assert_eq!(state.tree_rows().len(), 2);
assert_eq!(state.tree_rows(Duration::MAX).len(), 2);
}
}
-6
View File
@@ -26,9 +26,3 @@ impl Default for Palette {
}
}
}
#[derive(Clone, Copy, Debug, Default, Deserialize, PartialEq, Eq)]
#[serde(default, deny_unknown_fields)]
pub struct Config {
pub palette: Palette,
}
+252
View File
@@ -0,0 +1,252 @@
use std::{
fs, io,
os::unix::net::UnixDatagram,
path::{Path, PathBuf},
time::Duration,
};
use bootvine::view::PasswordPrompt;
use crossterm::event::{Event, KeyCode, KeyEvent, KeyEventKind, KeyModifiers};
use rustix::process::{Pid, test_kill_process};
use zeroize::Zeroizing;
use crate::clock::monotonic_now;
const REQUESTS: &str = "/run/systemd/ask-password";
const REQUEST_PREFIX: &str = "ask.";
const ASK_SECTION: &str = "[Ask]";
const ROOM_FOR_TYPING: usize = 512;
#[derive(Debug, PartialEq, Eq)]
pub struct PasswordRequest {
pub file: PathBuf,
pub message: String,
socket: PathBuf,
echo: bool,
silent: bool,
not_after: Option<Duration>,
asker: Option<Pid>,
}
pub fn requested() -> bool {
!request_files().is_empty()
}
fn request_files() -> Vec<PathBuf> {
let mut files: Vec<PathBuf> = fs::read_dir(REQUESTS)
.into_iter()
.flatten()
.flatten()
.filter(|entry| {
entry
.file_name()
.to_string_lossy()
.starts_with(REQUEST_PREFIX)
})
.map(|entry| entry.path())
.collect();
files.sort();
files
}
impl PasswordRequest {
fn first_live() -> Option<Self> {
request_files()
.iter()
.filter_map(|file| Self::read(file))
.find(Self::is_live)
}
fn read(file: &Path) -> Option<Self> {
Self::parse(file, &fs::read_to_string(file).ok()?)
}
fn parse(file: &Path, text: &str) -> Option<Self> {
let fields: Vec<(&str, &str)> = text
.lines()
.map(str::trim)
.skip_while(|line| *line != ASK_SECTION)
.skip(1)
.take_while(|line| !line.starts_with('['))
.filter_map(|line| line.split_once('='))
.collect();
let field = |key: &str| {
fields
.iter()
.find(|(name, _)| *name == key)
.map(|(_, value)| *value)
};
let flag = |key: &str| field(key).is_some_and(is_true);
Some(Self {
file: file.to_owned(),
message: field("Message").unwrap_or_default().to_owned(),
socket: PathBuf::from(field("Socket")?),
echo: flag("Echo"),
silent: flag("Silent"),
not_after: field("NotAfter")
.and_then(|value| value.parse().ok())
.filter(|micros| *micros > 0)
.map(Duration::from_micros),
asker: field("PID")
.and_then(|value| value.parse().ok())
.and_then(Pid::from_raw),
})
}
fn is_live(&self) -> bool {
self.file.exists()
&& self
.not_after
.is_none_or(|deadline| monotonic_now() <= deadline)
&& self
.asker
.is_none_or(|asker| test_kill_process(asker).is_ok())
}
fn answer(&self, password: &str) -> io::Result<()> {
let mut packet = Zeroizing::new(Vec::with_capacity(password.len() + 1));
packet.push(b'+');
packet.extend_from_slice(password.as_bytes());
UnixDatagram::unbound()?.send_to(&packet, &self.socket)?;
Ok(())
}
}
fn is_true(value: &str) -> bool {
matches!(
value.to_ascii_lowercase().as_str(),
"1" | "yes" | "y" | "true" | "t" | "on"
)
}
pub struct PasswordEntry {
request: PasswordRequest,
typed: Zeroizing<String>,
sent: bool,
}
impl PasswordEntry {
pub fn follow(current: Option<Self>) -> Option<Self> {
if let Some(entry) = current.filter(|entry| entry.request.is_live()) {
return Some(entry);
}
let request = PasswordRequest::first_live()?;
eprintln!(
"bootvine: asking for a password: {}",
request.file.display()
);
Some(Self {
request,
typed: Zeroizing::new(String::with_capacity(ROOM_FOR_TYPING)),
sent: false,
})
}
pub fn prompt(&self) -> PasswordPrompt<'_> {
let input = match (self.sent, self.request.echo, self.request.silent) {
(true, _, _) | (false, _, true) => String::new(),
(false, true, false) => self.typed.as_str().to_owned(),
(false, false, false) => "*".repeat(self.typed.chars().count()),
};
PasswordPrompt {
message: &self.request.message,
input,
sent: self.sent,
}
}
pub fn type_key(&mut self, event: &Event) -> io::Result<()> {
let Event::Key(KeyEvent {
code,
modifiers,
kind: KeyEventKind::Press,
..
}) = event
else {
return Ok(());
};
if self.sent {
return Ok(());
}
match code {
KeyCode::Enter => {
self.request.answer(&self.typed)?;
self.sent = true;
self.typed.clear();
eprintln!("bootvine: answered a password prompt");
}
KeyCode::Backspace => {
self.typed.pop();
}
KeyCode::Char('u') if modifiers.contains(KeyModifiers::CONTROL) => self.typed.clear(),
KeyCode::Char(_) if modifiers.contains(KeyModifiers::CONTROL) => {}
KeyCode::Char(character)
if self.typed.len() + character.len_utf8() <= ROOM_FOR_TYPING =>
{
self.typed.push(*character);
}
_ => {}
}
Ok(())
}
}
#[cfg(test)]
mod tests {
use super::*;
const CRYPTSETUP_ASK: &str = concat!(
"[Ask]\n",
"PID=1\n",
"Socket=/run/systemd/ask-password/sck.1\n",
"AcceptCached=1\n",
"Echo=0\n",
"NotAfter=0\n",
"Message=Please enter passphrase for disk secret:\n",
"Icon=drive-harddisk\n",
"Id=cryptsetup:/dev/vdb\n",
);
#[test]
fn reads_what_cryptsetup_asks() {
let request = PasswordRequest::parse(Path::new("ask.x"), CRYPTSETUP_ASK).expect("parsed");
assert_eq!(
request,
PasswordRequest {
file: PathBuf::from("ask.x"),
message: "Please enter passphrase for disk secret:".to_owned(),
socket: PathBuf::from("/run/systemd/ask-password/sck.1"),
echo: false,
silent: false,
not_after: None,
asker: Pid::from_raw(1),
}
);
}
#[test]
fn ignores_requests_without_a_socket() {
assert_eq!(
PasswordRequest::parse(Path::new("ask.x"), "[Ask]\nMessage=hi\n"),
None
);
}
#[test]
fn hides_what_is_typed() {
let mut entry = PasswordEntry {
request: PasswordRequest::parse(Path::new("ask.x"), CRYPTSETUP_ASK).expect("parsed"),
typed: Zeroizing::new(String::new()),
sent: false,
};
"secret".chars().for_each(|character| {
entry
.type_key(&Event::Key(KeyEvent::from(KeyCode::Char(character))))
.expect("typed");
});
entry
.type_key(&Event::Key(KeyEvent::from(KeyCode::Backspace)))
.expect("erased");
assert_eq!(entry.prompt().input, "*****");
}
}
+28 -7
View File
@@ -9,6 +9,7 @@ use std::{
};
use bootvine::{
config::Timing,
model::{BootState, Phase},
origin::BootOrigin,
palette::Palette,
@@ -27,6 +28,7 @@ use crate::{
console::Console,
error::Error,
feed::Feed,
password::PasswordEntry,
sysroot::INITRD_RELEASE,
systemd::{Scope, Session},
};
@@ -38,7 +40,7 @@ pub struct Options {
pub scope: Scope,
pub shutdown: bool,
pub target: Option<String>,
pub hold: Duration,
pub timing: Timing,
pub palette: Palette,
}
@@ -71,7 +73,7 @@ pub fn run(options: &Options) -> Result<(), Error> {
&terminate,
&options.palette,
&mut console,
options.hold,
&options.timing,
);
ratatui::restore();
watched
@@ -110,20 +112,28 @@ fn watch(
terminate: &AtomicBool,
palette: &Palette,
console: &mut Console,
hold: Duration,
timing: &Timing,
) -> Result<(), Error> {
let mut origin = BootOrigin::read();
let mut origin_phase = state.phase;
let mut frame: u64 = 0;
let mut painted_connections = feed.connections;
let mut last_full_repaint = Instant::now();
let mut password_entry: Option<PasswordEntry> = None;
loop {
feed.pump(state, FRAME_INTERVAL)?;
if state.phase != origin_phase {
origin = BootOrigin::read();
origin_phase = state.phase;
}
console.make_way_for_password_prompts();
if console.come_forward_once_prompts_are_gone() {
terminal.clear()?;
}
password_entry = if console.answers_password_prompts() {
PasswordEntry::follow(password_entry.take())
} else {
None
};
let repaint_due = feed.connections != painted_connections
|| last_full_repaint.elapsed() >= FULL_REPAINT_INTERVAL;
if repaint_due {
@@ -134,10 +144,12 @@ fn watch(
BootView {
state,
palette,
timing,
glyphs: &console.glyphs,
now: monotonic_now(),
origin: &origin,
frame,
password_prompt: password_entry.as_ref().map(PasswordEntry::prompt),
},
canvas.area(),
);
@@ -153,14 +165,23 @@ fn watch(
"bootvine: {} reached, handing the console over",
state.root.as_deref().unwrap_or("boot")
);
sleep(hold);
sleep(timing.keep_final_frame_for);
return Ok(());
}
if terminate.load(Ordering::Relaxed) {
return Ok(());
}
if event::poll(Duration::ZERO)? && asks_to_quit(&event::read()?) {
return Ok(());
while event::poll(Duration::ZERO)? {
let event = event::read()?;
match &mut password_entry {
Some(entry) => {
if let Err(error) = entry.type_key(&event) {
eprintln!("bootvine: cannot answer the password prompt: {error}");
}
}
None if asks_to_quit(&event) => return Ok(()),
None => {}
}
}
frame += 1;
}
+67 -6
View File
@@ -1,5 +1,6 @@
mod footer;
mod header;
mod prompt;
mod stages;
mod timeline;
mod tree;
@@ -16,8 +17,13 @@ use ratatui::{
use unicode_truncate::UnicodeTruncateStr;
use unicode_width::UnicodeWidthStr;
use self::{footer::Footer, header::Header, stages::Stages, timeline::Timeline, tree::UnitTree};
pub use self::prompt::PasswordPrompt;
use self::{
footer::Footer, header::Header, prompt::PasswordBar, stages::Stages, timeline::Timeline,
tree::UnitTree,
};
use crate::{
config::Timing,
glyphs::Glyphs,
model::{BootState, RowStatus, TreeRow, UnitKind, fit_to_height, fold_chains},
origin::BootOrigin,
@@ -28,7 +34,6 @@ const DURATION_WIDTH: u16 = 8;
const MIN_BAR_WIDTH: u16 = 12;
const MIN_HEIGHT_FOR_TIMELINE: u16 = 12;
const MIN_TIMELINE_HEIGHT: u16 = timeline::CHROME_HEIGHT + 4;
const NOTEWORTHY_DURATION: Duration = Duration::from_secs(1);
const HEADER_HEIGHT: u16 = 1;
const BRANCH: &str = "├─ ";
const LAST_BRANCH: &str = "└─ ";
@@ -44,10 +49,12 @@ const ELAPSED: SpanPrinter = SpanPrinter::new()
pub struct BootView<'a> {
pub state: &'a BootState,
pub palette: &'a Palette,
pub timing: &'a Timing,
pub glyphs: &'a Glyphs,
pub now: Duration,
pub origin: &'a BootOrigin,
pub frame: u64,
pub password_prompt: Option<PasswordPrompt<'a>>,
}
impl BootView<'_> {
@@ -76,7 +83,10 @@ impl BootView<'_> {
.state
.finished_runs
.iter()
.filter(|run| run.finished_at.saturating_sub(run.started_at) >= NOTEWORTHY_DURATION)
.filter(|run| {
run.finished_at.saturating_sub(run.started_at)
>= self.timing.hide_runs_shorter_than
})
.collect(),
running,
palette: self.palette,
@@ -87,7 +97,9 @@ impl BootView<'_> {
impl Widget for BootView<'_> {
fn render(self, area: Rect, buf: &mut Buffer) {
let all_rows = self.state.tree_rows();
let all_rows = self
.state
.tree_rows(self.now.saturating_sub(self.timing.keep_finished_units_for));
let pending_count = all_rows.len();
let pruned_rows = fold_chains(fit_to_height(all_rows.clone(), 0));
let header = Header {
@@ -107,6 +119,7 @@ impl Widget for BootView<'_> {
rows: &pruned_rows,
hidden: pending_count - shown_units(&pruned_rows),
now: self.now,
hide_runs_shorter_than: self.timing.hide_runs_shorter_than,
frame: self.frame,
palette: self.palette,
glyphs: self.glyphs,
@@ -164,7 +177,15 @@ impl Widget for BootView<'_> {
if heights.timeline > 0 {
timeline.render(timeline_area, buf);
}
footer.render(footer_area, buf);
match &self.password_prompt {
Some(asking) => PasswordBar {
asking,
palette: self.palette,
glyphs: self.glyphs,
}
.render(footer_area, buf),
None => footer.render(footer_area, buf),
}
}
}
@@ -237,6 +258,7 @@ mod tests {
BootView {
state,
palette: &Palette::default(),
timing: &Timing::default(),
glyphs: &Glyphs::default(),
now,
origin: &BootOrigin {
@@ -246,6 +268,7 @@ mod tests {
kernel: "Linux 7.2.9".to_owned(),
},
frame: 1,
password_prompt: None,
},
frame.area(),
);
@@ -386,7 +409,7 @@ mod tests {
state.finish_job(3, JobResult::Failed, 1000 * MS);
state.finish_job(4, JobResult::Done, 1000 * MS);
state.finish_job(2, JobResult::Done, 1500 * MS);
let lines = render(&state, 3000 * MS, 110, 24);
let lines = render(&state, 5000 * MS, 110, 24);
let screen = lines.join("\n");
assert!(lines[2].starts_with(" ├─ √ basic.target"), "{screen}");
assert!(lines[3].starts_with(" │ └─ [×] flaky"), "{screen}");
@@ -398,6 +421,44 @@ mod tests {
assert!(!screen.contains("quick"), "{screen}");
}
#[test]
fn finished_units_linger_in_place_before_leaving() {
let mut state = BootState::new(Phase::Host);
state.set_root("multi-user.target".to_owned());
[
facts("multi-user.target", &["early.service", "late.service"]),
facts("early.service", &[]),
facts("late.service", &[]),
]
.into_iter()
.zip(1..)
.for_each(|(unit, id)| {
let name = unit.name.clone();
let activity = if name.ends_with(".service") {
running_since(Duration::ZERO)
} else {
Activity::default()
};
state.track_unit(unit, activity);
state.queue_job(id, &name, JobKind::BringsUp, Duration::ZERO);
});
state.finish_job(2, JobResult::Done, 3000 * MS);
let lingering = render(&state, 4000 * MS, 110, 24);
let screen = lingering.join("\n");
assert!(lingering[3].starts_with(" ├─ [√] early"), "{screen}");
assert!(lingering[4].starts_with(" └─ [/] late"), "{screen}");
let gone = render(&state, 5500 * MS, 110, 24);
let tree: Vec<&String> = gone
.iter()
.take_while(|line| !line.contains(" timeline "))
.collect();
assert!(
tree.iter().all(|line| !line.contains("early")),
"{}",
gone.join("\n")
);
}
#[test]
fn only_running_units_carry_a_timer() {
let lines = render(&boot_in_progress(), 12_400 * MS, 110, 24);
+41
View File
@@ -0,0 +1,41 @@
use ratatui::{
buffer::Buffer,
layout::Rect,
style::Stylize,
text::Line,
widgets::{Paragraph, Widget},
};
use super::rule;
use crate::{glyphs::Glyphs, palette::Palette};
pub struct PasswordPrompt<'a> {
pub message: &'a str,
pub input: String,
pub sent: bool,
}
pub struct PasswordBar<'a> {
pub asking: &'a PasswordPrompt<'a>,
pub palette: &'a Palette,
pub glyphs: &'a Glyphs,
}
impl Widget for PasswordBar<'_> {
fn render(self, area: Rect, buf: &mut Buffer) {
let status = if self.asking.sent {
format!(" checking{}", self.glyphs.ellipsis).fg(self.palette.waiting)
} else {
format!(" {}_", self.asking.input).fg(self.palette.text)
};
Paragraph::new(Line::from(vec![
self.asking.message.fg(self.palette.running).bold(),
status,
]))
.block(rule(
self.palette,
Line::from(" password ".fg(self.palette.running)),
))
.render(area, buf);
}
}
+5 -6
View File
@@ -9,10 +9,7 @@ use ratatui::{
};
use unicode_width::UnicodeWidthStr;
use super::{
BRANCH, DURATION_WIDTH, ELAPSED, ENDED_TRUNK, LAST_BRANCH, NOTEWORTHY_DURATION, PASSING_TRUNK,
fit_width,
};
use super::{BRANCH, DURATION_WIDTH, ELAPSED, ENDED_TRUNK, LAST_BRANCH, PASSING_TRUNK, fit_width};
use crate::{
glyphs::Glyphs,
model::{RowStatus, TreeRow, UnitKind},
@@ -29,6 +26,7 @@ pub struct UnitTree<'a> {
pub rows: &'a [TreeRow],
pub hidden: usize,
pub now: Duration,
pub hide_runs_shorter_than: Duration,
pub frame: u64,
pub palette: &'a Palette,
pub glyphs: &'a Glyphs,
@@ -105,7 +103,8 @@ impl UnitTree<'_> {
(_, _, RowStatus::Failed) => Style::from(self.palette.failed).bold(),
(_, UnitKind::Target, _) => self.palette.target.into(),
(_, _, RowStatus::Running) => self.palette.text.into(),
(_, _, RowStatus::Waiting | RowStatus::Done) => self.palette.waiting.into(),
(_, _, RowStatus::Waiting) => self.palette.waiting.into(),
(_, _, RowStatus::Done) => self.palette.muted.into(),
}
}
@@ -203,7 +202,7 @@ impl UnitTree<'_> {
let timer = row
.running_since
.map(|since| self.now.saturating_sub(since))
.filter(|running_for| *running_for >= NOTEWORTHY_DURATION)
.filter(|running_for| *running_for >= self.hide_runs_shorter_than)
.map(|running_for| ELAPSED.unsigned_duration_to_string(&running_for))
.unwrap_or_default();
let style = self.label_style(row, stage);