Title: Avoid blocking I/O in async paths

- Move storage to async tokio::fs APIs
- Await storage calls in CLI/TUI flows
- Offload current_dir and client init to blocking thread

Author: gleb-chipiga

src/cli.rs

@@ -163,7 +163,12 @@ pub fn build_config(args: &Cli) -> RunConfig {
 /// `silent` controls whether to consume events and suppress output.
 async fn run_test_engine(args: Cli, silent: bool) -> Result<()> {
     let cfg = build_config(&args);
-    let network_info = crate::network::gather_network_info(&args);
+    let network_info = tokio::task::spawn_blocking({
+        let args = args.clone();
+        move || crate::network::gather_network_info(&args)
+    })
+    .await
+    .context("gather_network_info task panicked")?;
     let enriched = if silent {
         // In silent mode, spawn task and consume events
         let (evt_tx, mut evt_rx) = mpsc::channel::<TestEvent>(2048);
@@ -198,7 +203,7 @@ async fn run_test_engine(args: Cli, silent: bool) -> Result<()> {
     };
 
     // Handle exports (errors will propagate)
-    handle_exports(&args, &enriched)?;
+    handle_exports(&args, &enriched).await?;
 
     if !silent {
         // Print JSON output in non-silent mode
@@ -208,9 +213,11 @@ async fn run_test_engine(args: Cli, silent: bool) -> Result<()> {
     // Save results if auto_save is enabled
     if args.auto_save {
         if silent {
-            crate::storage::save_run(&enriched).context("failed to save run results")?;
+            crate::storage::save_run(&enriched)
+                .await
+                .context("failed to save run results")?;
         } else {
-            if let Ok(p) = crate::storage::save_run(&enriched) {
+            if let Ok(p) = crate::storage::save_run(&enriched).await {
                 eprintln!("Saved: {}", p.display());
             }
         }
@@ -302,10 +309,15 @@ async fn run_text(args: Cli) -> Result<()> {
     let result = handle.await??;
 
     // Gather network information and enrich result
-    let network_info = crate::network::gather_network_info(&args);
+    let network_info = tokio::task::spawn_blocking({
+        let args = args.clone();
+        move || crate::network::gather_network_info(&args)
+    })
+    .await
+    .context("gather_network_info task panicked")?;
     let enriched = crate::network::enrich_result(&result, &network_info);
 
-    handle_exports(&args, &enriched)?;
+    handle_exports(&args, &enriched).await?;
     if let Some(meta) = enriched.meta.as_ref() {
         let extracted = crate::network::extract_metadata(meta);
         let ip = extracted.ip.as_deref().unwrap_or("-");
@@ -388,20 +400,20 @@ async fn run_text(args: Cli) -> Result<()> {
         );
     }
     if args.auto_save {
-        if let Ok(p) = crate::storage::save_run(&enriched) {
+        if let Ok(p) = crate::storage::save_run(&enriched).await {
             eprintln!("Saved: {}", p.display());
         }
     }
     Ok(())
 }
 
 /// Handle export operations (JSON and CSV) for both text and JSON modes.
-fn handle_exports(args: &Cli, result: &crate::model::RunResult) -> Result<()> {
+async fn handle_exports(args: &Cli, result: &crate::model::RunResult) -> Result<()> {
     if let Some(p) = args.export_json.as_deref() {
-        crate::storage::export_json(p, result)?;
+        crate::storage::export_json(p, result).await?;
     }
     if let Some(p) = args.export_csv.as_deref() {
-        crate::storage::export_csv(p, result)?;
+        crate::storage::export_csv(p, result).await?;
     }
     Ok(())
 }

src/engine/mod.rs

@@ -5,7 +5,7 @@ mod throughput;
 mod turn_udp;
 
 use crate::model::{Phase, RunConfig, RunResult, TestEvent};
-use anyhow::Result;
+use anyhow::{Context, Result};
 use std::sync::{
     atomic::{AtomicBool, Ordering},
     Arc,
@@ -34,7 +34,12 @@ impl TestEngine {
         event_tx: mpsc::Sender<TestEvent>,
         mut control_rx: mpsc::Receiver<EngineControl>,
     ) -> Result<RunResult> {
-        let client = cloudflare::CloudflareClient::new(&self.cfg)?;
+        let client = tokio::task::spawn_blocking({
+            let cfg = self.cfg.clone();
+            move || cloudflare::CloudflareClient::new(&cfg)
+        })
+        .await
+        .context("CloudflareClient::new task panicked")??;
 
         let paused = Arc::new(AtomicBool::new(false));
         let cancel = Arc::new(AtomicBool::new(false));

src/network.rs

@@ -26,21 +26,24 @@ pub fn extract_metadata(meta: &Value) -> ExtractedMetadata {
         .and_then(|v| v.as_str())
         .map(|s| s.to_string());
 
-    let asn = meta
-        .get("asn")
-        .and_then(|v| {
-            v.as_i64()
-                .map(|n| n.to_string())
-                .or_else(|| v.as_str().map(|s| s.to_string()))
-        });
+    let asn = meta.get("asn").and_then(|v| {
+        v.as_i64()
+            .map(|n| n.to_string())
+            .or_else(|| v.as_str().map(|s| s.to_string()))
+    });
 
     let as_org = ["asOrganization", "asnOrg"]
         .iter()
         .find_map(|key| meta.get(*key))
         .and_then(|v| v.as_str())
         .map(|s| s.to_string());
 
-    ExtractedMetadata { ip, colo, asn, as_org }
+    ExtractedMetadata {
+        ip,
+        colo,
+        asn,
+        as_org,
+    }
 }
 
 /// Network information gathered from the system

src/storage.rs

@@ -15,16 +15,20 @@ fn runs_dir() -> PathBuf {
 }
 
 /// Ensure the necessary directories exist for storing data.
-pub fn ensure_dirs() -> Result<()> {
-    std::fs::create_dir_all(runs_dir()).context("create runs dir")?;
+pub async fn ensure_dirs() -> Result<()> {
+    tokio::fs::create_dir_all(runs_dir())
+        .await
+        .context("create runs dir")?;
     Ok(())
 }
 
-pub fn save_run(result: &RunResult) -> Result<PathBuf> {
-    ensure_dirs()?;
+pub async fn save_run(result: &RunResult) -> Result<PathBuf> {
+    ensure_dirs().await?;
     let path = get_run_path(result)?;
     let data = serde_json::to_vec_pretty(result)?;
-    std::fs::write(&path, data).context("write run json")?;
+    tokio::fs::write(&path, data)
+        .await
+        .context("write run json")?;
     Ok(path)
 }
 
@@ -34,28 +38,36 @@ pub fn get_run_path(result: &RunResult) -> Result<PathBuf> {
     Ok(runs_dir().join(format!("run-{safe_ts}-{}.json", result.meas_id)))
 }
 
-pub fn delete_run(result: &RunResult) -> Result<()> {
+pub async fn delete_run(result: &RunResult) -> Result<()> {
     let path = get_run_path(result)?;
-    if path.exists() {
-        std::fs::remove_file(&path).context("delete run file")?;
+    if tokio::fs::try_exists(&path).await.unwrap_or(false) {
+        tokio::fs::remove_file(&path)
+            .await
+            .context("delete run file")?;
     }
     Ok(())
 }
 
-pub fn export_json(path: &Path, result: &RunResult) -> Result<()> {
+pub async fn export_json(path: &Path, result: &RunResult) -> Result<()> {
     // Create parent directories if they don't exist
     if let Some(parent) = path.parent() {
-        std::fs::create_dir_all(parent).context("create export directory")?;
+        tokio::fs::create_dir_all(parent)
+            .await
+            .context("create export directory")?;
     }
     let data = serde_json::to_vec_pretty(result)?;
-    std::fs::write(path, data).context("write export json")?;
+    tokio::fs::write(path, data)
+        .await
+        .context("write export json")?;
     Ok(())
 }
 
-pub fn export_csv(path: &Path, result: &RunResult) -> Result<()> {
+pub async fn export_csv(path: &Path, result: &RunResult) -> Result<()> {
     // Create parent directories if they don't exist
     if let Some(parent) = path.parent() {
-        std::fs::create_dir_all(parent).context("create export directory")?;
+        tokio::fs::create_dir_all(parent)
+            .await
+            .context("create export directory")?;
     }
     let mut out = String::new();
     out.push_str("timestamp_utc,base_url,meas_id,comments,server,download_mbps,upload_mbps,idle_mean_ms,idle_median_ms,idle_p25_ms,idle_p75_ms,idle_loss,dl_loaded_mean_ms,dl_loaded_median_ms,dl_loaded_p25_ms,dl_loaded_p75_ms,dl_loaded_loss,ul_loaded_mean_ms,ul_loaded_median_ms,ul_loaded_p25_ms,ul_loaded_p75_ms,ul_loaded_loss,ip,colo,asn,as_org,interface_name,network_name,is_wireless,interface_mac,link_speed_mbps\n");
@@ -93,7 +105,9 @@ pub fn export_csv(path: &Path, result: &RunResult) -> Result<()> {
         csv_escape(result.interface_mac.as_deref().unwrap_or("")),
         result.link_speed_mbps.map(|s| s.to_string()).unwrap_or_else(|| "".to_string()),
     ));
-    std::fs::write(path, out).context("write export csv")?;
+    tokio::fs::write(path, out)
+        .await
+        .context("write export csv")?;
     Ok(())
 }
 
@@ -106,17 +120,17 @@ fn csv_escape(s: &str) -> String {
     }
 }
 
-pub fn load_recent(limit: usize) -> Result<Vec<RunResult>> {
-    ensure_dirs()?;
+pub async fn load_recent(limit: usize) -> Result<Vec<RunResult>> {
+    ensure_dirs().await?;
     let dir = runs_dir();
     let mut entries: Vec<(std::time::SystemTime, PathBuf)> = Vec::new();
-    for e in std::fs::read_dir(&dir).context("read runs dir")? {
-        let e = e?;
+    let mut dir_iter = tokio::fs::read_dir(&dir).await.context("read runs dir")?;
+    while let Some(e) = dir_iter.next_entry().await? {
         let p = e.path();
         if p.extension().and_then(|e| e.to_str()) != Some("json") {
             continue;
         }
-        let m = e.metadata()?;
+        let m = e.metadata().await?;
         let mt = m.modified().unwrap_or(std::time::SystemTime::UNIX_EPOCH);
         entries.push((mt, p));
     }
@@ -125,7 +139,9 @@ pub fn load_recent(limit: usize) -> Result<Vec<RunResult>> {
 
     let mut out = Vec::new();
     for (_, p) in entries.into_iter().take(limit) {
-        let data = std::fs::read(&p).with_context(|| format!("read {}", p.display()))?;
+        let data = tokio::fs::read(&p)
+            .await
+            .with_context(|| format!("read {}", p.display()))?;
         let r: RunResult =
             serde_json::from_slice(&data).with_context(|| format!("parse {}", p.display()))?;
         out.push(r);