chore(l1): remove snapshot dirs when they are no longer used

crates/networking/p2p/sync.rs

@@ -10,7 +10,7 @@ use crate::sync::state_healing::heal_state_trie_wrap;
 use crate::sync::storage_healing::heal_storage_trie;
 use crate::utils::{
     current_unix_time, get_account_state_snapshots_dir, get_account_storages_snapshots_dir,
-    get_code_hashes_snapshots_dir,
+    get_code_hashes_snapshots_dir, validate_folders,
 };
 use crate::{
     metrics::METRICS,
@@ -197,6 +197,19 @@ impl Syncer {
             Err(e) => return Err(e.into()),
         };
 
+        // We validate that we have the folders that are being used empty, as we currently assume
+        // they are.
+        if !validate_folders(&self.datadir) {
+            // Temp std::process::exit until #2767 is done
+            error!(
+                "One of the folders used for temporary leaves during snap is still used. Delete them in {}",
+                &self.datadir.to_str().unwrap_or_default()
+            );
+            std::process::exit(1);
+            // Cloning a single string, the node should stop after this
+            // return Err(SyncError::NotEmptyDatadirFolders(self.datadir.clone()));
+        }
+
         loop {
             debug!("Sync Log 1: In snap sync");
             debug!(
@@ -1120,6 +1133,9 @@ impl Syncer {
                 .await?;
         }
 
+        std::fs::remove_dir_all(code_hashes_dir)
+            .map_err(|_| SyncError::CodeHashesSnapshotsDirNotFound)?;
+
         *METRICS.bytecode_download_end_time.lock().await = Some(SystemTime::now());
 
         debug_assert!(validate_bytecodes(store.clone(), pivot_header.state_root).await);
@@ -1322,6 +1338,8 @@ pub enum SyncError {
     NoPeers,
     #[error("Failed to get block headers")]
     NoBlockHeaders,
+    #[error("The download datadir folders at {0} are not empty, delete them first")]
+    NotEmptyDatadirFolders(PathBuf),
     #[error("Couldn't create a thread")]
     ThreadCreationError,
     #[error("Called update_pivot outside snapsync mode")]
@@ -1405,7 +1423,7 @@ pub async fn validate_storage_root(store: Store, state_root: H256) -> bool {
     .all(|valid| valid);
     info!("Finished validate_storage_root");
     if !is_valid {
-        std::process::exit(-1);
+        std::process::exit(1);
     }
     is_valid
 }
@@ -1430,7 +1448,7 @@ pub async fn validate_bytecodes(store: Store, state_root: H256) -> bool {
         }
     }
     if !is_valid {
-        std::process::exit(-1);
+        std::process::exit(1);
     }
     is_valid
 }
@@ -1493,6 +1511,8 @@ async fn insert_accounts(
 
         computed_state_root = current_state_root?;
     }
+    std::fs::remove_dir_all(account_state_snapshots_dir)
+        .map_err(|_| SyncError::AccountStoragesSnapshotsDirNotFound)?;
     info!("computed_state_root {computed_state_root}");
     Ok((computed_state_root, BTreeSet::new()))
 }
@@ -1561,6 +1581,10 @@ async fn insert_storages(
             .write_storage_trie_nodes_batch(storage_trie_node_changes)
             .await?;
     }
+
+    std::fs::remove_dir_all(account_storages_snapshots_dir)
+        .map_err(|_| SyncError::AccountStoragesSnapshotsDirNotFound)?;
+
     Ok(())
 }
 
@@ -1620,6 +1644,11 @@ async fn insert_accounts(
     )
     .map_err(SyncError::TrieGenerationError)?;
 
+    std::fs::remove_dir_all(account_state_snapshots_dir)
+        .map_err(|_| SyncError::AccountStateSnapshotsDirNotFound)?;
+    std::fs::remove_dir_all(get_rocksdb_temp_accounts_dir(datadir))
+        .map_err(|_| SyncError::AccountTempDBDirNotFound)?;
+
     let accounts_with_storage =
         BTreeSet::from_iter(storage_accounts.accounts_with_storage_root.keys().copied());
     Ok((compute_state_root, accounts_with_storage))
@@ -1679,7 +1708,7 @@ async fn insert_storages(
     let mut db_options = rocksdb::Options::default();
     db_options.create_if_missing(true);
     let db = rocksdb::DB::open(&db_options, get_rocksdb_temp_storage_dir(datadir))
-        .map_err(|_| SyncError::StorageTempDBDirNotFound)?;
+        .map_err(|err: rocksdb::Error| SyncError::RocksDBError(err.into_string()))?;
     let file_paths: Vec<PathBuf> = std::fs::read_dir(account_storages_snapshots_dir)
         .map_err(|_| SyncError::AccountStoragesSnapshotsDirNotFound)?
         .collect::<Result<Vec<_>, _>>()
@@ -1755,5 +1784,11 @@ async fn insert_storages(
             pool.execute(task);
         }
     });
+
+    std::fs::remove_dir_all(account_storages_snapshots_dir)
+        .map_err(|_| SyncError::AccountStoragesSnapshotsDirNotFound)?;
+    std::fs::remove_dir_all(get_rocksdb_temp_storage_dir(datadir))
+        .map_err(|_| SyncError::StorageTempDBDirNotFound)?;
+
     Ok(())
 }

crates/networking/p2p/utils.rs

@@ -39,6 +39,22 @@ pub fn public_key_from_signing_key(signer: &SecretKey) -> H512 {
     H512::from_slice(&encoded[1..])
 }
 
+/// Returns true if the folders used for the partial download of the leaves exists. if they do exist, it
+/// should be deleted. We don't auto delete them on the off chance we want to backup the files
+pub fn validate_folders(datadir: &Path) -> bool {
+    let folder_doesnt_exist = !std::fs::exists(get_account_state_snapshots_dir(datadir))
+        .is_ok_and(|exists| exists)
+        && !std::fs::exists(get_account_storages_snapshots_dir(datadir)).is_ok_and(|exists| exists)
+        && !std::fs::exists(get_code_hashes_snapshots_dir(datadir)).is_ok_and(|exists| exists);
+    #[cfg(feature = "rocksdb")]
+    let folder_doesnt_exist = {
+        folder_doesnt_exist
+            && !std::fs::exists(get_rocksdb_temp_accounts_dir(datadir)).is_ok_and(|exists| exists)
+            && !std::fs::exists(get_rocksdb_temp_storage_dir(datadir)).is_ok_and(|exists| exists)
+    };
+    folder_doesnt_exist
+}
+
 pub fn get_account_storages_snapshots_dir(datadir: &Path) -> PathBuf {
     datadir.join("account_storages_snapshots")
 }