2.1.1

Author: shinnku-nikaidou

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "layer7benchmark"
-version = "2.0.1"
+version = "2.1.1"
 edition = "2021"
 description = "A simple benchmark tool for Layer 7 (HTTP) load testing"
 license = "MIT"

Cargo.toml

@@ -62,4 +62,7 @@ pub struct Args {
     /// Four log levels are available: error, warn, info, and debug.
     #[arg(long = "log-level", default_value = "info")]
     pub log_level: String,
+
+    #[arg(long = "normal-output", default_value_t = false)]
+    pub normal_output: bool,
 }

src/args.rs

@@ -55,10 +55,14 @@ pub async fn run(args: Args) -> Result<()> {
         handles.spawn(handle);
     }
 
-    tokio::spawn(terminal::terminal_output(
-        method.clone(),
-        shutdown_rx.clone(),
-    ));
+    if args.normal_output {
+        tokio::spawn(terminal::normal_output(method.clone(), shutdown_rx.clone()));
+    } else {
+        tokio::spawn(terminal::terminal_output(
+            method.clone(),
+            shutdown_rx.clone(),
+        ));
+    }
 
     tokio::spawn(shutdown::handle_shutdown_signals(shutdown_tx.clone()));
     wait_for_completion(time, shutdown_tx.clone(), shutdown_rx.clone()).await?;

src/http_benchmark.rs

@@ -12,35 +12,91 @@ use std::{
 
 use crate::statistic::STATISTIC;
 
+pub enum OutputMode {
+    Terminal { refresh_rate_ms: u64 },
+    Normal { refresh_rate_ms: u64 },
+}
+
+impl Default for OutputMode {
+    fn default() -> Self {
+        OutputMode::Terminal {
+            refresh_rate_ms: 200,
+        }
+    }
+}
+
 pub async fn terminal_output(
     method: reqwest::Method,
     shutdown_signal: tokio::sync::watch::Receiver<bool>,
+) -> anyhow::Result<()> {
+    output_statistics(
+        method,
+        shutdown_signal,
+        OutputMode::Terminal {
+            refresh_rate_ms: 200,
+        },
+    )
+    .await
+}
+
+pub async fn normal_output(
+    method: reqwest::Method,
+    shutdown_signal: tokio::sync::watch::Receiver<bool>,
+) -> anyhow::Result<()> {
+    output_statistics(
+        method,
+        shutdown_signal,
+        OutputMode::Normal {
+            refresh_rate_ms: 2000,
+        },
+    )
+    .await
+}
+
+async fn output_statistics(
+    method: reqwest::Method,
+    shutdown_signal: tokio::sync::watch::Receiver<bool>,
+    mode: OutputMode,
 ) -> anyhow::Result<()> {
     let s = STATISTIC.get().unwrap();
     let counter = &s.request_counter;
     let sc = &s.status_counter;
     let network_traffics = &s.network_traffics;
 
+    // Initial delay before starting output
     tokio::time::sleep(Duration::from_secs(4)).await;
+
     let mut stdout = stdout();
     write!(stdout, "\n")?;
     stdout.flush()?;
-    let (_, y) = cursor::position()?;
+
+    // Only get cursor position when using terminal mode
+    let cursor_y = match mode {
+        OutputMode::Terminal { .. } => Some(cursor::position()?.1),
+        OutputMode::Normal { .. } => None,
+    };
+
     loop {
         if *shutdown_signal.borrow() {
             break Ok(());
         }
 
-        stdout
-            .execute(MoveTo(0, y))?
-            .execute(Clear(ClearType::FromCursorDown))?;
+        // Clear screen if in terminal mode
+        if let Some(y) = cursor_y {
+            stdout
+                .execute(MoveTo(0, y))?
+                .execute(Clear(ClearType::FromCursorDown))?;
+        }
+
+        // Write request count
         write!(
             stdout,
             "The {} request has sent {} times",
             method,
             counter.load(Ordering::Relaxed)
         )?;
 
+        // Write status counts
         write!(
             stdout,
             "\nrequest status counter's results: 2xx: {} 3xx: {} 4xx: {} 5xx: {} timeout: {}",
@@ -51,8 +107,8 @@ pub async fn terminal_output(
             sc.status_other.load(Ordering::Relaxed)
         )?;
 
+        // Write network traffic
         let byte = Byte::from_u64(network_traffics.load(Ordering::Relaxed));
-
         write!(
             stdout,
             "\nnetwork traffics: {} bytes, Human readable: {}",
@@ -61,9 +117,14 @@ pub async fn terminal_output(
         )?;
 
         writeln!(stdout, "")?;
-
         stdout.flush()?;
 
-        tokio::time::sleep(Duration::from_millis(200)).await;
+        // Sleep according to the specified mode
+        let sleep_duration = match mode {
+            OutputMode::Terminal { refresh_rate_ms } => refresh_rate_ms,
+            OutputMode::Normal { refresh_rate_ms } => refresh_rate_ms,
+        };
+
+        tokio::time::sleep(Duration::from_millis(sleep_duration)).await;
     }
 }