fix(storage): include snapshot data in db backup export

backup_to_directory used Snapshot::export_to_directory, which only copied
the .snapshot JSON and omitted {name}_data, producing tiny archives
unsuitable for sync-from-snapshot. Route backup through
SnapshotManager::export_snapshot instead.

Fix restore_from_directory to import_snapshot then load_snapshot, and
fix import_snapshot to resolve *_data using the original snapshot name
before rename.

Remove the stub Snapshot export/import helpers to avoid a second code path.

Made-with: Cursor

Author: TheNewAutonomy

crates/catalyst-storage/src/manager.rs

@@ -505,12 +505,12 @@ impl StorageManager {
         std::fs::create_dir_all(backup_dir)
             .map_err(StorageError::from)?;
 
-        // Create a snapshot first
+        // Create a snapshot first, then export metadata + `{name}_data` (not just the `.snapshot` file).
         let snapshot_name = format!("backup_{}", current_timestamp());
-        let snapshot = self.create_snapshot(&snapshot_name).await?;
-        
-        // Copy snapshot data to backup directory
-        snapshot.export_to_directory(backup_dir).await?;
+        self.create_snapshot(&snapshot_name).await?;
+        self.snapshot_manager
+            .export_snapshot(&snapshot_name, backup_dir)
+            .await?;
 
         log_info!(LogCategory::Storage, "Database backed up to {:?}", backup_dir);
         Ok(())
@@ -522,12 +522,14 @@ impl StorageManager {
             return Err(StorageError::config(format!("Backup directory {:?} does not exist", backup_dir)));
         }
 
-        // Import snapshot from backup directory
-        let snapshot_name = format!("restore_{}", current_timestamp());
-        let snapshot = Snapshot::import_from_directory(&snapshot_name, backup_dir).await?;
-        
-        // Load the snapshot
-        self.load_snapshot(&snapshot_name).await?;
+        // Register files from `backup_dir` into this node's snapshot dir, then load into the open DB.
+        let imported_name = self
+            .snapshot_manager
+            .import_snapshot(backup_dir, None)
+            .await?;
+        self.snapshot_manager
+            .load_snapshot(&imported_name)
+            .await?;
 
         // Recompute state root
         self.compute_state_root().await?;

crates/catalyst-storage/src/snapshot.rs

@@ -558,7 +558,8 @@ impl SnapshotManager {
 
         // Load snapshot metadata
         let mut snapshot = self.load_snapshot_metadata(&metadata_file).await?;
-        
+        let orig_name = snapshot.name.clone();
+
         // Use new name if provided
         let final_name = new_name.unwrap_or_else(|| {
             format!("{}_imported_{}", snapshot.name, current_timestamp())
@@ -576,8 +577,8 @@ impl SnapshotManager {
         std::fs::copy(&metadata_file, &snapshot.file_path)
             .map_err(StorageError::from)?;
 
-        // Copy data directory if it exists
-        let data_src = import_dir.join(format!("{}_data", snapshot.name));
+        // Copy data directory if it exists (on-disk folder uses `orig_name`, not renamed `final_name`)
+        let data_src = import_dir.join(format!("{}_data", orig_name));
         let data_dest = self.snapshot_dir.join(format!("{}_data", final_name));
 
         if data_src.exists() {
@@ -679,40 +680,6 @@ impl Snapshot {
     pub fn metadata(&self) -> &SnapshotMetadata {
         &self.metadata
     }
-    
-    /// Export to directory (convenience method)
-    pub async fn export_to_directory(&self, export_dir: &Path) -> StorageResult<()> {
-        // Create export directory
-        std::fs::create_dir_all(export_dir)
-            .map_err(StorageError::from)?;
-        
-        // Copy metadata file
-        let metadata_dest = export_dir.join(format!("{}.snapshot", self.name));
-        std::fs::copy(&self.file_path, &metadata_dest)
-            .map_err(StorageError::from)?;
-        
-        // Note: In a full implementation, you'd also copy the data directory
-        // This is simplified for the example
-        
-        Ok(())
-    }
-    
-    /// Import from directory (static constructor)
-    pub async fn import_from_directory(name: &str, import_dir: &Path) -> StorageResult<Snapshot> {
-        let metadata_file = import_dir.join(format!("{}.snapshot", name));
-        
-        if !metadata_file.exists() {
-            return Err(StorageError::snapshot(format!("Snapshot metadata file not found: {:?}", metadata_file)));
-        }
-        
-        let content = std::fs::read_to_string(&metadata_file)
-            .map_err(StorageError::from)?;
-        
-        let snapshot: Snapshot = serde_json::from_str(&content)
-            .map_err(|e| StorageError::serialization(format!("Failed to parse snapshot metadata: {}", e)))?;
-        
-        Ok(snapshot)
-    }
 }
 
 #[cfg(test)]