hotfix for high cpu usage while idle by making event receiver conditional

Author: kavehtehrani

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "cloudflare-speed-cli"
-version = "0.4.2"
+version = "0.4.3"
 edition = "2021"
 authors = ["kavehtehrani <codemonkey13x@gmail.com>"]
 description = "CLI tool for Cloudflare speed testing with TUI interface"

Cargo.toml

@@ -69,7 +69,7 @@ pub struct Cli {
     #[arg(long)]
     pub export_csv: Option<std::path::PathBuf>,
 
-    /// Use --auto-save true or --auto-save false to override (default: true)
+    /// Use --auto-save true or --auto-save false to override
     #[arg(long, default_value_t = true, action = clap::ArgAction::Set)]
     pub auto_save: bool,
 
@@ -84,6 +84,10 @@ pub struct Cli {
     /// Path to a custom TLS certificate file (PEM or DER format)
     #[arg(long)]
     pub certificate: Option<std::path::PathBuf>,
+
+    /// Automatically start a test when the app launches
+    #[arg(long, default_value_t = true, action = clap::ArgAction::Set)]
+    pub test_on_launch: bool,
 }
 
 pub async fn run(args: Cli) -> Result<()> {

src/cli.rs

@@ -60,9 +60,11 @@ impl TestEngine {
             });
 
         // Control listener.
+        // This task will exit naturally when the sender is dropped (which happens in cli.rs)
+        // The receiver will return None and the loop will exit cleanly
         let paused2 = paused.clone();
         let cancel2 = cancel.clone();
-        tokio::spawn(async move {
+        let control_handle = tokio::spawn(async move {
             while let Some(msg) = control_rx.recv().await {
                 match msg {
                     EngineControl::Pause(p) => paused2.store(p, Ordering::Relaxed),
@@ -153,6 +155,13 @@ impl TestEngine {
             }
         }
 
+        // Abort the control listener task before returning.
+        // In Tokio, dropping a JoinHandle does NOT cancel the task - it continues running!
+        // This was causing high CPU usage when idle because the task was still waiting
+        // on control_rx.recv().await even after the test completed.
+        control_handle.abort();
+        // Don't await the aborted task - just let it be cleaned up
+
         Ok(RunResult {
             timestamp_utc: time::OffsetDateTime::now_utc()
                 .format(&time::format_description::well_known::Rfc3339)

src/engine/mod.rs

@@ -89,7 +89,7 @@ pub async fn run_download_with_loaded_latency(
     let paused2 = paused.clone();
     let cancel2 = cancel.clone();
     let cfg2 = cfg.clone();
-    tokio::spawn(async move {
+    let lat_handle = tokio::spawn(async move {
         let res = run_latency_probes(
             &client2,
             Phase::Download,
@@ -165,6 +165,9 @@ pub async fn run_download_with_loaded_latency(
         .await
         .context("loaded latency task ended unexpectedly")?;
 
+    // Ensure the latency probe task has completed
+    let _ = lat_handle.await;
+
     Ok((dl, loaded_latency))
 }
 
@@ -229,7 +232,7 @@ pub async fn run_upload_with_loaded_latency(
     let paused2 = paused.clone();
     let cancel2 = cancel.clone();
     let cfg2 = cfg.clone();
-    tokio::spawn(async move {
+    let lat_handle = tokio::spawn(async move {
         let res = run_latency_probes(
             &client2,
             Phase::Upload,
@@ -305,5 +308,8 @@ pub async fn run_upload_with_loaded_latency(
         .await
         .context("loaded latency task ended unexpectedly")?;
 
+    // Ensure the latency probe task has completed
+    let _ = lat_handle.await;
+
     Ok((up, loaded_latency))
 }

src/engine/throughput.rs

@@ -9,7 +9,7 @@ use crossterm::{
     execute,
     terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
 };
-use futures::StreamExt;
+use futures::{future, StreamExt};
 use ratatui::{
     backend::CrosstermBackend,
     layout::{Constraint, Direction, Layout, Rect},
@@ -256,8 +256,12 @@ pub async fn run(args: Cli) -> Result<()> {
     let mut events = EventStream::new();
     let mut tick = tokio::time::interval(Duration::from_millis(100));
 
-    // Start first run.
-    let mut run_ctx = start_run(&args).await?;
+    // Start first run if test_on_launch is enabled
+    let mut run_ctx = if args.test_on_launch {
+        Some(start_run(&args).await?)
+    } else {
+        None
+    };
 
     let res = loop {
         tokio::select! {
@@ -272,12 +276,16 @@ pub async fn run(args: Cli) -> Result<()> {
                     }
                     match (k.modifiers, k.code) {
                         (_, KeyCode::Char('q')) | (KeyModifiers::CONTROL, KeyCode::Char('c')) => {
-                            run_ctx.ctrl_tx.send(EngineControl::Cancel).await.ok();
+                            if let Some(ref ctx) = run_ctx {
+                                ctx.ctrl_tx.send(EngineControl::Cancel).await.ok();
+                            }
                             break Ok(());
                         }
                         (_, KeyCode::Char('p')) => {
-                            state.paused = !state.paused;
-                            run_ctx.ctrl_tx.send(EngineControl::Pause(state.paused)).await.ok();
+                            if let Some(ref ctx) = run_ctx {
+                                state.paused = !state.paused;
+                                ctx.ctrl_tx.send(EngineControl::Pause(state.paused)).await.ok();
+                            }
                         }
                         (_, KeyCode::Char('r')) => {
                             // Refresh history (only when on history tab)
@@ -318,9 +326,11 @@ pub async fn run(args: Cli) -> Result<()> {
                             } else {
                                 // Rerun (only when NOT on history tab)
                                 state.info = "Restarting…".into();
-                                run_ctx.ctrl_tx.send(EngineControl::Cancel).await.ok();
-                                if let Some(h) = run_ctx.handle.take() {
-                                    let _ = h.await;
+                                if let Some(ref mut ctx) = run_ctx {
+                                    ctx.ctrl_tx.send(EngineControl::Cancel).await.ok();
+                                    if let Some(h) = ctx.handle.take() {
+                                        let _ = h.await;
+                                    }
                                 }
                                 state.last_result = None;
                                 state.run_start = Instant::now();
@@ -353,7 +363,7 @@ pub async fn run(args: Cli) -> Result<()> {
                                 state.loaded_ul_latency_received = 0;
                                 state.phase = Phase::IdleLatency;
                                 state.paused = false;
-                                run_ctx = start_run(&args).await?;
+                                run_ctx = Some(start_run(&args).await?);
                             }
                         }
                         (_, KeyCode::Char('s')) => {
@@ -531,11 +541,19 @@ pub async fn run(args: Cli) -> Result<()> {
                     }
                 }
             }
-            maybe_engine_ev = run_ctx.event_rx.recv() => {
+            // wrapping in conditional async to avoid spiking cpu usage when run_ctx is None
+            maybe_engine_ev = async {
+                if let Some(ref mut ctx) = run_ctx {
+                    ctx.event_rx.recv().await
+                } else {
+                    future::pending().await
+                }
+            } => {
                 match maybe_engine_ev {
                     None => {
                         // engine finished; wait for result
-                        if let Some(h) = run_ctx.handle.take() {
+                        if let Some(ctx) = &mut run_ctx {
+                            if let Some(h) = ctx.handle.take() {
                             match h.await {
                                 Ok(Ok(r)) => {
                                     if state.auto_save {
@@ -607,6 +625,8 @@ pub async fn run(args: Cli) -> Result<()> {
                                 Ok(Err(e)) => state.info = format!("Run failed: {e:#}"),
                                 Err(e) => state.info = format!("Run join failed: {e}"),
                             }
+                            }
+                            run_ctx = None; // Clear run_ctx after test completes
                         }
                     }
                     Some(ev) => apply_event(&mut state, ev),