style: apply rustfmt code formatting

Applied automatic code formatting across multiple files to improve consistency and readability, including proper indentation, line breaks, and spacing according to Rust style guidelines.

Author: guonaihong

src/engine.rs

@@ -8,6 +8,7 @@ use crate::template::TemplateEngine;
 use crate::ui::LiveUI;
 use anyhow::Result;
 use rand::Rng;
+use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::Arc;
 use std::time::{Duration, Instant};
 use tokio::sync::mpsc;
@@ -91,7 +92,6 @@ pub async fn run_benchmark(args: Args) -> Result<()> {
         final_stats.print_summary(args.latency);
     } else {
         // Print final summary after UI exits
-        println!("\n=== Final Results ===");
         final_stats.print_summary(args.latency);
     }
 
@@ -287,15 +287,28 @@ async fn run_benchmark_with_ui(
     let shared_stats = create_shared_stats();
     let shared_stats_for_ui = shared_stats.clone();
 
+    // Create stop flag for early termination (Ctrl+C)
+    let stop_flag = Arc::new(AtomicBool::new(false));
+    let stop_flag_for_ui = stop_flag.clone();
+
     // Create channel for UI updates (send cloned stats snapshot)
     let (ui_tx, ui_rx) = mpsc::channel(100);
 
     // Spawn UI task
     let ui_handle = tokio::spawn(async move {
         let mut ui = LiveUI::new(ui_rx, duration);
-        if let Err(e) = ui.run().await {
-            eprintln!("UI error: {}", e);
-        }
+        let result = match ui.run().await {
+            Ok(interrupted) => interrupted,
+            Err(e) => {
+                eprintln!("UI error: {}", e);
+                false
+            }
+        };
+
+        // Set stop flag when UI exits (either interrupted or completed)
+        stop_flag_for_ui.store(true, Ordering::Release);
+
+        result
     });
 
     // Spawn stats updater task
@@ -339,6 +352,7 @@ async fn run_benchmark_with_ui(
             template_engine,
             enable_http2,
             shared_stats,
+            stop_flag,
         )
     })
     .await??;
@@ -353,8 +367,15 @@ async fn run_benchmark_with_ui(
     // Wait a bit for UI to render final update
     tokio::time::sleep(Duration::from_millis(200)).await;
 
-    // Wait for UI to finish
-    let _ = ui_handle.await;
+    // Wait for UI to finish and get interrupted status
+    let interrupted = ui_handle.await.unwrap_or(false);
+
+    // Print message based on whether test was interrupted
+    if interrupted {
+        println!("\n=== Test Interrupted (Ctrl+C) ===");
+    } else {
+        println!("\n=== Test Completed ===");
+    }
 
     Ok(final_stats)
 }
@@ -370,6 +391,7 @@ fn run_workers_with_ui_updates(
     template_engine: Arc<TemplateEngine>,
     enable_http2: bool,
     shared_stats: SharedStats,
+    stop_flag: Arc<AtomicBool>,
 ) -> Result<Statistics> {
     let commands = Arc::new(commands);
     let end_time = Instant::now() + duration;
@@ -404,6 +426,7 @@ fn run_workers_with_ui_updates(
             let load_strategy = load_strategy.clone();
             let template_engine = template_engine.clone();
             let pool = pool.clone();
+            let stop_flag = stop_flag.clone();
 
             // 为每个线程创建独立的 tokio 运行时
             std::thread::spawn(move || {
@@ -421,13 +444,14 @@ fn run_workers_with_ui_updates(
                     let load_strategy = load_strategy.clone();
                     let template_engine = template_engine.clone();
                     let client = pool.get_client().clone();
+                    let stop_flag = stop_flag.clone();
 
                     local.spawn_local(async move {
                         // 创建客户端状态用于连接复用
                         let mut client_state = ClientState::new();
                         let mut request_count = 0u64;
 
-                        while Instant::now() < end_time {
+                        while Instant::now() < end_time && !stop_flag.load(Ordering::Acquire) {
                             // Select command based on load strategy
                             let cmd = match load_strategy.as_str() {
                                 "round-robin" => &commands[request_count as usize % commands.len()],

src/ui.rs

@@ -236,7 +236,8 @@ impl LiveUI {
     }
 
     /// Run the Live-UI main loop
-    pub async fn run(&mut self) -> Result<()> {
+    /// Returns true if interrupted by user (Ctrl+C), false if completed normally
+    pub async fn run(&mut self) -> Result<bool> {
         // Setup terminal
         enable_raw_mode()?;
         let mut stdout = std::io::stdout();
@@ -259,9 +260,13 @@ impl LiveUI {
         let mut last_request_count = 0u64;
         let mut last_rps_update = Instant::now();
 
+        // Track if interrupted by user
+        let mut interrupted = false;
+
         loop {
             // Check if we should stop
             if self.should_stop {
+                interrupted = true;
                 break;
             }
 
@@ -335,7 +340,7 @@ impl LiveUI {
         disable_raw_mode()?;
         execute!(terminal.backend_mut(), LeaveAlternateScreen)?;
 
-        Ok(())
+        Ok(interrupted)
     }
 
     /// Render the UI
@@ -594,36 +599,20 @@ impl LiveUI {
 
         let max_value = history.iter().copied().fold(0.0f64, f64::max).max(1.0);
 
-        // Build title with max value indicator
-        let formatted_max = if max_value >= 1_000_000.0 {
-            format!("{:.1}M", max_value / 1_000_000.0)
-        } else if max_value >= 1_000.0 {
-            format!("{:.1}K", max_value / 1_000.0)
-        } else {
-            format!("{:.1}", max_value)
-        };
+        // Build title with max value indicator using formatNumber rules
+        let formatted_max = format_number_f64(max_value);
         let title = format!("Request Rate (Last 10s) - Max: {} req/s", formatted_max);
 
-        // Create bar chart data - use actual TPS values, not normalized percentages
+        // Create bar chart data - label only shows time (1s, 2s, etc.)
         let bar_data: Vec<(String, u64)> = history
             .iter()
             .enumerate()
             .map(|(i, &value)| {
-                // Format TPS value with K/M suffix
-                let tps_str = if value >= 1_000_000.0 {
-                    format!("{:.0}M", value / 1_000_000.0)
-                } else if value >= 1_000.0 {
-                    format!("{:.0}K", value / 1_000.0)
-                } else {
-                    format!("{:.0}", value)
-                };
-
-                // Label with time and formatted TPS: "1s\n92K"
-                let label = format!("{}s\n{}", i + 1, tps_str);
+                // Label only shows time
+                let label = format!("{}s", i + 1);
 
-                // Use actual TPS value (as integer) for bar height
-                let tps_value = value as u64;
-                (label, tps_value)
+                // Use actual TPS value for bar height
+                (label, value as u64)
             })
             .collect();
 
@@ -641,17 +630,56 @@ impl LiveUI {
                     .title(title),
             )
             .data(&bar_data_refs)
-            .bar_width(3)
+            .bar_width(6)
             .bar_gap(1)
             .bar_style(Style::default().fg(self.theme.highlight_color()))
-            .value_style(
-                Style::default()
-                    .fg(self.theme.text_color())
-                    .add_modifier(Modifier::BOLD),
-            )
-            .label_style(Style::default().fg(self.theme.text_color()));
+            .label_style(Style::default().fg(self.theme.text_color()))
+            .value_style(Style::default().fg(Color::Black).bg(Color::Black)); // Hide raw values
 
         f.render_widget(bar_chart, area);
+
+        // Manually render formatted numbers on top of bars
+        let bar_width = 6u16;
+        let bar_gap = 1u16;
+        let total_bar_unit = bar_width + bar_gap;
+
+        // Calculate starting position for bars
+        let inner_area = Rect {
+            x: area.x + 1,
+            y: area.y + 1,
+            width: area.width.saturating_sub(2),
+            height: area.height.saturating_sub(2),
+        };
+
+        // Render formatted numbers above each bar
+        for (i, &value) in history.iter().enumerate() {
+            let formatted = format_number_f64(value);
+            let bar_x = inner_area.x + 2 + (i as u16 * total_bar_unit);
+
+            // Calculate bar height as percentage of available height
+            let chart_height = inner_area.height.saturating_sub(2); // Leave space for labels
+            let bar_height_ratio = (value / max_value).min(1.0);
+            let bar_height = (chart_height as f64 * bar_height_ratio) as u16;
+
+            // Position text on top of bar
+            let text_y = inner_area.y + chart_height.saturating_sub(bar_height).saturating_sub(1);
+
+            if bar_x < inner_area.x + inner_area.width && text_y < inner_area.y + inner_area.height
+            {
+                let text_area = Rect {
+                    x: bar_x,
+                    y: text_y,
+                    width: bar_width,
+                    height: 1,
+                };
+
+                let text = Paragraph::new(formatted)
+                    .style(Style::default().fg(self.theme.text_color()))
+                    .alignment(Alignment::Center);
+
+                f.render_widget(text, text_area);
+            }
+        }
     }
 
     /// Render latency histogram (percentiles)
@@ -816,14 +844,23 @@ impl LiveUI {
     }
 }
 
-/// Format large numbers with K/M suffix
+/// Format large numbers with K/M suffix (for u64)
 fn format_number(n: u64) -> String {
-    if n >= 1_000_000 {
-        format!("{:.1}M", n as f64 / 1_000_000.0)
-    } else if n >= 1_000 {
-        format!("{:.1}K", n as f64 / 1_000.0)
+    format_number_f64(n as f64)
+}
+
+/// Format large numbers with K/M suffix (for f64)
+/// Follows the formatting rules:
+/// - >= 1M: show with 1 decimal place (e.g., "1.5M")
+/// - >= 1K: show with no decimal places (e.g., "24K")
+/// - < 1K: show as integer (e.g., "500")
+fn format_number_f64(n: f64) -> String {
+    if n >= 1_000_000.0 {
+        format!("{:.1}M", n / 1_000_000.0)
+    } else if n >= 1_000.0 {
+        format!("{:.0}K", n / 1_000.0)
     } else {
-        n.to_string()
+        format!("{:.0}", n)
     }
 }