fix: lock to ensure atomicity of remove + rename operations

Author: fengmk2

crates/vite_install/src/package_manager.rs

@@ -5,11 +5,12 @@ use std::{
     io::BufReader,
     path::Path,
     process::{ExitStatus, Stdio},
+    sync::{Arc, Mutex, OnceLock},
 };
 
 use semver::{Version, VersionReq};
 use serde::{Deserialize, Serialize};
-use tokio::{fs::remove_dir_all, process::Command};
+use tokio::{fs::remove_dir_all, process::Command, sync::Mutex as TokioMutex};
 use vite_error::Error;
 use vite_path::{AbsolutePath, AbsolutePathBuf};
 use vite_str::Str;
@@ -320,6 +321,22 @@ async fn get_latest_version(package_manager_type: PackageManagerType) -> Result<
     Ok(package_json.version)
 }
 
+/// Get a per-directory lock for atomic remove + rename operations.
+/// This ensures that multiple concurrent threads won't conflict when
+/// installing the same package manager version.
+fn get_directory_lock(path: impl AsRef<Path>) -> Arc<TokioMutex<()>> {
+    static LOCKS: OnceLock<Mutex<HashMap<String, Arc<TokioMutex<()>>>>> = OnceLock::new();
+
+    let locks_map = LOCKS.get_or_init(|| Mutex::new(HashMap::new()));
+    let path_str = path.as_ref().to_string_lossy().to_string();
+
+    // Acquire the mutex for the locks map
+    // This is safe because we're only doing a quick HashMap lookup
+    let mut map = locks_map.lock().unwrap();
+
+    map.entry(path_str).or_insert_with(|| Arc::new(TokioMutex::new(()))).clone()
+}
+
 /// Download the package manager and extract it to the cache directory.
 /// Return the install directory, e.g. $`CACHE_DIR/vite/package_manager/pnpm/10.0.0/pnpm`
 async fn download_package_manager(
@@ -374,9 +391,19 @@ async fn download_package_manager(
     tracing::debug!("Rename package dir to {}", bin_name);
     tokio::fs::rename(&target_dir_tmp.join("package"), &target_dir_tmp.join(&bin_name)).await?;
 
-    // check bin_file again, for the concurrent download cases
-    if is_exists_file(&bin_file)? {
-        tracing::debug!("bin_file already exists, skip rename");
+    // Use a per-directory lock to ensure atomicity of remove + rename operations
+    // This prevents DirectoryNotEmpty exceptions when multiple threads try to install
+    // the same package manager version concurrently.
+    let dir_lock = get_directory_lock(&target_dir);
+    let _guard = dir_lock.lock().await;
+
+    // Check again after acquiring the lock, in case another thread completed
+    // the installation while we were downloading
+    if is_exists_file(&bin_file)?
+        && is_exists_file(bin_file.with_extension("cmd"))?
+        && is_exists_file(bin_file.with_extension("ps1"))?
+    {
+        tracing::debug!("bin_file already exists after lock acquisition, skip rename");
         return Ok(install_dir);
     }
 
@@ -395,12 +422,13 @@ async fn download_package_manager(
 /// Remove the directory and all its contents.
 /// Ignore the error if the directory is not found.
 async fn remove_dir_all_force(path: impl AsRef<Path>) -> Result<(), std::io::Error> {
-    match remove_dir_all(path).await {
+    match remove_dir_all(path.as_ref()).await {
         Ok(()) => Ok(()),
         Err(e) => {
             if e.kind() == std::io::ErrorKind::NotFound {
                 Ok(())
             } else {
+                tracing::error!("remove_dir_all_force path: {:?} error: {e:?}", path.as_ref());
                 Err(e)
             }
         }