del: fs::lock

Author: MiyakoMeow

cli/src/bms.rs

@@ -9,7 +9,6 @@ use futures::stream::{self, StreamExt as FuturesStreamExt};
 use smol::{fs, io};
 
 use self::work::extract_work_name;
-use crate::fs::lock::acquire_disk_lock;
 
 pub const BMS_FILE_EXTS: &[&str] = &["bms", "bme", "bml", "pms"];
 pub const BMSON_FILE_EXTS: &[&str] = &["bmson"];
@@ -38,10 +37,7 @@ pub const MEDIA_FILE_EXTS_FILE_EXTS: LazyCell<Vec<&str>> = LazyCell::new(|| {
 
 /// 仅负责读取 BMS 文件（异步 IO）
 async fn read_bms_file(file: &Path) -> io::Result<Vec<u8>> {
-    let bytes = {
-        let _lock_guard = acquire_disk_lock(file).await;
-        fs::read(file).await?
-    };
+    let bytes = { fs::read(file).await? };
     Ok(bytes)
 }
 
@@ -60,10 +56,7 @@ pub async fn parse_bms_file(file: &Path) -> io::Result<BmsOutput> {
 
 /// 仅负责读取 BMSON 文件（异步 IO）
 async fn read_bmson_file(file: &Path) -> io::Result<Vec<u8>> {
-    let bytes = {
-        let _lock_guard = acquire_disk_lock(file).await;
-        fs::read(file).await?
-    };
+    let bytes = { fs::read(file).await? };
     Ok(bytes)
 }
 

cli/src/fs.rs

@@ -1,4 +1,3 @@
-pub mod lock;
 pub mod moving;
 pub mod rawpack;
 pub mod sync;
@@ -12,8 +11,6 @@ use smol::{
     stream::StreamExt,
 };
 
-use crate::fs::lock::acquire_disk_locks;
-
 /// Signs:
 ///  ：＼／＊？＂＜＞｜
 pub fn get_vaild_fs_name(ori_name: &str) -> String {
@@ -45,7 +42,6 @@ pub async fn is_file_same_content(a: &Path, b: &Path) -> io::Result<bool> {
         }
         Ok(hasher.finalize())
     }
-    let _locks = acquire_disk_locks(&[a, b]).await;
     let a_md = fs::metadata(a).await?;
     let b_md = fs::metadata(b).await?;
     if a_md.len() != b_md.len() || a_md.is_dir() || b_md.is_dir() {

cli/src/fs/lock.rs

@@ -14,7 +14,7 @@ use futures::stream::{self, StreamExt as FuturesStreamExt, TryStreamExt};
 
 use crate::bms::{BMS_FILE_EXTS, BMSON_FILE_EXTS};
 
-use super::{is_dir_having_file, is_file_same_content, lock::acquire_disk_locks};
+use super::{is_dir_having_file, is_file_same_content};
 use log::warn;
 
 /// Same name enum as Python
@@ -117,12 +117,10 @@ pub async fn move_elements_across_dir(
     let dir_path_ori = dir_path_ori.as_ref();
     let dir_path_dst = dir_path_dst.as_ref();
     // Lock and read source metadata
-    let _l_ori = acquire_disk_locks(&[dir_path_ori]).await;
     let ori_md = match fs::metadata(&dir_path_ori).await {
         Ok(m) => m,
         Err(_) => return Ok(()),
     };
-    drop(_l_ori);
 
     if dir_path_ori == dir_path_dst {
         return Ok(());
@@ -134,9 +132,7 @@ pub async fn move_elements_across_dir(
     // Do this check BEFORE creating the target directory, otherwise we'd
     // unnecessarily enumerate and move children one-by-one.
     // Lock and read destination metadata
-    let _l_dst = acquire_disk_locks(&[dir_path_dst]).await;
     let dst_meta_res = fs::metadata(&dir_path_dst).await;
-    drop(_l_dst);
 
     match dst_meta_res {
         Ok(m) => {
@@ -148,7 +144,6 @@ pub async fn move_elements_across_dir(
         }
         Err(e) => {
             if e.kind() == io::ErrorKind::NotFound {
-                let _l = acquire_disk_locks(&[dir_path_ori, dir_path_dst]).await;
                 fs::rename(&dir_path_ori, &dir_path_dst).await?;
                 return Ok(());
             } else {
@@ -189,9 +184,7 @@ async fn process_directory(
     replace_options: &ReplaceOptions,
 ) -> io::Result<Vec<(PathBuf, PathBuf)>> {
     // Collect entries to be processed (files / subdirectories)
-    let _l_rd = acquire_disk_locks(&[dir_path_ori]).await;
     let mut entries = fs::read_dir(dir_path_ori).await?;
-    drop(_l_rd);
     let next_folder_paths = Arc::new(Mutex::new(Vec::new()));
     let mut pairs: Vec<(PathBuf, PathBuf)> = Vec::new();
 
@@ -259,9 +252,7 @@ async fn process_directory(
     // Stage 2a: directory direct moves (streamed parallel)
     stream::iter(dir_direct_moves)
         .map(|(src, dst)| async move {
-            let _locks = acquire_disk_locks(&[&src, &dst]).await;
             let r = fs::rename(&src, &dst).await.map(|_| ());
-            drop(_locks);
             r
         })
         .buffer_unordered(64)
@@ -288,9 +279,7 @@ async fn process_directory(
     // Stage 2c: file Rename actions (streamed parallel)
     stream::iter(file_rename_ops)
         .map(|(src, dst)| async move {
-            let _locks = acquire_disk_locks(&[&src, &dst]).await;
             let r = move_file_rename(&src, &dst).await.map(|_| ());
-            drop(_locks);
             r
         })
         .buffer_unordered(128)
@@ -303,9 +292,7 @@ async fn process_directory(
         .map(|(src, dst)| {
             let rep = rep_clone2.clone();
             async move {
-                let _locks = acquire_disk_locks(&[&src, &dst]).await;
                 let r = move_file(&src, &dst, &rep).await.map(|_| ());
-                drop(_locks);
                 r
             }
         })
@@ -325,36 +312,28 @@ async fn move_file(src: &Path, dst: &Path, rep: &ReplaceOptions) -> io::Result<(
 
     match action {
         ReplaceAction::Replace => {
-            let _locks = acquire_disk_locks(&[src, dst]).await;
             let r = fs::rename(src, dst).await;
-            drop(_locks);
             r
         }
         ReplaceAction::Skip => {
             let exists = fs::metadata(&dst).await.is_ok();
             if exists {
                 return Ok(());
             }
-            let _locks = acquire_disk_locks(&[src, dst]).await;
             let r = fs::rename(src, dst).await;
-            drop(_locks);
             r
         }
         ReplaceAction::Rename => move_file_rename(src, dst).await,
         ReplaceAction::CheckReplace => {
             let dst_exists = fs::metadata(&dst).await.is_ok();
             if !dst_exists {
-                let _locks = acquire_disk_locks(&[src, dst]).await;
                 let r = fs::rename(src, dst).await;
-                drop(_locks);
                 r
             } else {
                 let same = is_file_same_content(src, dst).await?;
                 if same {
                     // Same content, directly overwrite
-                    let _locks = acquire_disk_locks(&[src, dst]).await;
                     let r = fs::rename(src, dst).await;
-                    drop(_locks);
                     r
                 } else {
                     move_file_rename(src, dst).await
@@ -382,17 +361,13 @@ async fn move_file_rename(src: &Path, dst_dir: &Path) -> io::Result<()> {
         };
         dst.set_file_name(name);
         if fs::metadata(&dst).await.is_err() {
-            let _locks = acquire_disk_locks(&[src, &dst]).await;
             fs::rename(src, &dst).await?;
-            drop(_locks);
             return Ok(());
         }
         let same = is_file_same_content(src, &dst).await?;
         if same {
             // File with same name and content already exists, skip
-            let _ls = acquire_disk_locks(&[src]).await;
             fs::remove_file(src).await?;
-            drop(_ls);
             return Ok(());
         }
     }

cli/src/fs/moving.rs

@@ -5,7 +5,6 @@ use std::path::Path;
 use smol::stream::StreamExt;
 use smol::{fs, io};
 
-use crate::fs::lock::{acquire_disk_lock, acquire_disk_locks};
 use crate::fs::moving::{ReplacePreset, move_elements_across_dir, replace_options_from_preset};
 
 /// Extract supported archives to specified cache directory
@@ -28,30 +27,16 @@ pub async fn unzip_file_to_cache_dir(
         .to_lowercase();
 
     match ext.as_str() {
-        "zip" => {
-            // Acquire disk locks for file operations (smart locking to avoid duplicate locks on same disk)
-            let _lock_guards = acquire_disk_locks(&[file_path, cache_dir_path]).await;
-            extract_zip(file_path, cache_dir_path).await?
-        }
-        "7z" => {
-            // Acquire disk locks for file operations (smart locking to avoid duplicate locks on same disk)
-            let _lock_guards = acquire_disk_locks(&[file_path, cache_dir_path]).await;
-            extract_7z(file_path, cache_dir_path).await?
-        }
-        "rar" => {
-            // Acquire disk locks for file operations (smart locking to avoid duplicate locks on same disk)
-            let _lock_guards = acquire_disk_locks(&[file_path, cache_dir_path]).await;
-            extract_rar(file_path, cache_dir_path).await?
-        }
+        "zip" => extract_zip(file_path, cache_dir_path).await?,
+        "7z" => extract_7z(file_path, cache_dir_path).await?,
+        "rar" => extract_rar(file_path, cache_dir_path).await?,
         _ => {
             // Not an archive => copy after space
             let target_name = file_name
                 .split_once(' ')
                 .map(|(_, s)| s)
                 .unwrap_or(file_name);
             let target = cache_dir_path.join(target_name);
-            // Acquire disk locks for file copy operation
-            let _lock_guards = acquire_disk_locks(&[file_path, cache_dir_path]).await;
             fs::copy(file_path, target).await?;
         }
     }
@@ -141,8 +126,6 @@ pub async fn move_out_files_in_folder_in_cache_dir(
             let path = entry.path();
             if entry.file_type().await?.is_dir() {
                 if name == "__MACOSX" {
-                    // Acquire disk lock for directory removal
-                    let _lock_guard = acquire_disk_lock(&path).await;
                     fs::remove_dir_all(&path).await?;
                     continue;
                 }
@@ -181,8 +164,6 @@ pub async fn move_out_files_in_folder_in_cache_dir(
                     " - Renaming inner inner dir name: {}",
                     inner_inner.display()
                 );
-                // Acquire disk lock for file rename operation
-                let _lock_guard = acquire_disk_lock(&inner_inner).await;
                 fs::rename(&inner_inner, format!("{}-rep", inner_inner.display())).await?;
             }
             log::info!(
@@ -196,8 +177,6 @@ pub async fn move_out_files_in_folder_in_cache_dir(
                 replace_options_from_preset(replace_preset),
             )
             .await?;
-            // Acquire disk lock for directory removal
-            let _lock_guard = acquire_disk_lock(&inner_path).await;
             fs::remove_dir(&inner_path).await.ok();
         }
     }
@@ -208,8 +187,6 @@ pub async fn move_out_files_in_folder_in_cache_dir(
 
     if cache_folder_count == 0 && cache_file_count == 0 {
         log::info!(" !_! {}: Cache is Empty!", cache_dir_path.display());
-        // Acquire disk lock for directory removal
-        let _lock_guard = acquire_disk_lock(cache_dir_path).await;
         fs::remove_dir(cache_dir_path).await?;
         return Ok(false);
     }