deb: change ui/ux of pkh deb
This commit is contained in:
+545
@@ -0,0 +1,545 @@
|
||||
//! Live UI for `pkh deb`: a status bar with the current build phase on top
|
||||
//! and a rolling pane of rewritten log lines below ("a terminal in the
|
||||
//! terminal").
|
||||
//!
|
||||
//! Subprocess output is captured through a [`LineSink`] implementation,
|
||||
//! rewritten by classifiers ([`crate::ui::logfmt`]) and rendered in place
|
||||
//! with indicatif, so pkh's own log lines keep printing above the widget via
|
||||
//! `indicatif-log-bridge`. Every raw captured line is also tee'd to a log
|
||||
//! file under the pkh cache directory.
|
||||
|
||||
use std::collections::VecDeque;
|
||||
use std::fs::{self, File};
|
||||
use std::io::Write;
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::sync::atomic::{AtomicBool, Ordering};
|
||||
use std::sync::{Arc, Mutex};
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
use crossterm::{cursor, execute, style::Stylize, terminal::Clear, terminal::ClearType};
|
||||
use directories::ProjectDirs;
|
||||
use indicatif::{MultiProgress, ProgressBar, ProgressStyle};
|
||||
|
||||
use crate::context::{LineSink, Stream};
|
||||
use crate::ui::logfmt::{
|
||||
Action, AptInstallClassifier, AptUpdateClassifier, Classifier, GenericClassifier,
|
||||
MakeClassifier, MmdebstrapClassifier, QuiltClassifier,
|
||||
};
|
||||
|
||||
/// Number of lines displayed in the rolling pane
|
||||
const PANE_LINES: usize = 4;
|
||||
|
||||
/// Minimum interval between pane redraws
|
||||
const REDRAW_INTERVAL: Duration = Duration::from_millis(50);
|
||||
|
||||
/// Build phases of `pkh deb`, shown in the status bar
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
pub enum Phase {
|
||||
/// Downloading the chroot tarball (mmdebstrap)
|
||||
PreparingChroot,
|
||||
/// Extracting the chroot tarball
|
||||
ExtractingChroot,
|
||||
/// Device nodes, /proc bind mount, etc.
|
||||
FinalizingChroot,
|
||||
/// apt-get update
|
||||
UpdatingPackageLists,
|
||||
/// Installing build-essential & co
|
||||
InstallingEssentials,
|
||||
/// quilt push -a
|
||||
ApplyingPatches,
|
||||
/// --inject packages
|
||||
InjectingPackages,
|
||||
/// apt-get build-dep
|
||||
InstallingBuildDeps,
|
||||
/// debian/rules build
|
||||
Building,
|
||||
/// fakeroot debian/rules binary
|
||||
ProducingBinaries,
|
||||
/// Retrieving produced .deb files
|
||||
RetrievingArtifacts,
|
||||
}
|
||||
|
||||
impl Phase {
|
||||
/// Human-readable label displayed in the status bar
|
||||
pub fn label(&self) -> &'static str {
|
||||
match self {
|
||||
Phase::PreparingChroot => "Preparing chroot",
|
||||
Phase::ExtractingChroot => "Extracting chroot",
|
||||
Phase::FinalizingChroot => "Finalizing chroot",
|
||||
Phase::UpdatingPackageLists => "Updating package lists",
|
||||
Phase::InstallingEssentials => "Installing essential packages",
|
||||
Phase::ApplyingPatches => "Applying patches",
|
||||
Phase::InjectingPackages => "Injecting packages",
|
||||
Phase::InstallingBuildDeps => "Installing build dependencies",
|
||||
Phase::Building => "Building package",
|
||||
Phase::ProducingBinaries => "Producing binary packages",
|
||||
Phase::RetrievingArtifacts => "Retrieving artifacts",
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Default classifier used for a given phase
|
||||
fn default_classifier(phase: Phase) -> Box<dyn Classifier> {
|
||||
match phase {
|
||||
Phase::PreparingChroot => Box::new(MmdebstrapClassifier::new()),
|
||||
Phase::ExtractingChroot | Phase::FinalizingChroot => Box::new(GenericClassifier::new()),
|
||||
Phase::UpdatingPackageLists => Box::new(AptUpdateClassifier::new()),
|
||||
Phase::InstallingEssentials => Box::new(AptInstallClassifier::new("Installing essentials")),
|
||||
Phase::ApplyingPatches => Box::new(QuiltClassifier::new(0)),
|
||||
Phase::InjectingPackages => Box::new(AptInstallClassifier::new("Injecting packages")),
|
||||
Phase::InstallingBuildDeps => {
|
||||
Box::new(AptInstallClassifier::new("Installing build dependencies"))
|
||||
}
|
||||
Phase::Building | Phase::ProducingBinaries => Box::new(MakeClassifier::new()),
|
||||
Phase::RetrievingArtifacts => Box::new(GenericClassifier::new()),
|
||||
}
|
||||
}
|
||||
|
||||
/// Visual kind of a pane line, driving its color
|
||||
#[derive(Debug, Clone, Copy, PartialEq)]
|
||||
enum Kind {
|
||||
Normal,
|
||||
Warning,
|
||||
Error,
|
||||
}
|
||||
|
||||
/// Mutable state shared between the sink and the widget
|
||||
struct Pipeline {
|
||||
classifier: Box<dyn Classifier>,
|
||||
lines: VecDeque<(Kind, String)>,
|
||||
errors: Vec<String>,
|
||||
last_draw: Instant,
|
||||
bar_total: u64,
|
||||
}
|
||||
|
||||
/// State shared between [`DebUi`] and its sinks
|
||||
struct Shared {
|
||||
top: ProgressBar,
|
||||
pane: ProgressBar,
|
||||
state: Mutex<Pipeline>,
|
||||
tee: Mutex<Option<File>>,
|
||||
log_path: Mutex<PathBuf>,
|
||||
timestamp: String,
|
||||
enabled: bool,
|
||||
/// Set once the widget has been removed from the terminal; afterwards all
|
||||
/// rendering is skipped so late events cannot redraw stale frames.
|
||||
suspended: AtomicBool,
|
||||
started: Instant,
|
||||
}
|
||||
|
||||
/// Live build view for `pkh deb`
|
||||
///
|
||||
/// Create one per build (disabled automatically when stdout is not a TTY or
|
||||
/// when the user requests verbose output), pass it down as
|
||||
/// `Option<Arc<DebUi>>`, and feed subprocess output through [`DebUi::sink`].
|
||||
pub struct DebUi {
|
||||
shared: Arc<Shared>,
|
||||
}
|
||||
|
||||
impl DebUi {
|
||||
/// Create a live view attached to `multi`
|
||||
///
|
||||
/// When stdout is not a TTY, the widget is disabled: no bars are drawn,
|
||||
/// but captured output is still tee'd to the log file.
|
||||
pub fn new(multi: &MultiProgress) -> Self {
|
||||
let enabled = is_stdout_tty();
|
||||
|
||||
let top = if enabled {
|
||||
let pb = multi.add(ProgressBar::new(0));
|
||||
pb.enable_steady_tick(Duration::from_millis(80));
|
||||
pb.set_style(spinner_style());
|
||||
pb.set_prefix("Building package");
|
||||
pb.set_message("(starting…)");
|
||||
pb
|
||||
} else {
|
||||
ProgressBar::hidden()
|
||||
};
|
||||
|
||||
let pane = if enabled {
|
||||
let pb = multi.add(ProgressBar::new(0));
|
||||
pb.enable_steady_tick(Duration::from_millis(150));
|
||||
// No template margin: multi-line messages are only prefixed by
|
||||
// the template on their first line, which would misalign the
|
||||
// pane; each rendered line carries its own indent instead.
|
||||
pb.set_style(
|
||||
ProgressStyle::default_bar()
|
||||
.template("{msg}")
|
||||
.expect("valid template"),
|
||||
);
|
||||
pb.set_message(" │ (starting…)");
|
||||
pb
|
||||
} else {
|
||||
ProgressBar::hidden()
|
||||
};
|
||||
|
||||
let timestamp = chrono::Utc::now().format("%Y%m%dT%H%M%S").to_string();
|
||||
let log_path = default_log_path(×tamp);
|
||||
|
||||
let ui = Self {
|
||||
shared: Arc::new(Shared {
|
||||
top,
|
||||
pane,
|
||||
state: Mutex::new(Pipeline {
|
||||
classifier: Box::new(GenericClassifier::new()),
|
||||
lines: VecDeque::new(),
|
||||
errors: Vec::new(),
|
||||
last_draw: Instant::now(),
|
||||
bar_total: 0,
|
||||
}),
|
||||
tee: Mutex::new(None),
|
||||
log_path: Mutex::new(log_path.clone()),
|
||||
timestamp,
|
||||
enabled,
|
||||
suspended: AtomicBool::new(false),
|
||||
started: Instant::now(),
|
||||
}),
|
||||
};
|
||||
|
||||
if ui.shared.enabled {
|
||||
install_sigint_hook(&log_path);
|
||||
}
|
||||
|
||||
ui
|
||||
}
|
||||
|
||||
/// Identify the package being built; names the log file and the status bar
|
||||
pub fn set_target(&self, package: &str, version: &str, series: &str, arch: &str) {
|
||||
if self.shared.enabled {
|
||||
self.shared.top.set_prefix(format!(
|
||||
"Building {package} ({version}) for {series}/{arch}"
|
||||
));
|
||||
}
|
||||
|
||||
// Rename the log file to include the package identity (best-effort),
|
||||
// then open it so subsequent captured lines are tee'd.
|
||||
let old_path = self.shared.log_path.lock().unwrap().clone();
|
||||
let log_path = match old_path.parent() {
|
||||
Some(dir) => dir.join(format!(
|
||||
"deb-{package}-{version}-{}.log",
|
||||
self.shared.timestamp
|
||||
)),
|
||||
None => old_path.clone(),
|
||||
};
|
||||
let _ = fs::rename(&old_path, &log_path);
|
||||
*self.shared.log_path.lock().unwrap() = log_path.clone();
|
||||
update_sigint_log_path(&log_path);
|
||||
|
||||
if let Some(dir) = log_path.parent() {
|
||||
let _ = fs::create_dir_all(dir);
|
||||
}
|
||||
match File::create(&log_path) {
|
||||
Ok(mut file) => {
|
||||
let _ = writeln!(
|
||||
file,
|
||||
"# pkh deb {} ({}) for {}/{} started {}",
|
||||
package,
|
||||
version,
|
||||
series,
|
||||
arch,
|
||||
chrono::Utc::now().to_rfc3339()
|
||||
);
|
||||
*self.shared.tee.lock().unwrap() = Some(file);
|
||||
}
|
||||
Err(e) => {
|
||||
log::warn!(
|
||||
"Could not create build log file {}: {}",
|
||||
log_path.display(),
|
||||
e
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Switch to a phase, installing its default classifier
|
||||
pub fn phase(&self, phase: Phase) {
|
||||
self.phase_with(phase, default_classifier(phase));
|
||||
}
|
||||
|
||||
/// Switch to a phase with a custom classifier (e.g. quilt with a known
|
||||
/// patch count)
|
||||
pub fn phase_with(&self, phase: Phase, classifier: Box<dyn Classifier>) {
|
||||
{
|
||||
let mut st = self.shared.state.lock().unwrap();
|
||||
st.classifier = classifier;
|
||||
st.lines.clear();
|
||||
st.bar_total = 0;
|
||||
st.last_draw = Instant::now();
|
||||
}
|
||||
if self.shared.enabled {
|
||||
self.shared.top.set_style(spinner_style());
|
||||
self.shared.top.set_message(phase.label());
|
||||
self.shared.pane.set_message("");
|
||||
}
|
||||
}
|
||||
|
||||
/// Update the status bar message directly (for in-process work such as
|
||||
/// tarball extraction that has no subprocess output)
|
||||
pub fn progress_message(&self, msg: &str) {
|
||||
if self.active() {
|
||||
self.shared.top.set_message(msg.to_string());
|
||||
}
|
||||
}
|
||||
|
||||
/// Drive the determinate progress bar directly (e.g. artifact retrieval)
|
||||
pub fn count_progress(&self, label: &str, pos: usize, total: usize) {
|
||||
if !self.active() || total == 0 {
|
||||
return;
|
||||
}
|
||||
apply_progress(
|
||||
&self.shared.top,
|
||||
&mut self.shared.state.lock().unwrap(),
|
||||
pos as u64,
|
||||
total as u64,
|
||||
);
|
||||
self.shared.top.set_message(label.to_string());
|
||||
}
|
||||
|
||||
/// Whether the widget is enabled and still drawn
|
||||
fn active(&self) -> bool {
|
||||
self.shared.enabled && !self.shared.suspended.load(Ordering::SeqCst)
|
||||
}
|
||||
|
||||
/// Obtain a sink feeding this view; pass it to `ContextCommand::capture`
|
||||
pub fn sink(self: &Arc<Self>) -> Arc<dyn LineSink> {
|
||||
Arc::new(Sink {
|
||||
shared: self.shared.clone(),
|
||||
})
|
||||
}
|
||||
|
||||
/// Remove the widget from the terminal (e.g. before printing passthrough
|
||||
/// diagnostics or letting child cleanup commands write to the terminal);
|
||||
/// idempotent
|
||||
///
|
||||
/// Steady ticks are disabled first: otherwise a tick can redraw a frame
|
||||
/// right after the clear, leaving stale copies of the widget on screen.
|
||||
pub fn suspend(&self) {
|
||||
if !self.shared.enabled {
|
||||
return;
|
||||
}
|
||||
if self.shared.suspended.swap(true, Ordering::SeqCst) {
|
||||
return;
|
||||
}
|
||||
self.shared.top.disable_steady_tick();
|
||||
self.shared.pane.disable_steady_tick();
|
||||
self.shared.top.finish_and_clear();
|
||||
self.shared.pane.finish_and_clear();
|
||||
}
|
||||
|
||||
/// Clear the widget and print a success summary with the artifacts
|
||||
pub fn finish_success(&self, artifacts: &[PathBuf], elapsed: Duration) {
|
||||
self.suspend();
|
||||
if self.shared.enabled && !artifacts.is_empty() {
|
||||
for artifact in artifacts {
|
||||
println!(" → {}", artifact.display());
|
||||
}
|
||||
println!(" ✔ Built in {}s", elapsed.as_secs());
|
||||
}
|
||||
}
|
||||
|
||||
/// Clear the widget and print a failure summary (recent captured errors
|
||||
/// and the path to the full log)
|
||||
pub fn finish_failure(&self) {
|
||||
self.suspend();
|
||||
|
||||
let st = self.shared.state.lock().unwrap();
|
||||
if self.shared.enabled && !st.errors.is_empty() {
|
||||
eprintln!("Last captured errors:");
|
||||
for err in st
|
||||
.errors
|
||||
.iter()
|
||||
.rev()
|
||||
.take(5)
|
||||
.collect::<Vec<_>>()
|
||||
.iter()
|
||||
.rev()
|
||||
{
|
||||
eprintln!(" {}", err);
|
||||
}
|
||||
}
|
||||
let log_path = self.shared.log_path.lock().unwrap().clone();
|
||||
if log_path.exists() {
|
||||
eprintln!("Full log: {}", log_path.display());
|
||||
}
|
||||
}
|
||||
|
||||
/// Time elapsed since the view was created
|
||||
pub fn elapsed(&self) -> Duration {
|
||||
self.shared.started.elapsed()
|
||||
}
|
||||
|
||||
/// Path of the full build log file
|
||||
pub fn log_path(&self) -> PathBuf {
|
||||
self.shared.log_path.lock().unwrap().clone()
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for DebUi {
|
||||
fn drop(&mut self) {
|
||||
// Safety net: clear the widget on early returns/unwinds
|
||||
self.suspend();
|
||||
}
|
||||
}
|
||||
|
||||
/// Bridge forwarding captured subprocess lines into the pipeline
|
||||
struct Sink {
|
||||
shared: Arc<Shared>,
|
||||
}
|
||||
|
||||
impl LineSink for Sink {
|
||||
fn line(&self, stream: Stream, line: &str) {
|
||||
// Tee the raw line first: nothing should be lost, even when the
|
||||
// widget is disabled.
|
||||
{
|
||||
let mut tee = self.shared.tee.lock().unwrap();
|
||||
if let Some(file) = tee.as_mut() {
|
||||
let _ = writeln!(file, "{line}");
|
||||
}
|
||||
}
|
||||
|
||||
if !self.shared.enabled || self.shared.suspended.load(Ordering::SeqCst) {
|
||||
return;
|
||||
}
|
||||
|
||||
let mut st = self.shared.state.lock().unwrap();
|
||||
for action in st.classifier.feed(stream, line) {
|
||||
match action {
|
||||
Action::Hidden => {}
|
||||
Action::Progress { pos, total } => {
|
||||
apply_progress(&self.shared.top, &mut st, pos, total)
|
||||
}
|
||||
Action::Shown(text) => push_line(&self.shared, &mut st, Kind::Normal, text),
|
||||
Action::Warning(text) => push_line(&self.shared, &mut st, Kind::Warning, text),
|
||||
Action::Error(text) => {
|
||||
if st.errors.len() < 100 {
|
||||
st.errors.push(text.clone());
|
||||
}
|
||||
push_line(&self.shared, &mut st, Kind::Error, text);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Update the determinate progress bar, restyling it when needed
|
||||
fn apply_progress(top: &ProgressBar, st: &mut Pipeline, pos: u64, total: u64) {
|
||||
if total == 0 {
|
||||
return;
|
||||
}
|
||||
if st.bar_total != total {
|
||||
st.bar_total = total;
|
||||
top.set_style(determinate_style());
|
||||
top.set_length(total);
|
||||
}
|
||||
top.set_position(pos.min(total));
|
||||
}
|
||||
|
||||
/// Push a line into the rolling pane and redraw (throttled)
|
||||
///
|
||||
/// When the pane is full, the oldest non-error line is dropped first so
|
||||
/// errors stay visible longer.
|
||||
fn push_line(shared: &Shared, st: &mut Pipeline, kind: Kind, text: String) {
|
||||
st.lines.push_back((kind, text));
|
||||
while st.lines.len() > PANE_LINES {
|
||||
let drop_idx = st
|
||||
.lines
|
||||
.iter()
|
||||
.position(|(k, _)| *k != Kind::Error)
|
||||
.unwrap_or(0);
|
||||
st.lines.remove(drop_idx);
|
||||
}
|
||||
|
||||
let now = Instant::now();
|
||||
if now.duration_since(st.last_draw) >= REDRAW_INTERVAL {
|
||||
st.last_draw = now;
|
||||
shared.pane.set_message(render_pane(&st.lines));
|
||||
}
|
||||
}
|
||||
|
||||
/// Render the pane content with per-kind colors
|
||||
fn render_pane(lines: &VecDeque<(Kind, String)>) -> String {
|
||||
lines
|
||||
.iter()
|
||||
.map(|(kind, text)| match kind {
|
||||
Kind::Normal => format!(" │ {text}"),
|
||||
Kind::Warning => format!(" │ {}", text.as_str().yellow()),
|
||||
Kind::Error => format!(" │ {}", text.as_str().red()),
|
||||
})
|
||||
.collect::<Vec<_>>()
|
||||
.join("\n")
|
||||
}
|
||||
|
||||
/// Status bar style while no determinate progress is known
|
||||
///
|
||||
/// The target lives on the first line and the current phase/message on its own
|
||||
/// line below, so narrow terminals are not overflowed.
|
||||
fn spinner_style() -> ProgressStyle {
|
||||
ProgressStyle::default_bar()
|
||||
.template("> {spinner:.blue} {prefix}\n {msg}")
|
||||
.expect("valid template")
|
||||
}
|
||||
|
||||
/// Status bar style with a determinate progress bar
|
||||
///
|
||||
/// Same two-line layout as [`spinner_style`], plus the bar on a third line.
|
||||
fn determinate_style() -> ProgressStyle {
|
||||
ProgressStyle::default_bar()
|
||||
.template("> {spinner:.blue} {prefix}\n {msg} [{bar:24.cyan/blue}] {pos}/{len}")
|
||||
.expect("valid template")
|
||||
.progress_chars("=> ")
|
||||
}
|
||||
|
||||
/// Whether stdout is a terminal
|
||||
fn is_stdout_tty() -> bool {
|
||||
// SAFETY: isatty only inspects the file descriptor
|
||||
unsafe { libc::isatty(libc::STDOUT_FILENO) == 1 }
|
||||
}
|
||||
|
||||
/// Default log file path for a given timestamp
|
||||
fn default_log_path(timestamp: &str) -> PathBuf {
|
||||
let dir = ProjectDirs::from("com", "pkh", "pkh")
|
||||
.map(|dirs| dirs.cache_dir().join("logs"))
|
||||
.unwrap_or_else(std::env::temp_dir);
|
||||
dir.join(format!("deb-{timestamp}.log"))
|
||||
}
|
||||
|
||||
static SIGINT_LOG_PATH: Mutex<Option<PathBuf>> = Mutex::new(None);
|
||||
static SIGINT_INSTALLED: AtomicBool = AtomicBool::new(false);
|
||||
|
||||
/// Install a best-effort Ctrl+C handler clearing the widget and pointing at
|
||||
/// the log file before exiting
|
||||
fn install_sigint_hook(log_path: &Path) {
|
||||
update_sigint_log_path(log_path);
|
||||
if SIGINT_INSTALLED.swap(true, Ordering::SeqCst) {
|
||||
return;
|
||||
}
|
||||
|
||||
// SAFETY: installing a signal handler; the handler itself is best-effort
|
||||
// (it performs non async-signal-safe operations, acceptable here because
|
||||
// it immediately exits afterwards).
|
||||
unsafe {
|
||||
libc::signal(libc::SIGINT, on_sigint as *const () as usize);
|
||||
}
|
||||
}
|
||||
|
||||
/// Point the sigint handler at the current log file location
|
||||
fn update_sigint_log_path(log_path: &Path) {
|
||||
*SIGINT_LOG_PATH.lock().unwrap() = Some(log_path.to_path_buf());
|
||||
}
|
||||
|
||||
extern "C" fn on_sigint(_sig: libc::c_int) {
|
||||
// Best-effort cleanup: clear leftover widget lines and show the cursor
|
||||
let _ = execute!(
|
||||
std::io::stdout(),
|
||||
Clear(ClearType::FromCursorDown),
|
||||
cursor::Show
|
||||
);
|
||||
if let Ok(guard) = SIGINT_LOG_PATH.try_lock()
|
||||
&& let Some(path) = guard.as_ref()
|
||||
{
|
||||
eprintln!("\nInterrupted — full log: {}", path.display());
|
||||
}
|
||||
// SAFETY: raw exit bypassing destructors, intended in a signal handler
|
||||
unsafe {
|
||||
libc::_exit(130);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,510 @@
|
||||
//! Line classifiers rewriting raw subprocess output for the live UI
|
||||
//!
|
||||
//! Each classifier is a small stateful machine fed every captured line of a
|
||||
//! build phase; it decides what to display (rewritten lines, warnings,
|
||||
//! errors) and whether the line carries countable progress. Classifiers are
|
||||
//! pure with respect to the UI: they only return [`Action`]s.
|
||||
|
||||
use std::sync::OnceLock;
|
||||
|
||||
use crate::context::Stream;
|
||||
use regex::Regex;
|
||||
|
||||
/// Maximum length of a rewritten line displayed in the rolling pane
|
||||
pub(crate) const MAX_LINE_WIDTH: usize = 120;
|
||||
|
||||
/// What a classifier decided to do with a captured line
|
||||
#[derive(Debug, Clone, PartialEq)]
|
||||
pub enum Action {
|
||||
/// Drop the line (noise)
|
||||
Hidden,
|
||||
/// Display a rewritten line in the rolling pane
|
||||
Shown(String),
|
||||
/// Display a warning line (yellow)
|
||||
Warning(String),
|
||||
/// Display an error line (red, sticky)
|
||||
Error(String),
|
||||
/// Update the determinate progress bar
|
||||
Progress {
|
||||
/// Current position
|
||||
pos: u64,
|
||||
/// Total number of items (0 = unknown)
|
||||
total: u64,
|
||||
},
|
||||
}
|
||||
|
||||
/// Stateful classifier turning raw subprocess lines into UI actions
|
||||
pub trait Classifier: Send {
|
||||
/// Feed one captured line, returning the actions it produces
|
||||
fn feed(&mut self, stream: Stream, line: &str) -> Vec<Action>;
|
||||
}
|
||||
|
||||
/// Truncate a line to [`MAX_LINE_WIDTH`], appending an ellipsis if cut
|
||||
pub(crate) fn truncate(line: &str) -> String {
|
||||
if line.chars().count() <= MAX_LINE_WIDTH {
|
||||
line.to_string()
|
||||
} else {
|
||||
let cut: String = line.chars().take(MAX_LINE_WIDTH - 1).collect();
|
||||
format!("{}…", cut.trim_end())
|
||||
}
|
||||
}
|
||||
|
||||
/// Classify apt-style severity prefixes (`E:` / `W:`)
|
||||
fn apt_severity(line: &str) -> Option<Action> {
|
||||
if line.starts_with("E:") {
|
||||
Some(Action::Error(truncate(line)))
|
||||
} else if line.starts_with("W:") {
|
||||
Some(Action::Warning(truncate(line)))
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
/// Classifier for `apt-get update` output
|
||||
///
|
||||
/// Collapses `Get:/Hit:/Ign:` lines into a running source counter and always
|
||||
/// surfaces errors and warnings.
|
||||
#[derive(Default)]
|
||||
pub struct AptUpdateClassifier {
|
||||
sources: u64,
|
||||
}
|
||||
|
||||
impl AptUpdateClassifier {
|
||||
/// Create a new classifier
|
||||
pub fn new() -> Self {
|
||||
Self::default()
|
||||
}
|
||||
}
|
||||
|
||||
impl Classifier for AptUpdateClassifier {
|
||||
fn feed(&mut self, _stream: Stream, line: &str) -> Vec<Action> {
|
||||
if line.starts_with("Get:") || line.starts_with("Hit:") || line.starts_with("Ign:") {
|
||||
self.sources += 1;
|
||||
vec![Action::Shown(format!(
|
||||
"Updating package lists… ({} sources)",
|
||||
self.sources
|
||||
))]
|
||||
} else if let Some(severity) = apt_severity(line) {
|
||||
vec![severity]
|
||||
} else {
|
||||
vec![Action::Hidden]
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Classifier for `apt-get install` / `apt-get build-dep` output
|
||||
///
|
||||
/// Parses the upfront summary ("N upgraded, M newly installed, …") to derive
|
||||
/// a total, then counts `Unpacking`/`Setting up` lines to drive a determinate
|
||||
/// progress bar.
|
||||
#[derive(Default)]
|
||||
pub struct AptInstallClassifier {
|
||||
label: String,
|
||||
total: u64,
|
||||
done: u64,
|
||||
}
|
||||
|
||||
impl AptInstallClassifier {
|
||||
/// Create a classifier for an install phase labeled `label`
|
||||
pub fn new(label: &str) -> Self {
|
||||
Self {
|
||||
label: label.to_string(),
|
||||
..Default::default()
|
||||
}
|
||||
}
|
||||
|
||||
fn progress(&self) -> Action {
|
||||
if self.total > 0 {
|
||||
Action::Progress {
|
||||
pos: self.done.min(self.total),
|
||||
total: self.total,
|
||||
}
|
||||
} else {
|
||||
Action::Hidden
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Classifier for AptInstallClassifier {
|
||||
fn feed(&mut self, _stream: Stream, line: &str) -> Vec<Action> {
|
||||
static SUMMARY_RE: OnceLock<Regex> = OnceLock::new();
|
||||
let summary_re = SUMMARY_RE.get_or_init(|| {
|
||||
Regex::new(r"(\d+) (?:upgraded|newly installed|re-installed)").unwrap()
|
||||
});
|
||||
static UNPACK_RE: OnceLock<Regex> = OnceLock::new();
|
||||
let unpack_re =
|
||||
UNPACK_RE.get_or_init(|| Regex::new(r"^Unpacking ([^ ]+) \(([^)]+)\)").unwrap());
|
||||
static SETUP_RE: OnceLock<Regex> = OnceLock::new();
|
||||
let setup_re =
|
||||
SETUP_RE.get_or_init(|| Regex::new(r"^Setting up ([^ ]+) \(([^)]+)\)").unwrap());
|
||||
|
||||
if summary_re.is_match(line) && !self.label.is_empty() {
|
||||
// Only accept the summary once: later lines may repeat counts
|
||||
if self.total == 0 {
|
||||
let total: u64 = summary_re
|
||||
.captures_iter(line)
|
||||
.filter_map(|c| c[1].parse::<u64>().ok())
|
||||
.sum();
|
||||
self.total = total;
|
||||
vec![Action::Shown(format!("{}: {} packages", self.label, total))]
|
||||
} else {
|
||||
vec![Action::Hidden]
|
||||
}
|
||||
} else if let Some(caps) = unpack_re.captures(line) {
|
||||
self.done += 1;
|
||||
vec![
|
||||
Action::Shown(format!(
|
||||
"{}: unpacking {} ({})",
|
||||
self.label, &caps[1], &caps[2]
|
||||
)),
|
||||
self.progress(),
|
||||
]
|
||||
} else if let Some(caps) = setup_re.captures(line) {
|
||||
self.done += 1;
|
||||
vec![
|
||||
Action::Shown(format!(
|
||||
"{}: setting up {} ({})",
|
||||
self.label, &caps[1], &caps[2]
|
||||
)),
|
||||
self.progress(),
|
||||
]
|
||||
} else if let Some(severity) = apt_severity(line) {
|
||||
vec![severity]
|
||||
} else {
|
||||
vec![Action::Hidden]
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Classifier for `quilt push -a` output
|
||||
///
|
||||
/// Driven by the number of patches listed in `debian/patches/series`, known
|
||||
/// before the command runs.
|
||||
pub struct QuiltClassifier {
|
||||
total: u64,
|
||||
applied: u64,
|
||||
}
|
||||
|
||||
impl QuiltClassifier {
|
||||
/// Create a classifier expecting `total` patches
|
||||
pub fn new(total: usize) -> Self {
|
||||
Self {
|
||||
total: total as u64,
|
||||
applied: 0,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Classifier for QuiltClassifier {
|
||||
fn feed(&mut self, _stream: Stream, line: &str) -> Vec<Action> {
|
||||
static APPLYING_RE: OnceLock<Regex> = OnceLock::new();
|
||||
let applying_re =
|
||||
APPLYING_RE.get_or_init(|| Regex::new(r"^Applying patch ([^ ]+)").unwrap());
|
||||
|
||||
if line.contains("failed") || line.contains("Failed") {
|
||||
// Check failures first: "Applying patch x failed" must not be
|
||||
// counted as a successful application
|
||||
vec![Action::Error(truncate(line))]
|
||||
} else if let Some(caps) = applying_re.captures(line) {
|
||||
self.applied += 1;
|
||||
let mut actions = vec![Action::Shown(format!("Applying patch {}", &caps[1]))];
|
||||
if self.total > 0 {
|
||||
actions.push(Action::Progress {
|
||||
pos: self.applied.min(self.total),
|
||||
total: self.total,
|
||||
});
|
||||
}
|
||||
actions
|
||||
} else if line.starts_with("Now at patch") {
|
||||
vec![Action::Shown(truncate(line))]
|
||||
} else {
|
||||
vec![Action::Hidden]
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Classifier for make/cmake-based builds (`debian/rules build`, dh helpers)
|
||||
///
|
||||
/// Detects `[ 42%]`-style progress markers, hides directory enter/leave
|
||||
/// noise, and shows compile/link/dh lines.
|
||||
#[derive(Default)]
|
||||
pub struct MakeClassifier {}
|
||||
|
||||
impl MakeClassifier {
|
||||
/// Create a new classifier
|
||||
pub fn new() -> Self {
|
||||
Self::default()
|
||||
}
|
||||
}
|
||||
|
||||
impl Classifier for MakeClassifier {
|
||||
fn feed(&mut self, _stream: Stream, line: &str) -> Vec<Action> {
|
||||
static PERCENT_RE: OnceLock<Regex> = OnceLock::new();
|
||||
let percent_re = PERCENT_RE.get_or_init(|| Regex::new(r"\[\s*(\d+)%\]").unwrap());
|
||||
|
||||
if let Some(caps) = percent_re.captures(line) {
|
||||
let pct: u64 = caps[1].parse().unwrap_or(0);
|
||||
return vec![
|
||||
Action::Shown(truncate(line)),
|
||||
Action::Progress {
|
||||
pos: pct,
|
||||
total: 100,
|
||||
},
|
||||
];
|
||||
}
|
||||
|
||||
if line.contains("make[")
|
||||
&& (line.contains("Entering directory") || line.contains("Leaving directory"))
|
||||
{
|
||||
return vec![Action::Hidden];
|
||||
}
|
||||
|
||||
if line.contains("error:")
|
||||
|| line.contains("Error ")
|
||||
|| line.contains("*** [")
|
||||
|| line.contains("failed")
|
||||
{
|
||||
return vec![Action::Error(truncate(line))];
|
||||
}
|
||||
|
||||
if line.starts_with("dh_")
|
||||
|| line.contains("gcc ")
|
||||
|| line.contains("g++ ")
|
||||
|| line.contains("cc ")
|
||||
|| line.contains("clang")
|
||||
|| line.contains("ld ")
|
||||
|| line.contains("ar ")
|
||||
{
|
||||
return vec![Action::Shown(truncate(line))];
|
||||
}
|
||||
|
||||
vec![Action::Hidden]
|
||||
}
|
||||
}
|
||||
|
||||
/// Classifier for `mmdebstrap` output (chroot tarball creation)
|
||||
///
|
||||
/// mmdebstrap prefixes its own messages with `I:` / `W:` / `E:`; everything
|
||||
/// else is chroot-internal apt/dpkg noise.
|
||||
#[derive(Default)]
|
||||
pub struct MmdebstrapClassifier {}
|
||||
|
||||
impl MmdebstrapClassifier {
|
||||
/// Create a new classifier
|
||||
pub fn new() -> Self {
|
||||
Self::default()
|
||||
}
|
||||
}
|
||||
|
||||
impl Classifier for MmdebstrapClassifier {
|
||||
fn feed(&mut self, _stream: Stream, line: &str) -> Vec<Action> {
|
||||
if let Some(rest) = line.strip_prefix("I: ") {
|
||||
vec![Action::Shown(truncate(rest))]
|
||||
} else if let Some(rest) = line.strip_prefix("W: ") {
|
||||
vec![Action::Warning(truncate(rest))]
|
||||
} else if let Some(rest) = line.strip_prefix("E: ") {
|
||||
vec![Action::Error(truncate(rest))]
|
||||
} else if line.starts_with("Setting up ") {
|
||||
vec![Action::Shown(truncate(line))]
|
||||
} else {
|
||||
vec![Action::Hidden]
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Generic fallback classifier: shows the last meaningful line and surfaces
|
||||
/// obvious error/warning patterns.
|
||||
#[derive(Default)]
|
||||
pub struct GenericClassifier {}
|
||||
|
||||
impl GenericClassifier {
|
||||
/// Create a new classifier
|
||||
pub fn new() -> Self {
|
||||
Self::default()
|
||||
}
|
||||
}
|
||||
|
||||
impl Classifier for GenericClassifier {
|
||||
fn feed(&mut self, _stream: Stream, line: &str) -> Vec<Action> {
|
||||
if line.starts_with("E:")
|
||||
|| line.contains("error:")
|
||||
|| line.contains("Error ")
|
||||
|| line.contains("failed")
|
||||
{
|
||||
vec![Action::Error(truncate(line))]
|
||||
} else if line.starts_with("W:") {
|
||||
vec![Action::Warning(truncate(line))]
|
||||
} else {
|
||||
vec![Action::Shown(truncate(line))]
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn feed_one(c: &mut dyn Classifier, line: &str) -> Vec<Action> {
|
||||
c.feed(Stream::Stdout, line)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_apt_update_collapses_sources_and_surfaces_errors() {
|
||||
let mut c = AptUpdateClassifier::new();
|
||||
assert_eq!(
|
||||
feed_one(&mut c, "Hit:1 http://archive.ubuntu.com noble InRelease"),
|
||||
vec![Action::Shown(
|
||||
"Updating package lists… (1 sources)".to_string()
|
||||
)]
|
||||
);
|
||||
assert_eq!(
|
||||
feed_one(
|
||||
&mut c,
|
||||
"Get:2 http://security.ubuntu.com noble-security InRelease"
|
||||
),
|
||||
vec![Action::Shown(
|
||||
"Updating package lists… (2 sources)".to_string()
|
||||
)]
|
||||
);
|
||||
assert_eq!(
|
||||
feed_one(&mut c, "E: Repository 'x' changed its 'suite' value"),
|
||||
vec![Action::Error(
|
||||
"E: Repository 'x' changed its 'suite' value".to_string()
|
||||
)]
|
||||
);
|
||||
assert_eq!(
|
||||
feed_one(&mut c, "Reading package lists..."),
|
||||
vec![Action::Hidden]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_apt_install_counts_packages() {
|
||||
let mut c = AptInstallClassifier::new("Installing build dependencies");
|
||||
// Summary line sets the total
|
||||
assert_eq!(
|
||||
feed_one(
|
||||
&mut c,
|
||||
"2 upgraded, 3 newly installed, 0 to remove and 0 not upgraded."
|
||||
),
|
||||
vec![Action::Shown(
|
||||
"Installing build dependencies: 5 packages".to_string()
|
||||
)]
|
||||
);
|
||||
// Unpacking and setting up drive progress
|
||||
assert_eq!(
|
||||
feed_one(&mut c, "Unpacking libfoo (1.2-3)"),
|
||||
vec![
|
||||
Action::Shown(
|
||||
"Installing build dependencies: unpacking libfoo (1.2-3)".to_string()
|
||||
),
|
||||
Action::Progress { pos: 1, total: 5 }
|
||||
]
|
||||
);
|
||||
assert_eq!(
|
||||
feed_one(&mut c, "Setting up libfoo (1.2-3)"),
|
||||
vec![
|
||||
Action::Shown(
|
||||
"Installing build dependencies: setting up libfoo (1.2-3)".to_string()
|
||||
),
|
||||
Action::Progress { pos: 2, total: 5 }
|
||||
]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_quilt_counts_patches() {
|
||||
let mut c = QuiltClassifier::new(2);
|
||||
assert_eq!(
|
||||
feed_one(&mut c, "Applying patch debian/patches/foo.patch"),
|
||||
vec![
|
||||
Action::Shown("Applying patch debian/patches/foo.patch".to_string()),
|
||||
Action::Progress { pos: 1, total: 2 }
|
||||
]
|
||||
);
|
||||
assert_eq!(
|
||||
feed_one(&mut c, "Applying patch debian/patches/bar.patch"),
|
||||
vec![
|
||||
Action::Shown("Applying patch debian/patches/bar.patch".to_string()),
|
||||
Action::Progress { pos: 2, total: 2 }
|
||||
]
|
||||
);
|
||||
assert_eq!(
|
||||
feed_one(&mut c, "Applying patch x failed"),
|
||||
vec![Action::Error("Applying patch x failed".to_string())]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_make_detects_percent_and_hides_noise() {
|
||||
let mut c = MakeClassifier::new();
|
||||
assert_eq!(
|
||||
feed_one(
|
||||
&mut c,
|
||||
"[ 42%] Building CXX object CMakeFiles/hello.dir/hello.o"
|
||||
),
|
||||
vec![
|
||||
Action::Shown(
|
||||
"[ 42%] Building CXX object CMakeFiles/hello.dir/hello.o".to_string()
|
||||
),
|
||||
Action::Progress {
|
||||
pos: 42,
|
||||
total: 100
|
||||
}
|
||||
]
|
||||
);
|
||||
assert_eq!(
|
||||
feed_one(&mut c, "make[2]: Entering directory '/tmp/build'"),
|
||||
vec![Action::Hidden]
|
||||
);
|
||||
assert_eq!(
|
||||
feed_one(&mut c, "make[1]: *** [Makefile:531: hello.o] Error 1"),
|
||||
vec![Action::Error(
|
||||
"make[1]: *** [Makefile:531: hello.o] Error 1".to_string()
|
||||
)]
|
||||
);
|
||||
assert_eq!(
|
||||
feed_one(&mut c, "dh_auto_build"),
|
||||
vec![Action::Shown("dh_auto_build".to_string())]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_mmdebstrap_prefixes() {
|
||||
let mut c = MmdebstrapClassifier::new();
|
||||
assert_eq!(
|
||||
feed_one(&mut c, "I: chroot architecture is amd64"),
|
||||
vec![Action::Shown("chroot architecture is amd64".to_string())]
|
||||
);
|
||||
assert_eq!(
|
||||
feed_one(&mut c, "W: some warning"),
|
||||
vec![Action::Warning("some warning".to_string())]
|
||||
);
|
||||
assert_eq!(
|
||||
feed_one(&mut c, "Get:1 http://x InRelease"),
|
||||
vec![Action::Hidden]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_generic_shows_lines_and_errors() {
|
||||
let mut c = GenericClassifier::new();
|
||||
assert_eq!(
|
||||
feed_one(&mut c, "some random output"),
|
||||
vec![Action::Shown("some random output".to_string())]
|
||||
);
|
||||
assert_eq!(
|
||||
feed_one(&mut c, "something failed badly"),
|
||||
vec![Action::Error("something failed badly".to_string())]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_truncate_long_lines() {
|
||||
let long = "x".repeat(300);
|
||||
let truncated = truncate(&long);
|
||||
assert_eq!(truncated.chars().count(), MAX_LINE_WIDTH);
|
||||
assert!(truncated.ends_with('…'));
|
||||
assert_eq!(truncate("short"), "short");
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user