use async mutex (tokio mutex) instead of the ordinary mutex

Cargo.lock

···
 
 [[package]]
 name = "replay"
-version = "0.1.1"
+version = "0.1.2"
 dependencies = [
  "actix-web",
  "clap",

Cargo.toml

···
 [package]
 name = "replay"
-version = "0.1.1"
+version = "0.1.2"
 edition = "2024"
 description = "A simple HTTP request replay tool"
 license = "Apache-2.0"

src/main.rs

···
 
-use std::sync::{Arc, Mutex};
+use std::sync::{Arc};
 
 use clap::{Arg, Command};
 use owo_colors::OwoColorize;
 use proxy::start_server;
+use tokio::sync::Mutex;
 
 pub mod proxy;
 pub mod replay;
···
         let logs = store::load_logs_from_file(proxy::PROXY_LOG_FILE)?;
         let logs = Arc::new(Mutex::new(logs));
         let listen = matches.get_one::<String>("listen").unwrap();
-        println!("Loaded {} mocks from {}", logs.lock().unwrap().len().magenta(), proxy::PROXY_LOG_FILE.magenta());
+        println!("Loaded {} mocks from {}", logs.lock().await.len().magenta(), proxy::PROXY_LOG_FILE.magenta());
         println!("Replay server is running on {}", listen.magenta());
         replay::start_replay_server(logs, listen).await?;
         return Ok(());

src/proxy.rs

···
-use std::{process::exit, sync::{Arc, Mutex}, thread, time::{SystemTime, UNIX_EPOCH}};
+use std::{process::exit, sync::Arc, thread, time::{SystemTime, UNIX_EPOCH}};
 
 use http_body_util::{BodyExt, Full};
 use hyper::{body::{Buf, Bytes, Incoming}, server::conn::http1, Request, Response};
 use owo_colors::OwoColorize;
 use serde::{Deserialize, Serialize};
-use tokio::net::TcpListener;
+use tokio::{net::TcpListener, sync::Mutex};
 use hyper_util::rt::TokioIo;
 
 use crate::{replay::start_replay_server, store::{save_logs_to_file, LogStore}};
···
   tokio::spawn(async move {
       loop {
           tokio::time::sleep(tokio::time::Duration::from_secs(5)).await;
-          save_logs_to_file(&logs_for_saving, PROXY_LOG_FILE).unwrap_or_else(|e| {
-              eprintln!("Error saving logs: {}", e);
-          });
+          save_logs_to_file(&logs_for_saving, PROXY_LOG_FILE).await
+                .unwrap_or_else(|e| eprintln!("Error saving logs to file: {}", e));
       }
   });
 
···
           });
 
           if let Err(err) = http1::Builder::new()
-                .keep_alive(false)  // Disable keep-alive
-                .max_buf_size(30 * 1024 * 1024) // 30 MB
+                .keep_alive(false)
+                .max_buf_size(30 * 1024 * 1024)
               .serve_connection(io, service)
               .await
           {
···
   };
 
   {
-    let mut logs_guard = logs.lock().unwrap();
+    let mut logs_guard = logs.lock().await;
     if !logs_guard.iter()
       .any(|log|
           log.request.method == log_entry.request.method &&

src/replay.rs

···
 
 pub async fn start_replay_server(logs: LogStore, bind_address: &str) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
   if let Ok(file_logs) = load_logs_from_file(PROXY_LOG_FILE) {
-      let mut logs_guard = logs.lock().unwrap();
+      let mut logs_guard = logs.lock().await;
       for log in file_logs {
           logs_guard.push(log);
       }
···
       println!("Replay server received request: {}", key.magenta());
 
       let response = {
-          let logs_guard = logs.lock().unwrap();
+          let logs_guard = logs.lock().await;
           logs_guard.iter()
               .find(|log| {
                   let log_key = build_request_key(
···
   }
 
   async fn list_requests(logs: web::Data<LogStore>) -> impl Responder {
-      let logs_guard = logs.lock().unwrap();
+      let logs_guard = logs.lock().await;
       let requests: Vec<_> = logs_guard.iter().map(|log| {
           let key = build_request_key(
               &log.request.method,

src/store.rs

···
     fs::{File, OpenOptions},
     io::Write,
     path::Path,
-    sync::{Arc, Mutex},
+    sync::Arc,
 };
+
+use tokio::sync::Mutex;
 
 use crate::proxy::ProxyLog;
 
 pub type LogStore = Arc<Mutex<Vec<ProxyLog>>>;
 
-pub fn save_logs_to_file(
+pub async fn save_logs_to_file(
     logs: &LogStore,
     filename: &str,
 ) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
-    let logs_guard = logs.lock().unwrap();
+    let logs_guard = logs.lock().await;
 
     if logs_guard.is_empty() {
         return Ok(());