From 0c30e712611075b372a585628b458dc88d611976 Mon Sep 17 00:00:00 2001 From: Willem Vanhulle Date: Wed, 14 Oct 2026 17:19:20 +0200 Subject: [PATCH] feat: better tree view --- Cargo.lock | 2 + Cargo.toml | 2 + demo/host.nix | 3 +- demo/units.nix | 16 +- demo/user-units.nix | 4 +- docs/initrd.png | Bin 4924 -> 5993 bytes docs/shutdown.png | Bin 4685 -> 14178 bytes docs/stage-2.png | Bin 9704 -> 10889 bytes examples/demo.rs | 56 ++++++- src/glyphs.rs | 8 + src/lib.rs | 1 + src/model.rs | 365 ++++++++++++++++++++++++++++++++++-------- src/origin.rs | 172 ++++++++++++++++++++ src/run.rs | 11 +- src/view.rs | 370 ++++++++++++++++++++++++++++++++----------- src/view/failures.rs | 40 ----- src/view/header.rs | 37 ++++- src/view/stages.rs | 115 +++++++------- src/view/timeline.rs | 21 ++- src/view/tree.rs | 268 ++++++++++++++++++++++++------- 20 files changed, 1148 insertions(+), 343 deletions(-) create mode 100644 src/origin.rs delete mode 100644 src/view/failures.rs diff --git a/Cargo.lock b/Cargo.lock index 8e3fa5d..8338184 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -155,6 +155,8 @@ dependencies = [ "serde", "signal-hook 0.4.5", "toml", + "unicode-truncate", + "unicode-width", ] [[package]] diff --git a/Cargo.toml b/Cargo.toml index 9b4d70d..8634706 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -18,6 +18,8 @@ rustix = { version = "1", features = ["fs", "process", "stdio", "system", "termi serde = { version = "1.0.229", features = ["derive"] } signal-hook = "0.4" toml = "1.1.8" +unicode-truncate = "2.0" +unicode-width = "0.2" [profile.release] lto = "thin" diff --git a/demo/host.nix b/demo/host.nix index 4f53ca4..1c332af 100644 --- a/demo/host.nix +++ b/demo/host.nix @@ -6,6 +6,7 @@ }: let demoService = spec: { + inherit (spec) description; after = map (dependency: "${dependency}.service") (spec.after or [ ]); wantedBy = [ "multi-user.target" ]; serviceConfig = { @@ -30,7 +31,7 @@ in boot.initrd.systemd = { enable = true; services.demo-initrd-probe = { - description = "bootvine demo: slow initrd step"; + description = "Slow hardware probe"; wantedBy = [ "initrd.target" ]; before = [ "initrd.target" ]; unitConfig.DefaultDependencies = false; diff --git a/demo/units.nix b/demo/units.nix index 18767e8..d3408a1 100644 --- a/demo/units.nix +++ b/demo/units.nix @@ -3,19 +3,23 @@ initrdProbeSeconds = "6"; services = { demo-disk = { + description = "Scratch disk preparation"; seconds = "2"; stopSeconds = "2"; }; demo-db = { + description = "Demo database"; seconds = "3"; stopSeconds = "3"; after = [ "demo-disk" ]; }; demo-cache = { + description = "In-memory cache"; seconds = "1.5"; stopSeconds = "1"; }; demo-web = { + description = "Web frontend"; seconds = "2"; stopSeconds = "2"; after = [ @@ -23,13 +27,21 @@ "demo-cache" ]; }; - demo-fetch.seconds = "4"; + demo-fetch = { + description = "Remote content sync"; + seconds = "4"; + }; demo-flaky = { + description = "Flaky health check"; seconds = "1"; fails = true; }; - demo-slow.seconds = "8"; + demo-slow = { + description = "Slow warm-up job"; + seconds = "8"; + }; demo-report = { + description = "Startup report"; seconds = "1"; after = [ "demo-web" diff --git a/demo/user-units.nix b/demo/user-units.nix index 59cd4f3..a71b422 100644 --- a/demo/user-units.nix +++ b/demo/user-units.nix @@ -14,7 +14,7 @@ let name: spec: writeText "${name}.service" (toUnitFile { Unit = { - Description = "bootvine demo: ${name}"; + Description = spec.description; After = map (dependency: "${dependency}.service") (spec.after or [ ]); }; Service = { @@ -34,7 +34,7 @@ let targetFile = writeText "${demoUnits.target}.target" (toUnitFile { Unit = { - Description = "bootvine demo target"; + Description = "bootvine demo services"; Wants = serviceNames; After = serviceNames; }; diff --git a/docs/initrd.png b/docs/initrd.png index 979d784efb225903aa30fe5be47dda6de5d57baf..374cbcafdae10862d5018b1a2b793af2cd1350f9 100644 GIT binary patch literal 5993 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 diff --git a/docs/shutdown.png b/docs/shutdown.png index f3d18ec8d047c73f31a8c1685d0e71d6daed2dea..daad49a31e66f12823b615c4ffbc28a7bf733b52 100644 GIT binary patch literal 14178 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 _qqv_P@UWW8J9y#Peg&v-C|m zm21w}OJ$!ZQH?p^_urZ8ex`*>ed~f%H{UO4t76|xw5 zzFqssb?9)w!iJ@>okeAtjMG_6e1v+XCb1pyxew@s*u6ov7^CWwU~*| zOZC>ZJq>%bqLR$ZD#YI8f1hcW@ZZ;}_>J9z@^^L*$}5a7JPYoW?!15b+-LvA<%^5A zKME1}@Nn}B)wwJw3fHCHT$}fI#vVrTw0AF9lpHr2>}jbr+4ke5*NZu-m)*;jY}t3j zkpJI$|97$Pj@K&*_+*B91#Z|vKMB&(O_Ew z9?=C2FDfVqxGJfoxMoFPIL%mIy?x8+d8eaS5{tNyqv@9Xtzl${Hc-lEK8va+pBNRjc<6I$!byJQFno9)i+ijb0=kP-Gm9#&TiVry2N@vgFpe}JBM)Pgy|=Y>IFA}ye1-C zG|w*KAgBucrd472Pg(y#?fRzgJ)E3Lwl#*g6K&4dI*4aE-r9WgcSGTy_O~*x;^uZL zNm~8NsjPf1?oj6O?_cPgd3lznmo_x?GBWn}aB?;@2na9-9bC9ZRKTt&7Fz186fXEK zAXqEEabtBOH%s$ptACo+p%0h8=h(a<`i^7m^~FI4o@k|SZD8O3ci*Hn_Ajqk+;3_K zw}0+%z)Otv4CfTl2~&Ds?UobRFiDkh^Y^a`3)1RA^Abxw%?)&rI%^oP{ELK^5i5J8 z-J5+U9eGV6mK3WteRqu46gskbcf)M9<1&ArU6$>1+gHG7J$-5NOlQVevDp)Xmm-Sc$@Prf?l0JX>S-^C zP1juz^qS?%?_Dxr_g`gTd|u%$FA#n(3&bi!&rSFMDv5A7aAdAXa%Cy8vaKeoo5T+e7JxQ#~Hd-&7yk zvpzq~{pGJkoo;?t(`0^5`x9RDx`@@+S$++#Bhz%vZ%U@8RP__q?bBN$#Z;81xWLWl zfbjj&mWHWkI8S(TNjz(8N?sP%}y<$P&zRaL`lzk{9Ao!a$(ac^1@$GoD` z$UT&m^YR9%a*6aE@^yElgEE^Uede)VZkw~2bqmv`MuVM+y3SVJu>l*6n6qCL%z9HX zC)lL-_*r2mcQ&onv*on@2BnK#s4?Bxa8UZ&X_h5(4+S_x#WyynTbk>0omk1i)X7q_ zRLf$1!?XUDhL|-)jL93%99O(C?L_*c*?DRSg#sO7r;pZ8urvSa#{-WHf9TKuc}iEo_w}CCC5c|!8tkrK zKl8ic@SKLUt-(3&>J9-1o>=~|Vk&cGaw~3s^1I=(6$?+;>-9~Qy3552o~<%{$Gj{} z>|`8ky1vs77NzUExSm~MY20C#P$D0&Qp4bhiI4C3%X*74?P6T=zi$aY7Ixr@&4D9Q z{|rw&ukJ2eG;!tc@=Y3(rZSx?=-l`!-_^^X#m-&9da{&i*y4Hp!YYv#fa%%k-?S&EdcfEe;6=#>+pSv7WgWsg$tG zW%e8Wgv5@HewLR%KR>kN;K{V{J7T}+?T^oQ^u%`x+AUw2dN-SuefEUeaVb@7Z~YD~ z-KeqluH^mL1D6gOng~6)s^0B;gX>mHU$W$)jk=$ipV!JhJTd*;)E5yqbL1!RMs;|x z9KSA<&3Y$)-h}B!vBDPT{ zxFqtu!>3jLGc1-6Ft}G%%y?R;i>2qZlLIe{PjN>>>+YPMzpQ_L{8+-hp6}+eV|)+K z-+KJq_~x_CH(L5PL=^j+|M_-txRk^rx#P2z?|58(bosvk$7d_;W))oY5IFyi$?n+y zFHSR$rcYV5Y{~o@e%I|c&zL+Eymm>#?ZCOUmf}|SR;~S!3v-`2Xcyd^?7XVx6|0h? z%~YmO0)ko#(t@5ZoV`i2^jF5G+EqObdJ8KVON|%ndowe7-rl0K;P z5W6a0V6&)=Q?GP0$BD(=9_!aQIYc#fvD##-bUe>sY_?OlIbr1k$J1sW;<|kz6XZQF zWY4)4Ez|M7v0U5D;{&-r&pvbaG||!#;Azk(w=N*TvBiB=Q#KQ$wx*~-g<8_~l?Bn;n!1@7wQo8)Ow*4(=-LSGR!(E# zIre_y0^V;EQ|!V$+)bZ#*1xn-)MRYt;QznlN6bN4=|}+sslA^(+jpg~$IMkl$Ws2+h8-1X-wIt+o zo0tGo)iv&lO%wXEzKLAmeXd-4;4({j&Xc!HyIQ(8<#Su)Zj0U9r?SOvTb(kbYm>)x z>*z@*t5pX>3uKReXI$RhEzekc;CRY)(CQQMOM(3Jb&C_{3CN!{%njD+`CySXG_R5?@6K)`Z5$(W-?y(w@^?}P8DLQ zS>902z!YYro}gu_{lGW!v(AspCBHIMPN<(Q-&`Qj8>l|#`eC(_z?S32T+$D>zL0cY z#(vy+*E8=x8!0u3_lpGhl3tvc&ulw=)55bg5#9#(TGQW6IW>KU+)+ctqfB*L94i(Y zm+NqP81ZWf7+jpYM__jJfg>sk<=pHSZ%lqJQh4On$~y=4J$YegcJ}y!dNz(3;sOs9 zgzpImU4MA#8t036U0Du~HukvQaxRaq*y#Zd^R{hcEolz(EToR>U zpRv4ASdhH8A@R`PUk!~(r*fmU6?)nBy$&sSXScvCvqsKG&&g*+`?!asx~F!7ndA8i?-rU3=hdf{C35XkiFs>0{&G0}UYx&?*N+y-{1R@9y*W zKkug3WK~q_{rk7;r**|YQGtr^JAaP(N-an0YurA{f9DibY!(dqT=gMj*SDIsmEyIxtk2&vU-Ieb z;dIY!4dxtziO$o0E|{)pt9MMtDu^-4;nW`+#hQ;R#aRD@To;?rTGyk(^5mjo+QXRU zhT5#^;kiGZpO)V!Eg1a%5g@@aL)-B}ZAlER@${ zWJ;Tn&3M&|G4{~a8S}#wuQItge^*Rkot+`;dW z|LLbrW5ah&!I|@~Coft2v*Ja&cSD1B2;av2e>nbXyRDIBWVyr1v7`w?yp^c!KBGnb0?P?(>@Uvmg-HLSf6k*T-oG$;QdBrjstQz*^G=gI5{|6I9ac3 z^38t1+_ZhNxWNvtdGDAvu`pyE%#c8iJ_m=v$mw zq7J-&pD)Ulv5j$q_D-=0`N6ic>_3QshK6b#6uLw={Gazvo^?(hciru`zwGa@v*a@@ zPHaFbNI$9=E1z{xB?^eiv^TRoabQ4>FSsN+awks%BfMfVK)Qg z>_^Uj*%=iV$k>M;{2yK-Iwy)D;BKQ_X-d8*T+YA=+8TMK%Q}KVHP`Fhw!DGpaNH_u;*}QFVjuP8yBF|h)X%hkmn6=V^f8a| z?Rm#{%uWtEe8Lz0$~^Hr;rXlKLC^*F!hd!TG#-S$XKq?{fTRNJ)Nx@3#|x0Peb7=A zC*{Uy$f+lgEF$oa(QrjWiQR|)V%~MR{#Q5iz5dzm+$8R$=e$h!U2N^+W%EKVOuxz+ zwkhk_i!=V-EPwj5wrf1Nzy9WvomcGapZtr{Fvt9ec zqYivfX31&&vHY&igF~7XjrVkgbhut@ZEnbKEh+f6Fyz4hzwhgpdHD)i2 ze}9Jm{r!FOkDu?~|9I!U_k#M1{g;0m{6Cu7E2O{uo_~G#-NNGRy>Z@OMdO#O@ttdQ zJL<~meD4x7M^3*3|I$mXihX5&9KC-+B>GS0WTsbJ69hk+{{8v={f-MvyITF0$_u-T zab$?CSvHlZ8{IGk_%_(tZ(R)*;18;LgF9dzKT=(Zi z_ys1lAG7|62pCk0%5X`fF}}8NIq;uPe8YNCgH>J^g#-%B`2++0-oIFTK$+D=zCiq* z)`R+sp$0qoSKRf!%YMcDr`tb2`Tv2B|NWcI;&YGP_1AMJX|0$os)rqfx*+&&t;ucLK6T)SY3bs literal 4685 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 Biw*z) literal 9704 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 &'static str { + match unit { + "initrd.target" => "Initrd Default Target", + "initrd-fs.target" => "Initrd File Systems", + "initrd-root-device.target" => "Initrd Root Device", + "sysroot.mount" => "/sysroot", + "systemd-fsck-root.service" => "File System Check on Root Device", + "dev-disk-by\\x2dlabel-nixos.device" => "/dev/disk/by-label/nixos", + "systemd-udevd.service" => "Rule-based Manager for Device Events and Files", + "demo-initrd-probe.service" => "Slow hardware probe", + "graphical.target" => "Graphical Interface", + "display-manager.service" => "Display Manager", + "multi-user.target" => "Multi-User System", + "basic.target" => "Basic System", + "sysinit.target" => "System Initialization", + "systemd-tmpfiles-setup.service" => "Create System Files and Directories", + "systemd-udev-trigger.service" => "Coldplug All udev Devices", + "NetworkManager.service" => "Network Manager", + "NetworkManager-wait-online.service" => "Network Manager Wait Online", + "network-online.target" => "Network is Online", + "tailscaled.service" => "Tailscale node agent", + "containerd.service" => "containerd container runtime", + "docker.socket" => "Docker Socket for the API", + "docker.service" => "Docker Application Container Engine", + "var-lib-docker.mount" => "/var/lib/docker", + "nvidia-powerd.service" => "NVIDIA Dynamic Boost", + "sys-devices-virtual-misc-rfkill.device" => "/sys/devices/virtual/misc/rfkill", + "systemd-rfkill.service" => "Load/Save RF Kill Switch Status", + _ => "", + } +} + struct ScriptedJob { id: u32, step: &'static Step, @@ -176,7 +220,7 @@ impl ScriptedJob { fn facts(&self) -> UnitFacts { UnitFacts { name: self.step.unit.to_owned(), - description: self.step.unit.to_owned(), + description: description(self.step.unit).to_owned(), after: self.step.after.iter().map(ToString::to_string).collect(), before: Vec::new(), } @@ -297,6 +341,12 @@ fn wants_to_quit() -> io::Result { fn play(terminal: &mut DefaultTerminal) -> io::Result<()> { let clock = Instant::now(); let now = || clock.elapsed(); + let origin = BootOrigin { + host: "demo".to_owned(), + system: "NixOS 26.11.20261007.39ad350".to_owned(), + generation: "42".to_owned(), + kernel: "Linux 7.2.9".to_owned(), + }; let mut state = BootState::new(Phase::Initrd); let mut script = Script::begin(INITRD, 1, &mut state, now()); let mut frame = 0; @@ -314,7 +364,7 @@ fn play(terminal: &mut DefaultTerminal) -> io::Result<()> { palette: &Palette::default(), glyphs: &Glyphs::default(), now: now(), - host: "demo", + origin: &origin, frame, }, canvas.area(), diff --git a/src/glyphs.rs b/src/glyphs.rs index 91cab02..1d0d568 100644 --- a/src/glyphs.rs +++ b/src/glyphs.rs @@ -7,6 +7,8 @@ pub struct Glyphs { pub still_going: char, pub running_mark: char, pub root_switch_mark: char, + pub stage_current: char, + pub stage_upcoming: char, pub ellipsis: &'static str, pub chain_link: &'static str, } @@ -18,6 +20,7 @@ const WAITING_BEAD: [char; 2] = ['·', '.']; const STILL_GOING: [char; 2] = ['▶', '>']; const RUNNING_MARK: [char; 3] = ['►', '▶', '>']; const ROOT_SWITCH_MARK: [char; 2] = ['│', '|']; +const STAGE_MARKS: [&str; 3] = ["◆◇", "●○", "*o"]; const ELLIPSIS: [&str; 2] = ["…", "..."]; const CHAIN_LINK: [&str; 2] = ["─", "-"]; @@ -43,6 +46,7 @@ impl Glyphs { .find(|candidate| candidate.chars().all(&covers)) .unwrap_or(candidates[candidates.len() - 1]) }; + let stage_marks: Vec = text(&STAGE_MARKS).chars().collect(); Self { done: symbol(&DONE), failed: symbol(&FAILED), @@ -51,6 +55,8 @@ impl Glyphs { still_going: symbol(&STILL_GOING), running_mark: symbol(&RUNNING_MARK), root_switch_mark: symbol(&ROOT_SWITCH_MARK), + stage_current: stage_marks[0], + stage_upcoming: stage_marks[1], ellipsis: text(&ELLIPSIS), chain_link: text(&CHAIN_LINK), } @@ -75,6 +81,7 @@ mod tests { assert_eq!(glyphs.running_mark, '▶'); assert_eq!(glyphs.failed, '×'); assert_eq!(glyphs.ellipsis, "…"); + assert_eq!((glyphs.stage_current, glyphs.stage_upcoming), ('*', 'o')); } #[test] @@ -84,6 +91,7 @@ mod tests { assert_eq!(glyphs.failed, 'x'); assert_eq!(glyphs.ellipsis, "..."); assert_eq!(glyphs.chain_link, "─"); + assert_eq!((glyphs.stage_current, glyphs.stage_upcoming), ('*', 'o')); } #[test] diff --git a/src/lib.rs b/src/lib.rs index b023062..1dadba6 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1,4 +1,5 @@ pub mod glyphs; pub mod model; +pub mod origin; pub mod palette; pub mod view; diff --git a/src/model.rs b/src/model.rs index bafd069..2c5f594 100644 --- a/src/model.rs +++ b/src/model.rs @@ -158,18 +158,80 @@ impl UnitRecord { } } +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum UnitKind { + Service, + Target, + Socket, + Mount, + Automount, + Device, + Swap, + Path, + Timer, + Slice, + Scope, + Other, +} + +impl UnitKind { + #[must_use] + pub fn of(name: &str) -> Self { + match name.rsplit_once('.').map(|(_, suffix)| suffix) { + Some("service") => Self::Service, + Some("target") => Self::Target, + Some("socket") => Self::Socket, + Some("mount") => Self::Mount, + Some("automount") => Self::Automount, + Some("device") => Self::Device, + Some("swap") => Self::Swap, + Some("path") => Self::Path, + Some("timer") => Self::Timer, + Some("slice") => Self::Slice, + Some("scope") => Self::Scope, + _ => Self::Other, + } + } + + #[must_use] + pub fn tag(self) -> &'static str { + match self { + Self::Service | Self::Target | Self::Other => "", + Self::Socket => "socket", + Self::Mount => "mount", + Self::Automount => "automount", + Self::Device => "device", + Self::Swap => "swap", + Self::Path => "path", + Self::Timer => "timer", + Self::Slice => "slice", + Self::Scope => "scope", + } + } + + fn labelled_by_description(self) -> bool { + matches!( + self, + Self::Device | Self::Mount | Self::Swap | Self::Automount + ) + } +} + #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub enum RowStatus { Waiting, Running, + Failed, + Done, } #[derive(Clone, Debug, PartialEq, Eq)] -pub struct PendingRow { +pub struct TreeRow { pub depth: usize, pub is_last_sibling: Vec, pub label: String, - pub is_target: bool, + pub description: String, + pub kind: UnitKind, pub status: RowStatus, pub queued_at: Duration, pub running_since: Option, @@ -204,6 +266,7 @@ pub struct FinishedRun { pub struct FinishedStage { pub label: &'static str, pub finished_units: usize, + pub failed_units: usize, pub started_at: Duration, pub reached_at: Duration, } @@ -351,7 +414,7 @@ impl BootState { record.job = None; } if let Some(started_at) = started_at - && !record.facts.name.ends_with(".target") + && UnitKind::of(&record.facts.name) != UnitKind::Target { self.finished_runs.push(FinishedRun { label: display_label(&record.facts), @@ -369,8 +432,9 @@ impl BootState { JobResult::Failed | JobResult::Timeout | JobResult::Dependency => Outcome::Failed, }; record.outcome = Some(outcome); - if outcome == Outcome::Failed && !self.failed.contains(&unit) { - self.failed.push(unit); + let label = display_label(&record.facts); + if outcome == Outcome::Failed && !self.failed.contains(&label) { + self.failed.push(label); } } @@ -383,6 +447,11 @@ impl BootState { self.finished_stages.push(FinishedStage { label: Phase::Initrd.label(), finished_units: finished_here + self.finished_before_reconnect, + failed_units: self + .units + .values() + .filter(|record| record.outcome == Some(Outcome::Failed)) + .count(), started_at: self.origin, reached_at: at, }); @@ -519,14 +588,25 @@ impl BootState { } #[must_use] - pub fn pending_rows(&self) -> Vec { + pub fn tree_rows(&self) -> Vec { let pending: HashSet<&str> = self .units .iter() - .filter(|(_, record)| record.job.is_some()) + .filter(|(name, record)| { + record.job.is_some() + || record.outcome == Some(Outcome::Failed) + || (self.is_milestone(name) && record.outcome.is_some()) + }) .map(|(name, _)| name.as_str()) .collect(); let root = self.root.as_deref().filter(|root| pending.contains(root)); + let stages: Vec<&str> = self + .milestone_targets + .iter() + .map(String::as_str) + .filter(|target| pending.contains(target)) + .chain(root.filter(|root| !self.is_milestone(root))) + .collect(); let blocked_by_pending: HashSet<&str> = pending .iter() .flat_map(|name| self.waits_for(name, &pending)) @@ -534,7 +614,7 @@ impl BootState { let mut unblocked: Vec<&str> = pending .iter() .copied() - .filter(|name| !blocked_by_pending.contains(name) && Some(*name) != root) + .filter(|name| !blocked_by_pending.contains(name) && !stages.contains(name)) .collect(); self.sort_siblings(&mut unblocked); let mut leftovers: Vec<&str> = pending.iter().copied().collect(); @@ -545,7 +625,9 @@ impl BootState { } let mut rows = Vec::new(); let mut visited = HashSet::new(); - root.into_iter() + stages + .iter() + .copied() .chain(unblocked) .chain(leftovers) .for_each(|top| { @@ -560,7 +642,12 @@ impl BootState { ); } }); - rows + let mut kept = Vec::new(); + grow_forest(&mut rows.into_iter().peekable(), 0) + .into_iter() + .filter(|stage| stage.row.status != RowStatus::Done || !stage.children.is_empty()) + .for_each(|stage| stage.flatten_into(0, &mut kept)); + relink_siblings(kept) } fn emit<'a>( @@ -570,32 +657,34 @@ impl BootState { visited: &mut HashSet<&'a str>, ancestry: &mut Vec, is_last: bool, - rows: &mut Vec, + rows: &mut Vec, ) { visited.insert(unit); let record = &self.units[unit]; - let job = record.job.expect("pending rows only hold units with a job"); let running_since = record.running_since(); + let status = match (record.job, running_since, record.outcome) { + (Some(_), Some(_), _) => RowStatus::Running, + (Some(_), None, _) => RowStatus::Waiting, + (None, _, Some(Outcome::Failed)) => RowStatus::Failed, + (None, ..) => RowStatus::Done, + }; let mut is_last_sibling = ancestry.clone(); is_last_sibling.push(is_last); - rows.push(PendingRow { + rows.push(TreeRow { depth: ancestry.len(), is_last_sibling, label: display_label(&record.facts), - is_target: record.facts.name.ends_with(".target"), - status: if running_since.is_some() { - RowStatus::Running - } else { - RowStatus::Waiting - }, - queued_at: job.queued_at, + description: summary(&record.facts), + kind: UnitKind::of(&record.facts.name), + status, + queued_at: record.job.map(|job| job.queued_at).unwrap_or_default(), running_since, chain: Vec::new(), }); let candidates: Vec<&str> = self .waits_for(unit, pending) .into_iter() - .filter(|dependency| !visited.contains(dependency)) + .filter(|dependency| !visited.contains(dependency) && !self.is_milestone(dependency)) .collect(); let mut children: Vec<&str> = candidates .iter() @@ -620,6 +709,10 @@ impl BootState { ancestry.pop(); } + fn is_milestone(&self, unit: &str) -> bool { + self.milestone_targets.iter().any(|target| target == unit) + } + fn waits_on(&self, waiter: &str, dependency: &str, pending: &HashSet<&str>) -> bool { let mut seen = HashSet::new(); let mut frontier = vec![waiter]; @@ -655,9 +748,13 @@ impl BootState { } fn sort_siblings(&self, names: &mut [&str]) { - let rank = |name: &str| match self.units[name].running_since() { - Some(since) => SiblingRank::RunningSince(since), - None => SiblingRank::Waiting, + let rank = |name: &str| { + let record = &self.units[name]; + match (record.running_since(), record.outcome) { + (Some(since), _) => SiblingRank::RunningSince(since), + (None, Some(Outcome::Failed)) => SiblingRank::Failed, + (None, _) => SiblingRank::Waiting, + } }; names.sort_by(|left, right| rank(left).cmp(&rank(right)).then_with(|| left.cmp(right))); } @@ -666,6 +763,7 @@ impl BootState { #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)] enum SiblingRank { RunningSince(Duration), + Failed, Waiting, } @@ -695,8 +793,7 @@ impl MilestoneWalk { } } -#[must_use] -pub fn paths_to_running(rows: Vec) -> Vec { +fn on_paths_to_running(rows: &[TreeRow]) -> Vec { let mut kept_below: Vec = Vec::new(); let mut kept: Vec = rows .iter() @@ -704,14 +801,40 @@ pub fn paths_to_running(rows: Vec) -> Vec { .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.is_target; - let keep = row.status == RowStatus::Running || descendant_kept || anchors_the_tree; + 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(); - let survivors: Vec = rows + 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 relink_siblings(rows); + } + let kept = with_spare_rows(&on_paths_to_running(&rows), budget); + let survivors: Vec = rows .into_iter() .zip(kept) .filter_map(|(row, keep)| keep.then_some(row)) @@ -722,7 +845,7 @@ pub fn paths_to_running(rows: Vec) -> Vec { const MIN_FOLDED_LINKS: usize = 2; struct TreeNode { - row: PendingRow, + row: TreeRow, children: Vec, } @@ -763,15 +886,15 @@ impl TreeNode { self } - fn flatten_into(self, depth: usize, rows: &mut Vec) { - rows.push(PendingRow { depth, ..self.row }); + fn flatten_into(self, depth: usize, rows: &mut Vec) { + rows.push(TreeRow { depth, ..self.row }); self.children .into_iter() .for_each(|child| child.flatten_into(depth + 1, rows)); } } -fn grow_forest(rows: &mut Peekable>, depth: usize) -> Vec { +fn grow_forest(rows: &mut Peekable>, depth: usize) -> Vec { iter::from_fn(|| { let row = rows.next_if(|row| row.depth == depth)?; Some(TreeNode { @@ -783,7 +906,7 @@ fn grow_forest(rows: &mut Peekable>, depth: usize) -> Vec) -> Vec { +pub fn fold_chains(rows: Vec) -> Vec { let mut flattened = Vec::new(); grow_forest(&mut rows.into_iter().peekable(), 0) .into_iter() @@ -791,7 +914,7 @@ pub fn fold_chains(rows: Vec) -> Vec { relink_siblings(flattened) } -fn relink_siblings(rows: Vec) -> Vec { +fn relink_siblings(rows: Vec) -> Vec { let mut later_sibling: Vec = Vec::new(); let mut is_last: Vec = rows .iter() @@ -810,7 +933,7 @@ fn relink_siblings(rows: Vec) -> Vec { .map(|(row, last)| { ancestry.truncate(row.depth); ancestry.push(last); - PendingRow { + TreeRow { is_last_sibling: ancestry.clone(), ..row } @@ -818,17 +941,32 @@ fn relink_siblings(rows: Vec) -> Vec { .collect() } +fn labelled_by_description(facts: &UnitFacts) -> bool { + !facts.description.is_empty() && UnitKind::of(&facts.name).labelled_by_description() +} + fn display_label(facts: &UnitFacts) -> String { - if let Some(stem) = facts.name.strip_suffix(".service") { - return stem.to_owned(); - } - let described_by_path = [".device", ".mount", ".swap", ".automount"] - .iter() - .any(|suffix| facts.name.ends_with(suffix)); - if described_by_path && !facts.description.is_empty() { + if labelled_by_description(facts) { return facts.description.clone(); } - facts.name.clone() + match UnitKind::of(&facts.name) { + UnitKind::Target | UnitKind::Other => facts.name.clone(), + _ => facts + .name + .rsplit_once('.') + .map_or_else(|| facts.name.clone(), |(stem, _)| stem.to_owned()), + } +} + +fn summary(facts: &UnitFacts) -> String { + let repeats_the_name = facts.description == facts.name + || facts + .description + .eq_ignore_ascii_case(&display_label(facts)); + if labelled_by_description(facts) || repeats_the_name { + return String::new(); + } + facts.description.clone() } #[cfg(test)] @@ -897,27 +1035,27 @@ mod tests { #[test] fn pending_units_nest_under_what_waits_on_them() { let outline: Vec = sample() - .pending_rows() + .tree_rows() .into_iter() .map(|row| format!("{}{}", " ".repeat(row.depth), row.label)) .collect(); assert_eq!( outline, [ + "basic.target", + "multi-user.target", + " docker", + " containerd", + " nm-wait", + " nm", "graphical.target", - " multi-user.target", - " docker", - " containerd", - " basic.target", - " nm-wait", - " nm", ] ); } #[test] fn only_chains_leading_to_running_units_stay_in_view() { - let rows = paths_to_running(sample().pending_rows()); + let rows = fit_to_height(sample().tree_rows(), 0); let outline: Vec = rows .iter() .map(|row| format!("{}{}", " ".repeat(row.depth), row.label)) @@ -925,18 +1063,106 @@ mod tests { assert_eq!( outline, [ + "basic.target", + "multi-user.target", + " docker", + " nm-wait", + " nm", "graphical.target", - " multi-user.target", - " docker", - " nm-wait", - " nm", ] ); let lasts: Vec = rows .iter() .map(|row| *row.is_last_sibling.last().unwrap()) .collect(); - assert_eq!(lasts, [true, true, false, true, true]); + assert_eq!(lasts, [false, false, false, true, true, true]); + } + + #[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| -> Vec { + fit_to_height(state.tree_rows(), budget) + .into_iter() + .map(|row| format!("{}{}", " ".repeat(row.depth), row.label)) + .collect() + }; + 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 mut state = BootState::new(Phase::Host); + state.set_root("multi-user.target".to_owned()); + [ + facts( + "multi-user.target", + &["basic.target", "dbus.service", "web.service"], + ), + facts("basic.target", &["dbus.service"]), + facts("dbus.service", &[]), + facts("web.service", &[]), + ] + .into_iter() + .zip(1..) + .for_each(|(unit, id)| { + let name = unit.name.clone(); + state.track_unit(unit, Activity::default()); + state.queue_job(id, &name, JobKind::BringsUp, Duration::ZERO); + }); + let outline: Vec = state + .tree_rows() + .into_iter() + .map(|row| format!("{}{}", " ".repeat(row.depth), row.label)) + .collect(); + assert_eq!( + outline, + ["basic.target", " dbus", "multi-user.target", " web"] + ); + } + + #[test] + fn kinds_with_a_tag_drop_their_suffix() { + let socket = facts("docker.socket", &[]); + assert_eq!(UnitKind::of(&socket.name), UnitKind::Socket); + assert_eq!(UnitKind::Socket.tag(), "socket"); + assert_eq!(display_label(&socket), "docker"); + assert_eq!(display_label(&facts("sshd.service", &[])), "sshd"); + assert_eq!(display_label(&facts("basic.target", &[])), "basic.target"); + assert_eq!(UnitKind::Target.tag(), ""); + } + + #[test] + fn descriptions_that_repeat_the_label_are_dropped() { + let described = |name: &str, description: &str| { + summary(&UnitFacts { + name: name.to_owned(), + description: description.to_owned(), + after: Vec::new(), + before: Vec::new(), + }) + }; + assert_eq!( + described("multi-user.target", "Multi-User System"), + "Multi-User System" + ); + assert_eq!(described("greetd.service", "greetd.service"), ""); + assert_eq!(described("greetd.service", "Greetd"), ""); + assert_eq!(described("dev-sda.device", "Samsung SSD"), ""); + assert_eq!(described("demo.service", ""), ""); } fn chain_state(waits: &[(&str, &[&str])], running: &str) -> BootState { @@ -955,7 +1181,7 @@ mod tests { } fn folded_outline(state: &BootState) -> Vec { - fold_chains(paths_to_running(state.pending_rows())) + fold_chains(fit_to_height(state.tree_rows(), 0)) .into_iter() .map(|row| { let chain = once(row.label.as_str()) @@ -1011,7 +1237,7 @@ mod tests { folded_outline(&state), ["root.target", " a", " b", " d"] ); - let rows = fold_chains(paths_to_running(both.pending_rows())); + let rows = fold_chains(fit_to_height(both.tree_rows(), 0)); let lasts: Vec = rows .iter() .map(|row| *row.is_last_sibling.last().unwrap()) @@ -1027,7 +1253,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 = paths_to_running(state.pending_rows()); + let rows = fit_to_height(state.tree_rows(), 0); assert_eq!(rows.len(), 1); assert_eq!(rows[0].label, "demo.target"); } @@ -1046,7 +1272,7 @@ mod tests { active_exit: None, }, ); - let rows = state.pending_rows(); + let rows = state.tree_rows(); assert!( rows.iter() .all(|row| row.label != "containerd" && row.label != "basic.target") @@ -1061,7 +1287,7 @@ mod tests { fn failures_are_listed_and_not_counted_as_done() { let mut state = sample(); state.finish_job(4, JobResult::Failed, 2000 * MS); - assert_eq!(state.failed, ["nm.service"]); + assert_eq!(state.failed, ["nm"]); let tally = state.tally(); assert_eq!(tally.failed, 1); assert_eq!(tally.done, 0); @@ -1105,13 +1331,14 @@ mod tests { [FinishedStage { label: "initrd", finished_units: 2, + failed_units: 0, started_at: Duration::ZERO, reached_at: 2000 * MS, }] ); assert_eq!(state.milestones()[0].reached_at, Some(2000 * MS)); assert_eq!(state.tally().done, 2); - assert!(state.pending_rows().is_empty()); + assert!(state.tree_rows().is_empty()); } #[test] @@ -1127,7 +1354,7 @@ mod tests { Activity::default(), ); state.queue_job(1, "dev-nvme1n1.device", JobKind::BringsUp, Duration::ZERO); - assert_eq!(state.pending_rows()[0].label, "Lexar SSD NM790 2TB"); + assert_eq!(state.tree_rows()[0].label, "Lexar SSD NM790 2TB"); } #[test] @@ -1151,7 +1378,7 @@ mod tests { state.queue_job(id, &name, JobKind::BringsUp, Duration::ZERO); }); let outline: Vec = state - .pending_rows() + .tree_rows() .into_iter() .map(|row| format!("{}{}", " ".repeat(row.depth), row.label)) .collect(); @@ -1167,7 +1394,7 @@ mod tests { fn outline(state: &BootState) -> Vec { state - .pending_rows() + .tree_rows() .into_iter() .map(|row| format!("{}{}", " ".repeat(row.depth), row.label)) .collect() @@ -1205,8 +1432,8 @@ mod tests { assert_eq!( outline(&state), [ + "shutdown.target", "poweroff.target", - " shutdown.target", "network.target", " web", ] @@ -1251,7 +1478,7 @@ mod tests { ..Activity::default() }, ); - assert_eq!(state.pending_rows()[0].running_since, Some(1200 * MS)); + assert_eq!(state.tree_rows()[0].running_since, Some(1200 * MS)); state.finish_job(1, JobResult::Done, 1700 * MS); assert_eq!( state.finished_runs, @@ -1290,6 +1517,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.pending_rows().len(), 2); + assert_eq!(state.tree_rows().len(), 2); } } diff --git a/src/origin.rs b/src/origin.rs new file mode 100644 index 0000000..91e7902 --- /dev/null +++ b/src/origin.rs @@ -0,0 +1,172 @@ +use std::{ + fs::{read_dir, read_link, read_to_string}, + path::{Path, PathBuf}, +}; + +use rustix::system::uname; + +const KERNEL_COMMAND_LINE: &str = "/proc/cmdline"; +const SYSTEM_PROFILES: &str = "/nix/var/nix/profiles"; +const OS_RELEASES: [&str; 2] = ["/etc/os-release", "/usr/lib/os-release"]; +const NIXOS_SYSTEM: &str = "nixos-system-"; + +#[derive(Clone, Debug, Default, PartialEq, Eq)] +pub struct BootOrigin { + pub host: String, + pub system: String, + pub generation: String, + pub kernel: String, +} + +impl BootOrigin { + #[must_use] + pub fn read() -> Self { + let names = uname(); + let host = names.nodename().to_string_lossy().into_owned(); + let command_line = read_to_string(KERNEL_COMMAND_LINE).unwrap_or_default(); + let system_path = init_system(&command_line); + let system = system_path + .and_then(|path| nixos_version(path, &host)) + .map(|version| format!("NixOS {version}")) + .or_else(|| { + OS_RELEASES + .iter() + .find_map(|path| read_to_string(path).ok()) + .and_then(|release| pretty_name(&release)) + }) + .unwrap_or_default(); + let generation = system_path + .map(|path| generation_of(Path::new(path), &system_links())) + .unwrap_or_default(); + Self { + kernel: format!("Linux {}", names.release().to_string_lossy()), + host, + system, + generation, + } + } + + #[must_use] + pub fn parts(&self) -> Vec { + [ + self.host.clone(), + self.system.clone(), + if self.generation.is_empty() { + String::new() + } else { + format!("generation {}", self.generation) + }, + self.kernel.clone(), + ] + .into_iter() + .filter(|part| !part.is_empty()) + .collect() + } +} + +fn init_system(command_line: &str) -> Option<&str> { + command_line + .split_whitespace() + .find_map(|argument| argument.strip_prefix("init=")) + .and_then(|init| init.strip_suffix("/init")) +} + +fn nixos_version<'a>(system_path: &'a str, host: &str) -> Option<&'a str> { + let (_, name) = system_path.rsplit_once('/')?; + let (_, rest) = name.split_once('-')?; + rest.strip_prefix(NIXOS_SYSTEM)? + .strip_prefix(host)? + .strip_prefix('-') +} + +fn pretty_name(os_release: &str) -> Option { + os_release + .lines() + .find_map(|line| line.strip_prefix("PRETTY_NAME=")) + .map(|value| value.trim_matches('"').to_owned()) +} + +struct SystemLink { + generation: String, + target: PathBuf, +} + +fn system_links() -> Vec { + read_dir(SYSTEM_PROFILES) + .into_iter() + .flatten() + .filter_map(Result::ok) + .filter_map(|entry| { + let name = entry.file_name().into_string().ok()?; + let generation = name.strip_prefix("system-")?.strip_suffix("-link")?; + Some(SystemLink { + generation: generation.to_owned(), + target: read_link(entry.path()).ok()?, + }) + }) + .collect() +} + +fn generation_of(system_path: &Path, links: &[SystemLink]) -> String { + links + .iter() + .find(|link| link.target == system_path) + .map(|link| link.generation.clone()) + .unwrap_or_default() +} + +#[cfg(test)] +mod tests { + use super::*; + + const COMMAND_LINE: &str = "initrd=\\EFI\\nixos\\x-initrd.efi \ + init=/nix/store/\ + av1146s7ayap8zgrpindi641v1fmdxsf-nixos-system-ryzen-26.11.\ + 20261007.39ad350/init panic=10 root=fstab"; + + #[test] + fn the_nixos_version_comes_from_the_init_on_the_command_line() { + let system = init_system(COMMAND_LINE).expect("init system"); + assert_eq!( + nixos_version(system, "ryzen"), + Some("26.11.20261007.39ad350") + ); + assert_eq!(nixos_version(system, "other-host"), None); + } + + #[test] + fn the_generation_is_the_profile_link_to_the_booted_system() { + let system = init_system(COMMAND_LINE).expect("init system"); + let links = [ + SystemLink { + generation: "2770".to_owned(), + target: "/nix/store/x43q-nixos-system-ryzen-26.11".into(), + }, + SystemLink { + generation: "2771".to_owned(), + target: system.into(), + }, + ]; + assert_eq!(generation_of(Path::new(system), &links), "2771"); + assert_eq!(generation_of(Path::new(system), &links[..1]), ""); + } + + #[test] + fn other_distributions_use_their_pretty_name() { + assert_eq!( + pretty_name("NAME=Arch\nPRETTY_NAME=\"Arch Linux\"\n"), + Some("Arch Linux".to_owned()) + ); + } + + #[test] + fn unknown_parts_are_left_out() { + let origin = BootOrigin { + host: "ryzen".to_owned(), + system: "NixOS 26.11".to_owned(), + generation: String::new(), + kernel: "Linux 7.2.9".to_owned(), + }; + assert_eq!(origin.parts(), ["ryzen", "NixOS 26.11", "Linux 7.2.9"]); + } +} diff --git a/src/run.rs b/src/run.rs index 60b02a7..bac9353 100644 --- a/src/run.rs +++ b/src/run.rs @@ -10,6 +10,7 @@ use std::{ use bootvine::{ model::{BootState, Phase}, + origin::BootOrigin, palette::Palette, view::BootView, }; @@ -19,7 +20,6 @@ use ratatui::{ backend::Backend, buffer::{Buffer, CellDiffOption}, }; -use rustix::system::uname; use signal_hook::{consts::SIGTERM, flag}; use crate::{ @@ -112,12 +112,17 @@ fn watch( console: &mut Console, hold: Duration, ) -> Result<(), Error> { - let host = uname().nodename().to_string_lossy().into_owned(); + 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(); loop { feed.pump(state, FRAME_INTERVAL)?; + if state.phase != origin_phase { + origin = BootOrigin::read(); + origin_phase = state.phase; + } console.make_way_for_password_prompts(); let repaint_due = feed.connections != painted_connections || last_full_repaint.elapsed() >= FULL_REPAINT_INTERVAL; @@ -131,7 +136,7 @@ fn watch( palette, glyphs: &console.glyphs, now: monotonic_now(), - host: &host, + origin: &origin, frame, }, canvas.area(), diff --git a/src/view.rs b/src/view.rs index 9687581..40b8ad1 100644 --- a/src/view.rs +++ b/src/view.rs @@ -1,4 +1,3 @@ -mod failures; mod footer; mod header; mod stages; @@ -14,24 +13,27 @@ use ratatui::{ text::Line, widgets::{Block, Borders, Widget}, }; +use unicode_truncate::UnicodeTruncateStr; +use unicode_width::UnicodeWidthStr; -use self::{ - failures::Failures, footer::Footer, header::Header, stages::Stages, timeline::Timeline, - tree::PendingTree, -}; +use self::{footer::Footer, header::Header, stages::Stages, timeline::Timeline, tree::UnitTree}; use crate::{ glyphs::Glyphs, - model::{BootState, PendingRow, RowStatus, fold_chains, paths_to_running}, + model::{BootState, RowStatus, TreeRow, UnitKind, fit_to_height, fold_chains}, + origin::BootOrigin, palette::Palette, }; -const RULE_STUB: &str = "──"; 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 = 2; +const HEADER_HEIGHT: u16 = 1; +const BRANCH: &str = "├─ "; +const LAST_BRANCH: &str = "└─ "; +const PASSING_TRUNK: &str = "│ "; +const ENDED_TRUNK: &str = " "; const ELAPSED: SpanPrinter = SpanPrinter::new() .designator(Designator::Compact) @@ -44,15 +46,15 @@ pub struct BootView<'a> { pub palette: &'a Palette, pub glyphs: &'a Glyphs, pub now: Duration, - pub host: &'a str, + pub origin: &'a BootOrigin, pub frame: u64, } impl BootView<'_> { - fn timeline<'a>(&'a self, rows: &'a [PendingRow]) -> Timeline<'a> { - let mut running: Vec<&PendingRow> = rows + fn timeline<'a>(&'a self, rows: &'a [TreeRow]) -> Timeline<'a> { + let mut running: Vec<&TreeRow> = rows .iter() - .filter(|row| !row.is_target && row.status == RowStatus::Running) + .filter(|row| row.kind != UnitKind::Target && row.status == RowStatus::Running) .collect(); running.sort_by_key(|row| row.running_since); Timeline { @@ -85,12 +87,11 @@ impl BootView<'_> { impl Widget for BootView<'_> { fn render(self, area: Rect, buf: &mut Buffer) { - let all_rows = self.state.pending_rows(); + let all_rows = self.state.tree_rows(); let pending_count = all_rows.len(); - let rows = fold_chains(paths_to_running(all_rows)); - let shown_units: usize = rows.iter().map(|row| 1 + row.chain.len()).sum(); + let pruned_rows = fold_chains(fit_to_height(all_rows.clone(), 0)); let header = Header { - host: self.host, + origin: self.origin, total: (!self.state.finished_stages.is_empty()) .then(|| self.now.saturating_sub(self.state.origin)), palette: self.palette, @@ -101,20 +102,16 @@ impl Widget for BootView<'_> { palette: self.palette, glyphs: self.glyphs, }; - let tree = PendingTree { - rows: &rows, - folded: pending_count - shown_units, + let pruned = UnitTree { + phase: stages.current_phase(), + rows: &pruned_rows, + hidden: pending_count - shown_units(&pruned_rows), now: self.now, frame: self.frame, palette: self.palette, glyphs: self.glyphs, }; - let failures = Failures { - units: &self.state.failed, - palette: self.palette, - glyphs: self.glyphs, - }; - let timeline = self.timeline(&rows); + let timeline = self.timeline(&pruned_rows); let footer = Footer { tally: self.state.tally(), shows_root_switch: !self.state.finished_stages.is_empty(), @@ -123,29 +120,38 @@ impl Widget for BootView<'_> { }; let fits_timeline = area.width >= timeline::LABEL_WIDTH + 1 + MIN_BAR_WIDTH && area.height >= MIN_HEIGHT_FOR_TIMELINE; + let free = area + .height + .saturating_sub(HEADER_HEIGHT + stages.height() + footer::HEIGHT); let heights = Heights::share( - area.height.saturating_sub( - HEADER_HEIGHT + stages.height() + failures.height() + footer::HEIGHT, - ), - tree.height(), + free, + pruned.height(), if fits_timeline { timeline.height() } else { 0 }, ); + let budget = usize::from(heights.tree.saturating_sub(1)); + let whole_tree = fit_to_height(all_rows.clone(), usize::MAX); + let rows = [whole_tree.clone(), fold_chains(whole_tree)] + .into_iter() + .find(|rows| rows.len() <= budget) + .unwrap_or_else(|| fold_chains(fit_to_height(all_rows, budget))); + let tree = UnitTree { + rows: &rows, + hidden: pending_count - shown_units(&rows), + ..pruned + }; + let tree_height = tree.height().min(heights.tree); let [ header_area, - _, stage_area, tree_area, - failed_area, _, timeline_area, footer_area, ] = Layout::vertical([ - Constraint::Length(1), - Constraint::Length(HEADER_HEIGHT - 1), + Constraint::Length(HEADER_HEIGHT), Constraint::Length(stages.height()), - Constraint::Length(heights.tree), - Constraint::Length(failures.height()), + Constraint::Length(tree_height), Constraint::Fill(1), Constraint::Length(heights.timeline), Constraint::Length(footer::HEIGHT), @@ -155,7 +161,6 @@ impl Widget for BootView<'_> { header.render(header_area, buf); stages.render(stage_area, buf); tree.render(tree_area, buf); - failures.render(failed_area, buf); if heights.timeline > 0 { timeline.render(timeline_area, buf); } @@ -170,12 +175,6 @@ struct Heights { impl Heights { fn share(free: u16, tree_need: u16, timeline_need: u16) -> Self { - if tree_need.saturating_add(timeline_need) <= free { - return Self { - tree: tree_need, - timeline: timeline_need, - }; - } let timeline = timeline_need .min(free.saturating_sub(tree_need).max(MIN_TIMELINE_HEIGHT)) .min(free); @@ -193,6 +192,18 @@ fn rule(palette: &Palette, left: Line<'static>) -> Block<'static> { .title(left) } +fn shown_units(rows: &[TreeRow]) -> usize { + rows.iter().map(|row| 1 + row.chain.len()).sum() +} + +fn fit_width(text: &str, room: usize, ellipsis: &str) -> String { + if text.width() <= room { + return text.to_owned(); + } + let (kept, _) = text.unicode_truncate(room.saturating_sub(ellipsis.width())); + format!("{kept}{ellipsis}") +} + fn unit_count(count: usize) -> String { match count { 1 => "1 unit".to_owned(), @@ -228,7 +239,12 @@ mod tests { palette: &Palette::default(), glyphs: &Glyphs::default(), now, - host: "ryzen", + origin: &BootOrigin { + host: "ryzen".to_owned(), + system: "NixOS 26.11".to_owned(), + generation: "2771".to_owned(), + kernel: "Linux 7.2.9".to_owned(), + }, frame: 1, }, frame.area(), @@ -297,18 +313,24 @@ mod tests { fn tree_on_top_timeline_below() { let lines = render(&boot_in_progress(), 12_400 * MS, 110, 24); let screen = lines.join("\n"); - assert_eq!(lines[0], "bootvine ryzen", "{screen}"); - assert!(lines[2].starts_with("── stage 2 ──"), "{screen}"); - assert!(lines[2].ends_with("12.4s ──"), "{screen}"); - assert!(lines[3].starts_with("graphical.target"), "{screen}"); - assert!(lines[4].starts_with("└─ multi-user.target"), "{screen}"); - assert!(lines[5].starts_with(" ├─ [/] systemd-rfkill"), "{screen}"); - assert!(lines[6].starts_with(" └─ [/] docker"), "{screen}"); - assert!(lines[7].starts_with("… 1 more"), "{screen}"); - assert!( - lines[8].starts_with("× nvidia-powerd.service failed"), + assert_eq!( + lines[0], "ryzen · NixOS 26.11 · generation 2771 · Linux 7.2.9", "{screen}" ); + assert!(lines[1].starts_with("└─ stage 2 12.4s"), "{screen}"); + assert!(lines[1].ends_with("running"), "{screen}"); + assert!( + lines[2].starts_with(" ├─ ◆ multi-user.target"), + "{screen}" + ); + assert!( + lines[3].starts_with(" │ ├─ [/] systemd-rfkill"), + "{screen}" + ); + assert!(lines[4].starts_with(" │ ├─ [/] docker"), "{screen}"); + assert!(lines[5].starts_with(" │ └─ [ ] web"), "{screen}"); + assert!(lines[6].starts_with(" ├─ ◇ graphical.target"), "{screen}"); + assert!(lines[7].starts_with(" └─ [×] nvidia-powerd"), "{screen}"); let timeline = lines .iter() .position(|line| line.contains(" timeline ")) @@ -343,15 +365,46 @@ mod tests { ); } + #[test] + fn failures_stay_in_the_stage_that_wanted_them() { + let mut state = BootState::new(Phase::Host); + state.set_root("multi-user.target".to_owned()); + [ + facts("multi-user.target", &["basic.target", "web.service"]), + facts("basic.target", &["flaky.service", "quick.service"]), + facts("flaky.service", &[]), + facts("quick.service", &[]), + facts("web.service", &[]), + ] + .into_iter() + .zip(1..) + .for_each(|(unit, id)| { + let name = unit.name.clone(); + state.track_unit(unit, Activity::default()); + state.queue_job(id, &name, JobKind::BringsUp, Duration::ZERO); + }); + 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 screen = lines.join("\n"); + assert!(lines[2].starts_with(" ├─ √ basic.target"), "{screen}"); + assert!(lines[3].starts_with(" │ └─ [×] flaky"), "{screen}"); + assert!( + lines[4].starts_with(" └─ ◆ multi-user.target"), + "{screen}" + ); + assert!(lines[5].starts_with(" └─ [ ] web"), "{screen}"); + assert!(!screen.contains("quick"), "{screen}"); + } + #[test] fn only_running_units_carry_a_timer() { let lines = render(&boot_in_progress(), 12_400 * MS, 110, 24); let screen = lines.join("\n"); - assert!( - lines[3].trim_end().ends_with("graphical.target"), - "{screen}" - ); - assert!(lines[5].ends_with("6.4s"), "{screen}"); + assert!(lines[2].ends_with("multi-user.target"), "{screen}"); + assert!(lines[3].ends_with("6.4s"), "{screen}"); + assert!(lines[5].ends_with("web"), "{screen}"); } #[test] @@ -368,24 +421,22 @@ mod tests { ); } - #[test] - fn folded_chains_shorten_to_their_ends_when_narrow() { - let mut state = BootState::new(Phase::Shutdown); - state.set_root("poweroff.target".to_owned()); + fn chain_boot() -> BootState { + let mut state = BootState::new(Phase::Host); + state.set_root("graphical.target".to_owned()); [ - ("poweroff.target", "systemd-poweroff.service"), - ("systemd-poweroff.service", "final.target"), - ("final.target", "shutdown.target"), - ("shutdown.target", "local-fs.target"), - ("local-fs.target", "demo-disk.service"), - ("demo-disk.service", "demo-db.service"), - ("demo-db.service", ""), + ("graphical.target", "network-wait.service"), + ("network-wait.service", "network.target"), + ("network.target", "network-manager.service"), + ("network-manager.service", "dbus.service"), + ("dbus.service", "udev-settle.service"), + ("udev-settle.service", ""), ] .into_iter() .zip(1..) .for_each(|((name, waits_on), id)| { let after: Vec<&str> = [waits_on].into_iter().filter(|w| !w.is_empty()).collect(); - let activity = if name == "demo-db.service" { + let activity = if name == "udev-settle.service" { running_since(1000 * MS) } else { Activity::default() @@ -393,37 +444,168 @@ mod tests { state.track_unit(facts(name, &after), activity); state.queue_job(id, name, JobKind::BringsUp, Duration::ZERO); }); - let wide = render(&state, 5000 * MS, 110, 24); + state + } + + #[test] + fn chains_stay_unfolded_while_they_fit() { + let lines = render(&chain_boot(), 5000 * MS, 110, 24); + let screen = lines.join("\n"); assert!( - wide[4].starts_with( - "└─ [ ] systemd-poweroff ─ final.target ─ shutdown.target ─ local-fs.target ─ \ - demo-disk" - ), - "{}", - wide.join("\n") + lines[3].starts_with(" └─ [ ] network-wait"), + "{screen}" ); assert!( - wide[5].starts_with(" └─ [/] demo-db"), - "{}", - wide.join("\n") + lines[4].starts_with(" └─ network.target"), + "{screen}" ); - let narrow = render(&state, 5000 * MS, 60, 24); assert!( - narrow[4].starts_with("└─ [ ] systemd-poweroff ─ … ─ demo-disk"), + lines[7].starts_with(" └─ [/] udev-settle"), + "{screen}" + ); + } + + #[test] + fn chains_fold_when_short_and_shorten_to_their_ends_when_narrow() { + let short = render(&chain_boot(), 5000 * MS, 110, 13); + assert!( + short[3] + .starts_with(" └─ [ ] network-wait ─ network.target ─ network-manager ─ dbus"), + "{}", + short.join("\n") + ); + assert!( + short[4].starts_with(" └─ [/] udev-settle"), + "{}", + short.join("\n") + ); + let narrow = render(&chain_boot(), 5000 * MS, 45, 8); + assert!( + narrow[3].starts_with(" └─ [ ] network-wait ─ … ─ dbus"), "{}", narrow.join("\n") ); } + fn described_boot() -> BootState { + let mut state = BootState::new(Phase::Host); + state.set_root("multi-user.target".to_owned()); + [ + ( + "multi-user.target", + "Multi-User System", + &["docker.service", "systemd-rfkill.service"][..], + ), + ("docker.service", "Docker Application Container Engine", &[]), + ( + "systemd-rfkill.service", + "Load/Save RF Kill Switch Status", + &[], + ), + ] + .into_iter() + .zip(1..) + .for_each(|((name, description, after), id)| { + state.track_unit( + UnitFacts { + description: description.to_owned(), + ..facts(name, after) + }, + running_since(1000 * MS), + ); + state.queue_job(id, name, JobKind::BringsUp, Duration::ZERO); + }); + state + } + + #[test] + fn descriptions_line_up_in_a_column() { + let lines = render(&described_boot(), 3000 * MS, 110, 24); + let screen = lines.join("\n"); + let column_of = |text: &str| { + lines + .iter() + .find_map(|line| line.find(text).map(|at| line[..at].width())) + .unwrap_or_else(|| panic!("{text} missing\n{screen}")) + }; + assert_eq!(column_of("Multi-User System"), column_of("description")); + assert_eq!( + column_of("Multi-User System"), + column_of("Docker Application") + ); + assert_eq!( + column_of("Multi-User System"), + column_of("Load/Save RF Kill") + ); + assert!(column_of("Multi-User System") > column_of("systemd-rfkill")); + } + + #[test] + fn non_service_units_carry_their_kind() { + let mut state = described_boot(); + state.track_unit( + UnitFacts { + description: "Docker Socket for the API".to_owned(), + ..facts("docker.socket", &[]) + }, + running_since(1000 * MS), + ); + state.queue_job(9, "docker.socket", JobKind::BringsUp, Duration::ZERO); + let lines = render(&state, 3000 * MS, 110, 24); + let screen = lines.join("\n"); + let socket_row = lines + .iter() + .find(|line| line.contains("Docker Socket")) + .unwrap_or_else(|| panic!("{screen}")); + assert!(socket_row.contains("[/] docker "), "{screen}"); + assert!(socket_row.contains(" socket "), "{screen}"); + assert!( + render(&described_boot(), 3000 * MS, 110, 24) + .iter() + .all(|line| !line.contains(" socket ")), + "{screen}" + ); + } + + #[test] + fn narrow_screens_keep_names_and_drop_descriptions() { + let lines = render(&described_boot(), 3000 * MS, 40, 24); + let screen = lines.join("\n"); + assert!(screen.contains("systemd-rfkill"), "{screen}"); + assert!(!screen.contains("Docker"), "{screen}"); + } + + #[test] + fn long_timeline_labels_end_in_an_ellipsis() { + let mut state = boot_in_progress(); + state.track_unit( + UnitFacts { + description: "Kernel Configuration File System".to_owned(), + ..facts("sys-kernel-config.mount", &[]) + }, + running_since(2000 * MS), + ); + state.queue_job(30, "sys-kernel-config.mount", JobKind::BringsUp, 2000 * MS); + state.finish_job(30, JobResult::Done, 4000 * MS); + let lines = render(&state, 12_400 * MS, 110, 24); + assert!( + lines + .iter() + .any(|line| line.starts_with("√ Kernel Configuration File…")), + "{}", + lines.join("\n") + ); + } + #[test] fn narrow_screens_drop_the_timeline() { - let lines = render(&boot_in_progress(), 12_400 * MS, 36, 24); + let lines = render(&boot_in_progress(), 12_400 * MS, 40, 24); assert!( lines.iter().all(|line| !line.contains('■')), "{}", lines.join("\n") ); - assert!(lines[5].contains("systemd-rfkill")); + assert!(lines[3].contains("systemd-rfkill"), "{}", lines.join("\n")); } #[test] @@ -441,12 +623,11 @@ mod tests { let screen = lines.join("\n"); assert!(lines[0].ends_with("17.3s"), "{screen}"); assert!( - lines[2].starts_with("── initrd ── ■ done in 7.2s · 1 unit ──"), + lines[1].starts_with("├─ initrd ■ done in 7.2s · 1 unit"), "{screen}" ); - assert!(lines[3].starts_with("── stage 2 ──"), "{screen}"); - assert!(lines[3].ends_with("10.1s ──"), "{screen}"); - assert!(lines[4].starts_with("graphical.target"), "{screen}"); + assert!(lines[2].starts_with("└─ stage 2 10.1s"), "{screen}"); + assert!(lines[3].starts_with(" └─ ◆ graphical.target"), "{screen}"); let timeline = lines .iter() .position(|line| line.contains(" timeline ")) @@ -474,8 +655,8 @@ mod tests { state.finish_job(1, JobResult::Done, 9000 * MS); let lines = render(&state, 9500 * MS, 110, 24); assert!( - lines[2].starts_with( - "── ■ boot finished in 9.5s · handing over to display-manager.service ──" + lines[1].starts_with( + "└─ ■ boot finished in 9.5s · handing over to display-manager.service" ), "{}", lines.join("\n") @@ -491,7 +672,7 @@ mod tests { state.queue_job(1, "poweroff.target", JobKind::BringsUp, 20_000 * MS); let lines = render(&state, 21_500 * MS, 110, 24); assert!( - lines[2].starts_with("── shutdown ─") && lines[2].ends_with(" 1.5s ──"), + lines[1].starts_with("└─ shutdown 1.5s") && lines[1].ends_with("running"), "{}", lines.join("\n") ); @@ -504,9 +685,8 @@ mod tests { state.manager_exited_at = Some(24_200 * MS); let lines = render(&state, 30_000 * MS, 110, 24); assert!( - lines[2].starts_with( - "── ■ shutdown finished in 4.2s · handing over to systemd-shutdown ──" - ), + lines[1] + .starts_with("└─ ■ shutdown finished in 4.2s · handing over to systemd-shutdown"), "{}", lines.join("\n") ); @@ -531,7 +711,7 @@ mod tests { }); let lines = render(&state, 1000 * MS, 110, 20); assert!( - lines.iter().any(|line| line.starts_with("… ")), + lines.iter().any(|line| line.starts_with(" … ")), "{}", lines.join("\n") ); diff --git a/src/view/failures.rs b/src/view/failures.rs deleted file mode 100644 index 383acd3..0000000 --- a/src/view/failures.rs +++ /dev/null @@ -1,40 +0,0 @@ -use ratatui::{ - buffer::Buffer, - layout::Rect, - style::Stylize, - text::Line, - widgets::{Paragraph, Widget}, -}; - -use crate::{glyphs::Glyphs, palette::Palette}; - -const MAX_ROWS: usize = 3; - -pub struct Failures<'a> { - pub units: &'a [String], - pub palette: &'a Palette, - pub glyphs: &'a Glyphs, -} - -impl Failures<'_> { - pub fn height(&self) -> u16 { - u16::try_from(self.lines().len()).unwrap_or(u16::MAX) - } - - fn lines(&self) -> Vec> { - let hidden = self.units.len().saturating_sub(MAX_ROWS); - self.units - .iter() - .take(MAX_ROWS) - .map(|unit| format!("{} {unit} failed", self.glyphs.failed)) - .chain((hidden > 0).then(|| format!("{} {hidden} more failed", self.glyphs.failed))) - .map(|text| Line::from(text).fg(self.palette.failed).bold()) - .collect() - } -} - -impl Widget for Failures<'_> { - fn render(self, area: Rect, buf: &mut Buffer) { - Paragraph::new(self.lines()).render(area, buf); - } -} diff --git a/src/view/header.rs b/src/view/header.rs index 707ed90..058cf3d 100644 --- a/src/view/header.rs +++ b/src/view/header.rs @@ -1,22 +1,42 @@ -use std::time::Duration; +use std::{iter::once, time::Duration}; use ratatui::{ buffer::Buffer, layout::{Constraint, Rect}, style::Stylize, - text::Line, + text::{Line, Span}, widgets::{Row, Table, Widget}, }; use super::{DURATION_WIDTH, ELAPSED}; -use crate::palette::Palette; +use crate::{origin::BootOrigin, palette::Palette}; + +const SEPARATOR: &str = " · "; pub struct Header<'a> { - pub host: &'a str, + pub origin: &'a BootOrigin, pub total: Option, pub palette: &'a Palette, } +impl Header<'_> { + fn origin(&self) -> Line<'static> { + Line::from( + self.origin + .parts() + .into_iter() + .enumerate() + .flat_map(|(index, part)| { + let separator = (index > 0).then(|| SEPARATOR.fg(self.palette.muted)); + let part = Span::from(part).fg(self.palette.text); + let part = if index == 0 { part.bold() } else { part }; + separator.into_iter().chain(once(part)) + }) + .collect::>(), + ) + } +} + impl Widget for Header<'_> { fn render(self, area: Rect, buf: &mut Buffer) { let total = self @@ -25,13 +45,14 @@ impl Widget for Header<'_> { .unwrap_or_default(); Table::new( [Row::new([ - Line::from(format!("bootvine {}", self.host)), - Line::from(total).right_aligned(), + self.origin(), + Line::from(total) + .fg(self.palette.text) + .bold() + .right_aligned(), ])], [Constraint::Fill(1), Constraint::Length(DURATION_WIDTH)], ) - .fg(self.palette.text) - .bold() .render(area, buf); } } diff --git a/src/view/stages.rs b/src/view/stages.rs index 1bdb02e..3be765e 100644 --- a/src/view/stages.rs +++ b/src/view/stages.rs @@ -1,17 +1,18 @@ -use std::{iter::once, time::Duration}; +use std::time::Duration; use ratatui::{ buffer::Buffer, layout::Rect, style::Stylize, - text::Line, - widgets::{Block, Widget}, + text::{Line, Span}, + widgets::{Paragraph, Widget}, }; -use super::{ELAPSED, RULE_STUB, rule, unit_count}; +use super::{BRANCH, ELAPSED, LAST_BRANCH, unit_count}; use crate::{glyphs::Glyphs, model::BootState, palette::Palette}; const SHUTDOWN_SUCCESSOR: &str = "systemd-shutdown"; +const PHASE_WIDTH: usize = 9; pub struct Stages<'a> { pub state: &'a BootState, @@ -28,7 +29,7 @@ struct Conclusion<'a> { impl Stages<'_> { pub fn height(&self) -> u16 { - u16::try_from(self.state.finished_stages.len() + 1).unwrap_or(u16::MAX) + u16::try_from(self.lines().len()).unwrap_or(u16::MAX) } fn conclusion(&self) -> Option> { @@ -51,78 +52,72 @@ impl Stages<'_> { }) } - fn finished_rules(&self) -> impl Iterator> + '_ { + fn finished_phases(&self) -> impl Iterator> + '_ { self.state.finished_stages.iter().map(|stage| { - rule( - self.palette, - Line::from(vec![ - format!("{RULE_STUB} {} {RULE_STUB} ", stage.label).fg(self.palette.muted), - format!( - "{} done in {}", - self.glyphs.bead, - ELAPSED.unsigned_duration_to_string( - &stage.reached_at.saturating_sub(stage.started_at) - ) + Line::from(vec![ + BRANCH.fg(self.palette.muted), + format!("{:PHASE_WIDTH$}", stage.label).fg(self.palette.waiting), + format!( + "{} done in {}", + self.glyphs.bead, + ELAPSED.unsigned_duration_to_string( + &stage.reached_at.saturating_sub(stage.started_at) ) - .fg(self.palette.done), - format!(" · {} ", unit_count(stage.finished_units)).fg(self.palette.waiting), - ]), - ) + ) + .fg(self.palette.done), + format!(" · {}", unit_count(stage.finished_units)).fg(self.palette.waiting), + if stage.failed_units > 0 { + format!(" · {} {} failed", self.glyphs.failed, stage.failed_units) + .fg(self.palette.failed) + .bold() + } else { + Span::default() + }, + ]) }) } - fn concluded_rule(&self, conclusion: &Conclusion) -> Block<'static> { - rule( - self.palette, - Line::from(vec![ - format!("{RULE_STUB} ").fg(self.palette.muted), - format!( - "{} {} finished in {}", - self.glyphs.bead, - conclusion.finished, - ELAPSED.unsigned_duration_to_string(&conclusion.took) - ) - .fg(self.palette.done) - .bold(), - format!(" · handing over to {} ", conclusion.handed_to).fg(self.palette.text), - ]), - ) + fn concluded_phase(&self, conclusion: &Conclusion) -> Line<'static> { + Line::from(vec![ + LAST_BRANCH.fg(self.palette.muted), + format!( + "{} {} finished in {}", + self.glyphs.bead, + conclusion.finished, + ELAPSED.unsigned_duration_to_string(&conclusion.took) + ) + .fg(self.palette.done) + .bold(), + format!(" · handing over to {}", conclusion.handed_to).fg(self.palette.text), + ]) } - fn current_rule(&self) -> Block<'static> { + pub fn current_phase(&self) -> Line<'static> { + if let Some(conclusion) = self.conclusion() { + return self.concluded_phase(&conclusion); + } let started_at = self .state .finished_stages .last() .map_or(self.state.origin, |stage| stage.reached_at); let elapsed = ELAPSED.unsigned_duration_to_string(&self.now.saturating_sub(started_at)); - rule( - self.palette, - Line::from(vec![ - format!("{RULE_STUB} ").fg(self.palette.muted), - self.state.phase.label().fg(self.palette.text).bold(), - " ".into(), - ]), - ) - .title( - Line::from(vec![ - " ".into(), - elapsed.fg(self.palette.text).bold(), - format!(" {RULE_STUB}").fg(self.palette.muted), - ]) - .right_aligned(), - ) + Line::from(vec![ + LAST_BRANCH.fg(self.palette.muted), + format!("{:PHASE_WIDTH$}", self.state.phase.label()) + .fg(self.palette.text) + .bold(), + elapsed.fg(self.palette.text), + ]) + } + + fn lines(&self) -> Vec> { + self.finished_phases().collect() } } impl Widget for Stages<'_> { fn render(self, area: Rect, buf: &mut Buffer) { - let last = self.conclusion().map_or_else( - || self.current_rule(), - |conclusion| self.concluded_rule(&conclusion), - ); - area.rows() - .zip(self.finished_rules().chain(once(last))) - .for_each(|(row, rule)| rule.render(row, buf)); + Paragraph::new(self.lines()).render(area, buf); } } diff --git a/src/view/timeline.rs b/src/view/timeline.rs index a94baa2..c62bd32 100644 --- a/src/view/timeline.rs +++ b/src/view/timeline.rs @@ -13,15 +13,16 @@ use ratatui::{ widgets::{Row, Table, Widget}, }; -use super::{rule, unit_count}; +use super::{fit_width, rule, unit_count}; use crate::{ glyphs::Glyphs, - model::{FinishedRun, MilestoneRow, PendingRow}, + model::{FinishedRun, MilestoneRow, TreeRow}, palette::Palette, }; pub const LABEL_WIDTH: u16 = 28; pub const CHROME_HEIGHT: u16 = 3; +const MARK_WIDTH: u16 = 2; const KERNEL_ORIGIN_LABEL: &str = "kernel"; const AXIS_LABEL_SPACING: u16 = 8; const AXIS_STEPS: [Duration; 12] = [ @@ -48,7 +49,7 @@ pub struct Timeline<'a> { pub root_switches: Vec, pub milestones: Vec, pub finished: Vec<&'a FinishedRun>, - pub running: Vec<&'a PendingRow>, + pub running: Vec<&'a TreeRow>, pub palette: &'a Palette, pub glyphs: &'a Glyphs, } @@ -112,7 +113,7 @@ impl Timeline<'_> { TimelineEntry { label: Line::from(vec![ Span::styled(format!("{mark} "), outcome), - run.label.as_str().fg(self.palette.waiting), + self.fitted(&run.label).fg(self.palette.waiting), ]), segments: vec![Segment { from: run.started_at, @@ -124,7 +125,15 @@ impl Timeline<'_> { } } - fn running_entry<'a>(&self, row: &'a PendingRow) -> TimelineEntry<'a> { + fn fitted(&self, label: &str) -> String { + fit_width( + label, + usize::from(LABEL_WIDTH - MARK_WIDTH), + self.glyphs.ellipsis, + ) + } + + fn running_entry<'a>(&self, row: &'a TreeRow) -> TimelineEntry<'a> { let since = row.running_since.unwrap_or(row.queued_at); let waited = (since > row.queued_at).then(|| Segment { from: row.queued_at, @@ -141,7 +150,7 @@ impl Timeline<'_> { TimelineEntry { label: Line::from(vec![ format!("{} ", self.glyphs.running_mark).fg(self.palette.running), - row.label.as_str().fg(self.palette.text), + self.fitted(&row.label).fg(self.palette.text), ]), segments: waited.into_iter().chain(once(ran)).collect(), still_going_at: Some(self.now), diff --git a/src/view/tree.rs b/src/view/tree.rs index 89c4a13..0507121 100644 --- a/src/view/tree.rs +++ b/src/view/tree.rs @@ -3,129 +3,289 @@ use std::{iter::once, time::Duration}; use ratatui::{ buffer::Buffer, layout::{Constraint, Rect}, - style::{Color, Stylize}, + style::{Style, Stylize}, text::{Line, Span}, widgets::{Row, Table, Widget}, }; +use unicode_width::UnicodeWidthStr; -use super::{DURATION_WIDTH, ELAPSED, NOTEWORTHY_DURATION}; +use super::{ + BRANCH, DURATION_WIDTH, ELAPSED, ENDED_TRUNK, LAST_BRANCH, NOTEWORTHY_DURATION, PASSING_TRUNK, + fit_width, +}; use crate::{ glyphs::Glyphs, - model::{PendingRow, RowStatus}, + model::{RowStatus, TreeRow, UnitKind}, palette::Palette, }; const SPINNER: [char; 4] = ['|', '/', '-', '\\']; +const DESCRIPTION_GAP: u16 = 1; +const MIN_DESCRIPTION_WIDTH: u16 = 12; +const HEADER_ROWS: u16 = 1; -pub struct PendingTree<'a> { - pub rows: &'a [PendingRow], - pub folded: usize, +pub struct UnitTree<'a> { + pub phase: Line<'static>, + pub rows: &'a [TreeRow], + pub hidden: usize, pub now: Duration, pub frame: u64, pub palette: &'a Palette, pub glyphs: &'a Glyphs, } -impl PendingTree<'_> { +struct Columns { + label: u16, + tag: u16, + description: u16, +} + +#[derive(Clone, Copy, PartialEq, Eq)] +enum Stage { + Reached, + Current, + Upcoming, + Inside, +} + +fn opens_a_stage(row: &TreeRow) -> bool { + row.depth == 0 && row.kind == UnitKind::Target +} + +fn width_of(text: &str) -> u16 { + u16::try_from(text.width()).unwrap_or(u16::MAX) +} + +impl UnitTree<'_> { pub fn height(&self) -> u16 { - u16::try_from(self.rows.len() + usize::from(self.folded > 0)).unwrap_or(u16::MAX) + u16::try_from(self.rows.len() + usize::from(self.hidden > 0)) + .unwrap_or(u16::MAX) + .saturating_add(HEADER_ROWS) } - fn label_color(&self, row: &PendingRow) -> Color { - if row.is_target { - return self.palette.target; + fn phase_fits_its_column(&self, columns: &Columns) -> bool { + self.phase.width() <= usize::from(columns.label) + } + + fn header(&self, columns: &Columns) -> Row<'static> { + if !self.phase_fits_its_column(columns) { + return Row::default().height(HEADER_ROWS); } - match row.status { - RowStatus::Running => self.palette.text, - RowStatus::Waiting => self.palette.waiting, + let name = |text: &'static str| Line::from(text).fg(self.palette.muted); + Row::new(columns.shown([ + self.phase.clone(), + name("kind"), + name("description"), + name("running").right_aligned(), + ])) + } + + fn stages(&self) -> impl Iterator + '_ { + let current = self + .rows + .iter() + .position(|row| opens_a_stage(row) && row.status != RowStatus::Done); + self.rows.iter().enumerate().map(move |(index, row)| { + if Some(index) == current { + Stage::Current + } else if opens_a_stage(row) && row.status == RowStatus::Done { + Stage::Reached + } else if opens_a_stage(row) { + Stage::Upcoming + } else { + Stage::Inside + } + }) + } + + fn label_style(&self, row: &TreeRow, stage: Stage) -> Style { + match (stage, row.kind, row.status) { + (Stage::Current, ..) => Style::from(self.palette.running).bold(), + (Stage::Reached, ..) => self.palette.done.into(), + (_, _, 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(), } } - fn status_marker(&self, row: &PendingRow) -> Span<'static> { - if row.is_target { - return Span::default(); - } - match row.status { - RowStatus::Running => { + fn status_marker(&self, row: &TreeRow, stage: Stage) -> Span<'static> { + match (stage, row.kind, row.status) { + (Stage::Current, ..) => { + format!("{} ", self.glyphs.stage_current).fg(self.palette.running) + } + (Stage::Upcoming, ..) => { + format!("{} ", self.glyphs.stage_upcoming).fg(self.palette.target) + } + (Stage::Reached, ..) => format!("{} ", self.glyphs.done).fg(self.palette.done), + (_, _, RowStatus::Failed) => { + format!("[{}] ", self.glyphs.failed).fg(self.palette.failed) + } + (_, UnitKind::Target, _) => Span::default(), + (_, _, RowStatus::Running) => { let spinner = SPINNER[usize::try_from(self.frame % 4).unwrap_or_default()]; format!("[{spinner}] ").fg(self.palette.running) } - RowStatus::Waiting => "[ ] ".fg(self.palette.waiting), + (_, _, RowStatus::Waiting) => "[ ] ".fg(self.palette.waiting), + (_, _, RowStatus::Done) => format!("[{}] ", self.glyphs.done).fg(self.palette.done), } } - fn chained_label(&self, row: &PendingRow, room: usize) -> String { + fn lead_width(&self, row: &TreeRow, stage: Stage) -> usize { + tree_prefix(row).width() + self.status_marker(row, stage).width() + } + + fn chained_label(&self, row: &TreeRow, room: usize) -> String { let link = format!(" {} ", self.glyphs.chain_link); - let Some(last) = row.chain.last() else { - return row.label.clone(); - }; let full: String = once(row.label.as_str()) .chain(row.chain.iter().map(String::as_str)) .collect::>() .join(&link); - if full.chars().count() <= room || row.chain.len() == 1 { - return full; - } - format!("{}{link}{}{link}{last}", row.label, self.glyphs.ellipsis) + let label = match row.chain.as_slice() { + [_, .., last] if full.width() > room => { + format!("{}{link}{}{link}{last}", row.label, self.glyphs.ellipsis) + } + _ => full, + }; + fit_width(&label, room, self.glyphs.ellipsis) } - fn row(&self, row: &PendingRow, label_room: usize) -> Row<'static> { + fn columns(&self, width: u16) -> Columns { + let unannotated = width.saturating_sub(DURATION_WIDTH + 1); + let annotated: Vec<(&TreeRow, Stage)> = self + .rows + .iter() + .zip(self.stages()) + .filter(|(row, _)| { + row.chain.is_empty() && !(row.description.is_empty() && row.kind.tag().is_empty()) + }) + .collect(); + let tag = annotated + .iter() + .map(|(row, _)| width_of(row.kind.tag())) + .max() + .unwrap_or_default(); + let content = unannotated.saturating_sub(1 + u16::from(tag > 0)); + let label = annotated + .iter() + .map(|(row, stage)| { + width_of(&row.label) + .saturating_add(u16::try_from(self.lead_width(row, *stage)).unwrap_or(u16::MAX)) + }) + .max() + .map(|widest| widest.saturating_add(DESCRIPTION_GAP)) + .filter(|widest| widest.saturating_add(tag + MIN_DESCRIPTION_WIDTH) <= content); + label.map_or( + Columns { + label: unannotated, + tag: 0, + description: 0, + }, + |label| Columns { + label, + tag, + description: content - label - tag, + }, + ) + } + + fn row(&self, row: &TreeRow, stage: Stage, columns: &Columns) -> Row<'static> { let prefix = tree_prefix(row); - let marker = self.status_marker(row); - let room = label_room.saturating_sub(prefix.chars().count() + marker.width()); + let marker = self.status_marker(row, stage); + let room = usize::from(columns.label).saturating_sub(self.lead_width(row, stage)); + let annotation = |text: &str, width: u16| { + if row.chain.is_empty() { + fit_width(text, usize::from(width), self.glyphs.ellipsis) + } else { + String::new() + } + }; let timer = row .running_since .map(|since| self.now.saturating_sub(since)) .filter(|running_for| *running_for >= NOTEWORTHY_DURATION) .map(|running_for| ELAPSED.unsigned_duration_to_string(&running_for)) .unwrap_or_default(); - let color = self.label_color(row); - Row::new([ + let style = self.label_style(row, stage); + Row::new(columns.shown([ Line::from(vec![ prefix.fg(self.palette.muted), marker, - self.chained_label(row, room).fg(color), + Span::styled(self.chained_label(row, room), style), ]), - Line::from(timer).fg(color).right_aligned(), - ]) + Line::from(annotation(row.kind.tag(), columns.tag)).fg(self.palette.muted), + Line::from(annotation(&row.description, columns.description)).fg(self.palette.muted), + Line::from(timer).style(style).right_aligned(), + ])) } } -impl Widget for PendingTree<'_> { +impl Columns { + fn shown(&self, cells: [T; 4]) -> impl Iterator { + let present = [true, self.tag > 0, self.description > 0, true]; + cells + .into_iter() + .zip(present) + .filter_map(|(cell, present)| present.then_some(cell)) + } + + fn widths(&self) -> impl Iterator { + self.shown([self.label, self.tag, self.description, DURATION_WIDTH]) + .map(Constraint::Length) + } +} + +impl Widget for UnitTree<'_> { fn render(self, area: Rect, buf: &mut Buffer) { - let capacity = usize::from(area.height); - let label_room = usize::from(area.width.saturating_sub(DURATION_WIDTH + 1)); - let shown = if usize::from(self.height()) > capacity { + let capacity = usize::from(area.height.saturating_sub(HEADER_ROWS)); + let shown = if usize::from(self.height() - HEADER_ROWS) > capacity { capacity.saturating_sub(1).min(self.rows.len()) } else { self.rows.len() }; - let hidden = self.rows.len() - shown + self.folded; + let hidden = self.rows.len() - shown + self.hidden; let overflow = (hidden > 0).then(|| { - Row::new([format!("{} {hidden} more", self.glyphs.ellipsis).fg(self.palette.waiting)]) + Row::new([ + format!("{ENDED_TRUNK}{} {hidden} more", self.glyphs.ellipsis) + .fg(self.palette.waiting), + ]) }); + let columns = self.columns(area.width); Table::new( self.rows .iter() + .zip(self.stages()) .take(shown) - .map(|row| self.row(row, label_room)) + .map(|(row, stage)| self.row(row, stage, &columns)) .chain(overflow), - [Constraint::Fill(1), Constraint::Length(DURATION_WIDTH)], + columns.widths(), ) + .header(self.header(&columns)) .render(area, buf); + if !self.phase_fits_its_column(&columns) { + self.phase.render(Rect { height: 1, ..area }, buf); + } } } -fn tree_prefix(row: &PendingRow) -> String { +fn tree_prefix(row: &TreeRow) -> String { let ancestors = row .is_last_sibling .iter() - .skip(1) - .take(row.depth.saturating_sub(1)) - .map(|ancestor_is_last| if *ancestor_is_last { " " } else { "│ " }); - let connector = (row.depth > 0).then(|| match row.is_last_sibling.last() { - Some(false) => "├─ ", - _ => "└─ ", - }); - ancestors.chain(connector).chain(once("")).collect() + .take(row.depth) + .map(|ancestor_is_last| { + if *ancestor_is_last { + ENDED_TRUNK + } else { + PASSING_TRUNK + } + }); + let connector = match row.is_last_sibling.last() { + Some(false) => BRANCH, + _ => LAST_BRANCH, + }; + once(ENDED_TRUNK) + .chain(ancestors) + .chain(once(connector)) + .collect() }