use crate::{DryRunAction, DryRunStatus, Impact, InvariantError, NodeId};
use std::collections::HashMap;
use std::io::{self, Write};
use std::time::Instant;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ProgressMode {
Describe,
DryRun,
Execute,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ProgressPlanOutcome {
Complete,
Incomplete,
Failed,
}
impl From<DryRunStatus> for ProgressPlanOutcome {
fn from(status: DryRunStatus) -> Self {
match status {
DryRunStatus::Complete => Self::Complete,
DryRunStatus::Incomplete => Self::Incomplete,
DryRunStatus::Failed => Self::Failed,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct ProgressNode<'a> {
node: NodeId,
position: usize,
total: usize,
name: &'a str,
impact: Impact,
}
impl<'a> ProgressNode<'a> {
pub(crate) fn new(
node: NodeId,
position: usize,
total: usize,
name: &'a str,
impact: Impact,
) -> Self {
Self {
node,
position,
total,
name,
impact,
}
}
pub fn node(&self) -> NodeId {
self.node
}
pub fn position(&self) -> usize {
self.position
}
pub fn total(&self) -> usize {
self.total
}
pub fn name(&self) -> &'a str {
self.name
}
pub fn impact(&self) -> Impact {
self.impact
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ProgressOutcome<'a, E> {
Described {
dry_run_action: Option<DryRunAction>,
},
Executed,
Skipped {
reason: &'a str,
},
Denied {
reason: &'a str,
},
Blocked {
missing_dependencies: &'a [NodeId],
},
UnavailableDependencies {
missing_dependencies: &'a [NodeId],
},
Failed {
error: &'a E,
},
Internal {
error: &'a InvariantError,
},
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ProgressEvent<'a, E> {
PlanStarted {
mode: ProgressMode,
plan_name: &'a str,
total_nodes: usize,
},
NodeDescribed {
mode: ProgressMode,
node: ProgressNode<'a>,
outcome: ProgressOutcome<'a, E>,
},
NodeStarted {
mode: ProgressMode,
node: ProgressNode<'a>,
},
NodeFinished {
mode: ProgressMode,
node: ProgressNode<'a>,
outcome: ProgressOutcome<'a, E>,
},
PlanFinished {
mode: ProgressMode,
plan_name: &'a str,
total_nodes: usize,
outcome: ProgressPlanOutcome,
},
}
pub trait ProgressListener<E> {
fn on_event(&mut self, event: ProgressEvent<'_, E>);
}
impl<E, F> ProgressListener<E> for F
where
F: for<'a> FnMut(ProgressEvent<'a, E>),
{
fn on_event(&mut self, event: ProgressEvent<'_, E>) {
self(event);
}
}
#[derive(Debug, Default, Clone, Copy)]
pub struct NoopProgress;
impl<E> ProgressListener<E> for NoopProgress {
fn on_event(&mut self, _event: ProgressEvent<'_, E>) {}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct ConsoleProgressOptions {
pub github_actions: bool,
pub show_elapsed: bool,
pub show_impact: bool,
}
impl Default for ConsoleProgressOptions {
fn default() -> Self {
Self {
github_actions: std::env::var_os("GITHUB_ACTIONS").is_some(),
show_elapsed: true,
show_impact: true,
}
}
}
#[derive(Debug, Default)]
pub struct ConsoleProgress {
options: ConsoleProgressOptions,
starts: HashMap<NodeId, Instant>,
}
impl ConsoleProgress {
pub fn new() -> Self {
Self::with_options(ConsoleProgressOptions::default())
}
pub fn with_options(options: ConsoleProgressOptions) -> Self {
Self {
options,
starts: HashMap::new(),
}
}
fn print_started(&mut self, mode: ProgressMode, node: ProgressNode<'_>) {
self.starts.insert(node.node(), Instant::now());
if self.options.github_actions {
println!(
"::notice title=rehearse::{} [{}/{}] {} ({}) started",
mode_label(mode),
node.position(),
node.total(),
node.name(),
node.impact()
);
return;
}
if self.options.show_impact {
print!(
"[{} {}/{}] {} ({}) ... ",
mode_label(mode),
node.position(),
node.total(),
node.name(),
node.impact()
);
} else {
print!(
"[{} {}/{}] {} ... ",
mode_label(mode),
node.position(),
node.total(),
node.name()
);
}
drop(io::stdout().flush());
}
fn print_finished<E>(
&mut self,
mode: ProgressMode,
node: ProgressNode<'_>,
outcome: ProgressOutcome<'_, E>,
) {
let status = progress_status(outcome);
if self.options.github_actions {
println!(
"::notice title=rehearse::{} [{}/{}] {} {status}",
mode_label(mode),
node.position(),
node.total(),
node.name()
);
return;
}
if self.options.show_elapsed {
let elapsed = self
.starts
.remove(&node.node())
.map(|start| start.elapsed())
.unwrap_or_default();
println!("{status} ({} ms)", elapsed.as_millis());
} else {
println!("{status}");
}
}
}
impl<E> ProgressListener<E> for ConsoleProgress {
fn on_event(&mut self, event: ProgressEvent<'_, E>) {
match event {
ProgressEvent::NodeStarted { mode, node }
if matches!(mode, ProgressMode::DryRun | ProgressMode::Execute) =>
{
self.print_started(mode, node);
}
ProgressEvent::NodeFinished {
mode,
node,
outcome,
} if matches!(mode, ProgressMode::DryRun | ProgressMode::Execute) => {
self.print_finished(mode, node, outcome);
}
_ => {}
}
}
}
fn mode_label(mode: ProgressMode) -> &'static str {
match mode {
ProgressMode::Describe => "describe",
ProgressMode::DryRun => "dry-run",
ProgressMode::Execute => "execute",
}
}
fn progress_status<E>(outcome: ProgressOutcome<'_, E>) -> &'static str {
match outcome {
ProgressOutcome::Described { .. } => "described",
ProgressOutcome::Executed => "ok",
ProgressOutcome::Skipped { .. } => "skipped",
ProgressOutcome::Denied { .. } => "denied",
ProgressOutcome::Blocked { .. } => "blocked",
ProgressOutcome::UnavailableDependencies { .. } => "unavailable dependencies",
ProgressOutcome::Failed { .. } => "failed",
ProgressOutcome::Internal { .. } => "internal error",
}
}