mid coding commit

core/archipelago/src/container/data_manager.rs

@@ -0,0 +1,119 @@
+use anyhow::{Context, Result};
+use std::path::{Path, PathBuf};
+use tokio::fs;
+
+pub struct DevDataManager {
+    dev_data_dir: PathBuf,
+}
+
+impl DevDataManager {
+    pub fn new(dev_data_dir: PathBuf) -> Self {
+        Self { dev_data_dir }
+    }
+
+    /// Get the dev data directory for an app
+    pub fn get_app_data_dir(&self, app_id: &str) -> PathBuf {
+        self.dev_data_dir.join(app_id)
+    }
+
+    /// Create data directory for an app
+    pub async fn create_app_data_dir(&self, app_id: &str) -> Result<PathBuf> {
+        let app_dir = self.get_app_data_dir(app_id);
+        fs::create_dir_all(&app_dir)
+            .await
+            .with_context(|| format!("Failed to create app data directory: {:?}", app_dir))?;
+        Ok(app_dir)
+    }
+
+    /// Map a volume source path to dev path
+    pub fn map_volume_path(&self, app_id: &str, volume_source: &str) -> PathBuf {
+        // If volume source is already in dev_data_dir, use it as-is
+        if volume_source.starts_with(self.dev_data_dir.to_str().unwrap_or("")) {
+            PathBuf::from(volume_source)
+        } else {
+            // Map production path to dev path
+            // e.g., /var/lib/archipelago/bitcoin -> /tmp/archipelago-dev/bitcoin
+            let app_dir = self.get_app_data_dir(app_id);
+            
+            // Extract the relative path from the production path
+            if let Some(relative) = volume_source.strip_prefix("/var/lib/archipelago/") {
+                app_dir.join(relative)
+            } else if let Some(relative) = volume_source.strip_prefix("/var/lib/archipelago") {
+                app_dir.join(relative)
+            } else {
+                // If it doesn't match expected pattern, use app_id as base
+                app_dir.join(volume_source.trim_start_matches('/'))
+            }
+        }
+    }
+
+    /// Clean up app data directory
+    pub async fn cleanup_app_data(&self, app_id: &str) -> Result<()> {
+        let app_dir = self.get_app_data_dir(app_id);
+        if app_dir.exists() {
+            fs::remove_dir_all(&app_dir)
+                .await
+                .with_context(|| format!("Failed to remove app data directory: {:?}", app_dir))?;
+        }
+        Ok(())
+    }
+
+    /// Preserve app data (no-op for cleanup, used when removing container)
+    pub async fn preserve_app_data(&self, _app_id: &str) -> Result<()> {
+        // In dev mode, we might want to preserve data between container removals
+        // This is a no-op by default, but can be extended
+        Ok(())
+    }
+
+    /// Get all app data directories
+    pub async fn list_app_data_dirs(&self) -> Result<Vec<String>> {
+        if !self.dev_data_dir.exists() {
+            return Ok(vec![]);
+        }
+
+        let mut entries = fs::read_dir(&self.dev_data_dir)
+            .await
+            .with_context(|| format!("Failed to read dev data directory: {:?}", self.dev_data_dir))?;
+
+        let mut app_ids = Vec::new();
+        while let Some(entry) = entries.next_entry().await? {
+            if entry.file_type().await?.is_dir() {
+                if let Some(name) = entry.file_name().to_str() {
+                    app_ids.push(name.to_string());
+                }
+            }
+        }
+
+        Ok(app_ids)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::path::PathBuf;
+
+    #[tokio::test]
+    async fn test_map_volume_path() {
+        let temp_dir = std::env::temp_dir().join("test-archipelago");
+        let manager = DevDataManager::new(temp_dir.clone());
+        
+        let dev_path = manager.map_volume_path("bitcoin-core", "/var/lib/archipelago/bitcoin");
+        assert!(dev_path.to_string_lossy().contains("bitcoin-core"));
+        
+        // Cleanup
+        let _ = tokio::fs::remove_dir_all(&temp_dir).await;
+    }
+
+    #[tokio::test]
+    async fn test_create_app_data_dir() {
+        let temp_dir = std::env::temp_dir().join("test-archipelago-2");
+        let manager = DevDataManager::new(temp_dir.clone());
+
+        let app_dir = manager.create_app_data_dir("test-app").await.unwrap();
+        assert!(app_dir.exists());
+        
+        // Cleanup
+        let _ = tokio::fs::remove_dir_all(&temp_dir).await;
+    }
+}