removed io module inside storage/disk

Author: ZocoLini

dash-spv/src/storage/disk/headers.rs

@@ -1,13 +1,17 @@
 //! Header storage operations for DiskStorageManager.
 
+use std::collections::HashMap;
+use std::fs;
 use std::ops::Range;
+use std::path::Path;
 use std::time::Instant;
 
 use dashcore::block::Header as BlockHeader;
 use dashcore::BlockHash;
 
 use crate::error::StorageResult;
 use crate::storage::disk::segments::SegmentCache;
+use crate::StorageError;
 
 use super::manager::DiskStorageManager;
 use super::segments::{create_sentinel_header, SegmentState};
@@ -450,6 +454,41 @@ impl DiskStorageManager {
     }
 }
 
+/// Load index from file.
+pub(super) async fn load_index_from_file(path: &Path) -> StorageResult<HashMap<BlockHash, u32>> {
+    tokio::task::spawn_blocking({
+        let path = path.to_path_buf();
+        move || {
+            let content = fs::read(&path)?;
+            bincode::deserialize(&content).map_err(|e| {
+                StorageError::ReadFailed(format!("Failed to deserialize index: {}", e))
+            })
+        }
+    })
+    .await
+    .map_err(|e| StorageError::ReadFailed(format!("Task join error: {}", e)))?
+}
+
+/// Save index to disk.
+pub(super) async fn save_index_to_disk(
+    path: &Path,
+    index: &HashMap<BlockHash, u32>,
+) -> StorageResult<()> {
+    tokio::task::spawn_blocking({
+        let path = path.to_path_buf();
+        let index = index.clone();
+        move || {
+            let data = bincode::serialize(&index).map_err(|e| {
+                StorageError::WriteFailed(format!("Failed to serialize index: {}", e))
+            })?;
+            fs::write(&path, data)?;
+            Ok(())
+        }
+    })
+    .await
+    .map_err(|e| StorageError::WriteFailed(format!("Task join error: {}", e)))?
+}
+
 /// Ensure a segment is loaded in memory.
 pub(super) async fn ensure_segment_loaded(
     manager: &DiskStorageManager,

dash-spv/src/storage/disk/io.rs

@@ -121,8 +121,6 @@ impl DiskStorageManager {
 
     /// Start the background worker and notification channel.
     pub(super) async fn start_worker(&mut self) {
-        use super::io::save_index_to_disk;
-
         let (worker_tx, mut worker_rx) = mpsc::channel::<WorkerCommand>(100);
         let (notification_tx, notification_rx) = mpsc::channel::<WorkerNotification>(100);
 
@@ -165,7 +163,7 @@ impl DiskStorageManager {
                         index,
                     } => {
                         let path = worker_base_path.join("headers/index.dat");
-                        if let Err(e) = save_index_to_disk(&path, &index).await {
+                        if let Err(e) = super::headers::save_index_to_disk(&path, &index).await {
                             eprintln!("Failed to save index: {}", e);
                         } else {
                             tracing::trace!("Background worker completed saving index");
@@ -261,7 +259,7 @@ impl DiskStorageManager {
         let index_path = self.base_path.join("headers/index.dat");
         let mut index_loaded = false;
         if index_path.exists() {
-            if let Ok(index) = super::io::load_index_from_file(&index_path).await {
+            if let Ok(index) = super::headers::load_index_from_file(&index_path).await {
                 *self.header_hash_index.write().await = index;
                 index_loaded = true;
             }

dash-spv/src/storage/disk/manager.rs

@@ -21,7 +21,6 @@
 
 mod filters;
 mod headers;
-mod io;
 mod manager;
 mod segments;
 mod state;