feat: cache storage move lock file (#8686)

* feat: cache storage move lock file

* feat: cache storage move lock file

* feat: cache storage move lock file

* feat: cache storage move lock file

* feat: cache storage move lock file

Author: LingyuCoder

crates/rspack_storage/src/pack/data/meta.rs

@@ -13,17 +13,26 @@ pub struct PackFileMeta {
   pub wrote: bool,
 }
 
+#[derive(Debug, Default, Clone)]
+pub enum RootMetaFrom {
+  #[default]
+  New,
+  File,
+}
+
 #[derive(Debug, Default, Clone)]
 pub struct RootMeta {
-  pub last_modified: u64,
+  pub expire_time: u64,
   pub scopes: HashSet<String>,
+  pub from: RootMetaFrom,
 }
 
 impl RootMeta {
-  pub fn new(scopes: HashSet<String>) -> Self {
+  pub fn new(scopes: HashSet<String>, expire: u64) -> Self {
     Self {
       scopes,
-      last_modified: current_time(),
+      expire_time: current_time() + expire,
+      from: RootMetaFrom::New,
     }
   }
   pub fn get_path(dir: &Utf8Path) -> Utf8PathBuf {

crates/rspack_storage/src/pack/data/mod.rs

@@ -3,7 +3,7 @@ mod options;
 mod pack;
 mod scope;
 
-pub use meta::{current_time, PackFileMeta, RootMeta, ScopeMeta};
+pub use meta::{current_time, PackFileMeta, RootMeta, RootMetaFrom, ScopeMeta};
 pub use options::{PackOptions, RootOptions};
 pub use pack::{Pack, PackContents, PackKeys};
 pub use scope::{PackScope, RootMetaState};

crates/rspack_storage/src/pack/fs/mod.rs

@@ -107,11 +107,13 @@ impl PackFS for PackBridgeFS {
   }
 
   async fn remove_file(&self, path: &Utf8Path) -> Result<()> {
-    self
-      .0
-      .remove_file(path)
-      .await
-      .map_err(|e| PackFsError::from_fs_error(path, PackFsErrorOpt::Remove, e))?;
+    if self.exists(path).await? {
+      self
+        .0
+        .remove_file(path)
+        .await
+        .map_err(|e| PackFsError::from_fs_error(path, PackFsErrorOpt::Remove, e))?;
+    }
     Ok(())
   }
 

crates/rspack_storage/src/pack/manager/mod.rs

@@ -65,6 +65,7 @@ impl ScopeManager {
               .filter(|(_, scope)| scope.loaded())
               .map(|(name, _)| name.clone())
               .collect::<HashSet<_>>(),
+            self.root_options.expire,
           )));
           Ok(())
         }
@@ -99,25 +100,37 @@ impl ScopeManager {
     Ok(rx)
   }
 
+  async fn clear_scope(&self, name: &str) {
+    self
+      .scopes
+      .lock()
+      .await
+      .get_mut(name)
+      .expect("should have scope")
+      .clear();
+  }
+
   pub async fn load(&self, name: &'static str) -> Result<StorageContent> {
+    self
+      .scopes
+      .lock()
+      .await
+      .entry(name.to_string())
+      .or_insert_with(|| PackScope::new(self.strategy.get_path(name), self.pack_options.clone()));
+
+    // only check lock file and root meta for the first time
     if matches!(*self.root_meta.lock().await, RootMetaState::Pending) {
-      let loaded = self.strategy.read_root_meta().await?;
-      if let Some(meta) = &loaded {
-        for scope_name in meta.scopes.clone() {
-          self
-            .scopes
-            .lock()
-            .await
-            .entry(scope_name.clone())
-            .or_insert_with(|| {
-              PackScope::new(
-                self.strategy.get_path(&scope_name),
-                self.pack_options.clone(),
-              )
-            });
+      match self.strategy.before_load().await {
+        Ok(()) => {
+          let loaded = self.strategy.read_root_meta().await?;
+          *self.root_meta.lock().await = RootMetaState::Value(loaded);
+        }
+        Err(err) => {
+          *self.root_meta.lock().await = RootMetaState::Value(None);
+          self.clear_scope(name).await;
+          return Err(err);
         }
       }
-      *self.root_meta.lock().await = RootMetaState::Value(loaded);
     }
 
     match self.validate_scope(name).await {
@@ -131,37 +144,18 @@ impl ScopeManager {
         }
         // create empty scope if not exists
         ValidateResult::NotExists => {
-          self
-            .scopes
-            .lock()
-            .await
-            .entry(name.to_string())
-            .or_insert_with(|| {
-              PackScope::empty(self.strategy.get_path(name), self.pack_options.clone())
-            });
+          self.clear_scope(name).await;
           Ok(vec![])
         }
         // clear scope if invalid
         ValidateResult::Invalid(_) => {
-          self
-            .scopes
-            .lock()
-            .await
-            .get_mut(name)
-            .expect("should have scope")
-            .clear();
+          self.clear_scope(name).await;
           Err(error!(validated.to_string()))
         }
       },
       Err(e) => {
         // clear scope if error
-        self
-          .scopes
-          .lock()
-          .await
-          .get_mut(name)
-          .expect("should have scope")
-          .clear();
+        self.clear_scope(name).await;
         Err(Error::from(e))
       }
     }
@@ -180,10 +174,7 @@ impl ScopeManager {
     };
 
     // scope exists, validate it
-    let validated = self
-      .strategy
-      .validate_root(root_meta, self.root_options.expire)
-      .await?;
+    let validated = self.strategy.validate_root(root_meta).await?;
     if validated.is_valid() {
       self.strategy.ensure_meta(scope).await?;
       let validated = self.strategy.validate_meta(scope).await?;
@@ -272,6 +263,8 @@ async fn save_scopes(
   .into_iter()
   .collect_vec();
 
+  strategy.write_root_meta(root_meta).await?;
+
   join_all(
     scopes
       .values()
@@ -291,8 +284,6 @@ async fn save_scopes(
   .into_iter()
   .collect::<Result<Vec<_>>>()?;
 
-  strategy.write_root_meta(root_meta).await?;
-
   for (_, scope) in scopes.iter_mut() {
     strategy.after_all(scope)?;
   }

crates/rspack_storage/src/pack/strategy/mod.rs

@@ -31,9 +31,10 @@ pub trait ScopeStrategy:
 
 #[async_trait]
 pub trait RootStrategy {
+  async fn before_load(&self) -> Result<()>;
   async fn read_root_meta(&self) -> Result<Option<RootMeta>>;
   async fn write_root_meta(&self, root_meta: &RootMeta) -> Result<()>;
-  async fn validate_root(&self, root_meta: &RootMeta, expire: u64) -> Result<ValidateResult>;
+  async fn validate_root(&self, root_meta: &RootMeta) -> Result<ValidateResult>;
   async fn clean_unused(
     &self,
     root_meta: &RootMeta,