#![cfg(feature = "tui")]
use std::{
borrow::Cow,
collections::VecDeque,
fmt::Write as _,
io::IsTerminal,
sync::{
Arc, Mutex,
atomic::{AtomicBool, AtomicU64, Ordering},
},
time::{Duration, Instant},
};
use tokio::task::JoinHandle;
use crate::{
report::{bar, fmt_duration, paint},
shutdown::Shutdown,
};
#[derive(Clone, Debug)]
pub struct LogChannel {
inner: Arc<Mutex<LogBuf>>,
}
#[derive(Debug)]
struct LogBuf {
lines: VecDeque<String>,
max_lines: usize,
}
impl Default for LogChannel {
fn default() -> Self {
Self::with_capacity(200)
}
}
impl LogChannel {
pub fn with_capacity(max_lines: usize) -> Self {
Self {
inner: Arc::new(Mutex::new(LogBuf {
lines: VecDeque::with_capacity(max_lines.min(1024)),
max_lines,
})),
}
}
pub fn push_line(&self, line: impl Into<String>) {
let mut buf = self.inner.lock().unwrap();
let line = line.into();
let line = line.strip_suffix('\n').unwrap_or(&line).to_string();
if buf.lines.len() == buf.max_lines {
buf.lines.pop_front();
}
buf.lines.push_back(line);
}
pub fn lines(&self) -> Vec<String> {
self.inner.lock().unwrap().lines.iter().cloned().collect()
}
pub fn drain(&self) -> Vec<String> {
let mut buf = self.inner.lock().unwrap();
buf.lines.drain(..).collect()
}
}
impl std::io::Write for LogChannel {
fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
let text = String::from_utf8_lossy(buf);
for line in text.split('\n') {
if !line.is_empty() {
self.push_line(line);
}
}
Ok(buf.len())
}
fn flush(&mut self) -> std::io::Result<()> {
Ok(())
}
}
#[derive(Debug, Clone, Copy)]
pub(crate) enum ProgressPlan {
Rounds(u64),
Time(Duration),
}
#[derive(Clone, Debug)]
pub struct Progress {
inner: Arc<Inner>,
}
#[derive(Debug)]
struct Inner {
name: Cow<'static, str>,
plan: ProgressPlan,
scenario_index: usize,
scenario_total: usize,
started: Instant,
rounds: AtomicU64,
success: AtomicU64,
failures: AtomicU64,
timeouts: AtomicU64,
validate_failures: AtomicU64,
teardown_failures: AtomicU64,
in_flight: AtomicU64,
in_setup: AtomicU64,
stop: AtomicBool,
log: Option<LogChannel>,
}
impl Progress {
pub(crate) fn new(
name: impl Into<Cow<'static, str>>,
plan: ProgressPlan,
log: Option<LogChannel>,
scenario_index: usize,
scenario_total: usize,
) -> Self {
Self {
inner: Arc::new(Inner {
name: name.into(),
plan,
scenario_index,
scenario_total,
started: Instant::now(),
rounds: AtomicU64::new(0),
success: AtomicU64::new(0),
failures: AtomicU64::new(0),
timeouts: AtomicU64::new(0),
validate_failures: AtomicU64::new(0),
teardown_failures: AtomicU64::new(0),
in_flight: AtomicU64::new(0),
in_setup: AtomicU64::new(0),
stop: AtomicBool::new(false),
log,
}),
}
}
#[cfg(feature = "tui")]
pub(crate) fn start_tui(
&self,
channel: crate::LogChannel,
options: crate::tui::TuiOptions,
shutdown: Option<Shutdown>,
) -> ProgressGuard {
if !std::io::stderr().is_terminal() {
return ProgressGuard {
inner: Arc::clone(&self.inner),
handle: None,
};
}
let inner = Arc::clone(&self.inner);
let task_inner = Arc::clone(&inner);
let handle = tokio::spawn(async move {
let mut writer = std::io::stderr();
let _ = std::io::Write::write(&mut writer, b"\x1b[?1049h");
let _ = std::io::Write::flush(&mut writer);
loop {
let stopping = shutdown.as_ref().is_some_and(|s| s.is_cancelled());
let line = render_line(&task_inner, stopping, options.color, options.bar_width);
let frame = crate::tui::render_frame(&line, &channel, &options);
let text = format!("\x1b[H\x1b[2J{frame}");
let _ = std::io::Write::write(&mut writer, text.as_bytes());
let _ = std::io::Write::flush(&mut writer);
if task_inner.stop.load(Ordering::Relaxed) {
break;
}
tokio::time::sleep(options.refresh).await;
}
let _ = std::io::Write::write(&mut writer, b"\x1b[?1049l");
let _ = std::io::Write::flush(&mut writer);
});
ProgressGuard {
inner,
handle: Some(handle),
}
}
pub(crate) fn begin_round(&self) {
self.inner.in_flight.fetch_add(1, Ordering::Relaxed);
}
pub(crate) fn end_round(&self) {
self.inner.in_flight.fetch_sub(1, Ordering::Relaxed);
}
pub(crate) fn begin_setup(&self) {
self.inner.in_setup.fetch_add(1, Ordering::Relaxed);
}
pub(crate) fn end_setup(&self) {
self.inner.in_setup.fetch_sub(1, Ordering::Relaxed);
}
pub(crate) fn round_recorded(&self) {
self.inner.rounds.fetch_add(1, Ordering::Relaxed);
}
pub(crate) fn result_recorded(&self, ok: bool) {
if ok {
self.inner.success.fetch_add(1, Ordering::Relaxed);
} else {
self.inner.failures.fetch_add(1, Ordering::Relaxed);
}
}
pub(crate) fn timeout_recorded(&self) {
self.inner.timeouts.fetch_add(1, Ordering::Relaxed);
}
pub(crate) fn validate_recorded(&self, ok: bool) {
if !ok {
self.inner.validate_failures.fetch_add(1, Ordering::Relaxed);
}
}
pub(crate) fn teardown_recorded(&self, ok: bool) {
if !ok {
self.inner.teardown_failures.fetch_add(1, Ordering::Relaxed);
}
}
pub(crate) fn push_log(&self, line: &str) -> bool {
if let Some(channel) = &self.inner.log {
channel.push_line(format!("[{} {line}]", now_hms()));
true
} else {
false
}
}
}
pub(crate) struct ProgressGuard {
inner: Arc<Inner>,
handle: Option<JoinHandle<()>>,
}
impl ProgressGuard {
pub(crate) async fn stop(mut self) {
self.inner.stop.store(true, Ordering::Relaxed);
if let Some(handle) = self.handle.take() {
let _ = handle.await;
}
}
}
impl Drop for ProgressGuard {
fn drop(&mut self) {
self.inner.stop.store(true, Ordering::Relaxed);
if let Some(handle) = self.handle.take() {
handle.abort();
}
}
}
const NAME_WIDTH: usize = 20;
fn render_line(inner: &Inner, stopping: bool, color: bool, bar_width: usize) -> String {
let name = fit_name(&inner.name);
let mut line = String::with_capacity(128);
if inner.scenario_total > 1 {
let _ = write!(
line,
"[{}/{}] ",
inner.scenario_index + 1,
inner.scenario_total
);
}
if inner.in_setup.load(Ordering::Relaxed) > 0 {
let _ = write!(line, "{name} {}", paint("setup...", "33", color));
return line;
}
let elapsed = inner.started.elapsed();
let rounds = inner.rounds.load(Ordering::Relaxed);
let (fraction, progress) = match inner.plan {
ProgressPlan::Rounds(total) => (ratio(rounds, total), format!("{rounds}/{total}")),
ProgressPlan::Time(planned) => (
ratio(elapsed.as_millis() as u64, planned.as_millis() as u64),
format!("{}/{}", fmt_duration(elapsed), fmt_duration(planned)),
),
};
let _ = write!(
line,
"{name} [{}] {:>5.1}% {progress:>15} {:>7} req/s",
bar(fraction, bar_width),
fraction * 100.0,
rate(rounds, elapsed),
);
if rounds > 0 {
let passed = inner
.success
.load(Ordering::Relaxed)
.saturating_sub(inner.validate_failures.load(Ordering::Relaxed));
let err = inner.failures.load(Ordering::Relaxed)
+ inner.validate_failures.load(Ordering::Relaxed);
let timeouts = inner.timeouts.load(Ordering::Relaxed);
let _ = write!(line, " succ {passed}");
if err > 0 {
let _ = write!(line, " {}", paint(&format!("err {err}"), "31", color));
}
if timeouts > 0 {
let _ = write!(
line,
" {}",
paint(&format!("timeout {timeouts}"), "33", color)
);
}
let teardown_failures = inner.teardown_failures.load(Ordering::Relaxed);
if teardown_failures > 0 {
let _ = write!(
line,
" {}",
paint(&format!("cleanup {teardown_failures}"), "31", color)
);
}
}
let in_flight = inner.in_flight.load(Ordering::Relaxed);
if in_flight > 0 {
let _ = write!(line, " inflight {in_flight}");
}
if stopping {
let _ = write!(line, " {}", paint("stopping...", "33", color));
}
line
}
fn fit_name(name: &str) -> String {
if name.chars().count() <= NAME_WIDTH {
format!("{name:<NAME_WIDTH$}")
} else {
let head: String = name.chars().take(NAME_WIDTH - 1).collect();
format!("{head}…")
}
}
fn ratio(done: u64, total: u64) -> f64 {
if total == 0 {
return 1.0;
}
(done as f64 / total as f64).clamp(0.0, 1.0)
}
fn now_hms() -> String {
let now = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap_or_default()
.as_secs();
let (h, m, s) = (now / 3600 % 24, now / 60 % 60, now % 60);
format!("{h:02}:{m:02}:{s:02}")
}
fn rate(rounds: u64, elapsed: Duration) -> u64 {
let secs = elapsed.as_secs_f64();
if secs < 0.001 {
return 0;
}
(rounds as f64 / secs) as u64
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn line_shows_rounds_percent_and_rate() {
let p = Progress::new("login", ProgressPlan::Rounds(1000), None, 1, 3);
for _ in 0..250 {
p.round_recorded();
}
for _ in 0..249 {
p.result_recorded(true);
}
p.result_recorded(false);
for _ in 0..249 {
p.validate_recorded(true);
}
for _ in 0..3 {
p.timeout_recorded();
}
let line = render_line(&p.inner, false, false, 20);
assert!(line.contains("login"), "{line}");
assert!(line.contains("[2/3]"), "{line}");
assert!(line.contains("25.0%"), "{line}");
assert!(line.contains("250/1000"), "{line}");
assert!(line.contains("req/s"), "{line}");
assert!(line.contains("succ 249"), "{line}");
assert!(line.contains("err 1"), "{line}");
assert!(line.contains("timeout 3"), "{line}");
assert!(!line.contains("fail"), "{line}");
assert!(!line.contains('\x1b'), "{line}");
assert!(!line.contains("setup"), "{line}");
assert!(!line.contains("inflight"), "{line}");
}
#[test]
fn line_reports_setup_phase_and_stopping() {
let p = Progress::new("scn", ProgressPlan::Rounds(10), None, 0, 2);
p.begin_setup();
let line = render_line(&p.inner, false, false, 20);
assert!(line.contains("setup..."), "{line}");
assert!(line.contains("[1/2]"), "{line}");
assert!(!line.contains("req/s"), "{line}");
p.end_setup();
p.begin_round();
let line = render_line(&p.inner, true, false, 20);
assert!(line.contains("inflight 1"), "{line}");
assert!(line.contains("stopping..."), "{line}");
assert!(!line.contains("succ"), "{line}");
assert!(!line.contains("err"), "{line}");
}
#[test]
fn line_shows_teardown_failures_separately() {
let p = Progress::new("scn", ProgressPlan::Rounds(10), None, 0, 1);
p.round_recorded();
p.result_recorded(true);
p.teardown_recorded(true);
p.teardown_recorded(false);
p.teardown_recorded(false);
let line = render_line(&p.inner, false, false, 20);
assert!(line.contains("cleanup 2"), "{line}");
assert!(line.contains("succ 1"), "{line}");
assert!(!line.contains("err"), "{line}");
assert!(!line.contains("fail"), "{line}");
let ok = Progress::new("ok", ProgressPlan::Rounds(10), None, 0, 1);
ok.round_recorded();
ok.teardown_recorded(true);
let line = render_line(&ok.inner, false, false, 20);
assert!(!line.contains("cleanup"), "{line}");
}
#[test]
fn duration_plan_uses_elapsed_over_planned() {
let p = Progress::new(
"dur",
ProgressPlan::Time(Duration::from_secs(600)),
None,
0,
1,
);
let line = render_line(&p.inner, false, false, 20);
assert!(line.contains("0.0%"), "{line}");
assert!(line.contains("/600000.00ms"), "{line}");
}
#[test]
fn long_name_is_truncated_to_fixed_width() {
let p = Progress::new(
"a_very_long_scenario_name_indeed",
ProgressPlan::Rounds(1),
None,
0,
3,
);
let line = render_line(&p.inner, false, false, 20);
assert!(line.starts_with("[1/3] a_very_long_scenari…"), "{line}");
}
#[test]
fn single_scenario_hides_index_badge() {
let p = Progress::new("only", ProgressPlan::Rounds(1), None, 0, 1);
let line = render_line(&p.inner, false, false, 20);
assert!(!line.contains("[1/1]"), "单场景不应显示序号: {line}");
assert!(line.starts_with("only"), "{line}");
}
#[test]
fn color_option_paints_failures() {
let p = Progress::new("scn", ProgressPlan::Rounds(1), None, 0, 1);
p.round_recorded();
p.result_recorded(false);
let line = render_line(&p.inner, false, true, 20);
assert!(line.contains("\x1b[31merr 1\x1b[0m"), "{line}");
}
#[test]
fn log_channel_ring_buffer_and_write() {
let mut channel = LogChannel::with_capacity(3);
channel.push_line("a");
channel.push_line("b");
channel.push_line("c");
channel.push_line("d"); assert_eq!(channel.lines(), vec!["b", "c", "d"]);
std::io::Write::write_all(&mut channel, b"e\nf\n").unwrap();
assert_eq!(channel.lines(), vec!["d", "e", "f"]);
assert_eq!(channel.drain(), vec!["d", "e", "f"]);
assert!(channel.lines().is_empty());
}
#[test]
fn push_log_prefixes_time_in_tui_mode() {
let channel = LogChannel::with_capacity(10);
let p = Progress::new("s", ProgressPlan::Rounds(1), Some(channel.clone()), 0, 1);
assert!(p.push_log("boom"));
let lines = channel.lines();
assert_eq!(lines.len(), 1);
assert!(lines[0].starts_with('['), "{lines:?}");
assert!(lines[0].ends_with("boom]"), "{lines:?}");
let p = Progress::new("s", ProgressPlan::Rounds(1), None, 0, 1);
assert!(!p.push_log("x"));
}
}