shadow_storage/

store.rs

//! Content-addressed storage implementation

use shadow_core::error::{Result, ShadowError};
use crate::chunking::{Chunker, ChunkInfo};
use crate::erasure::ErasureEncoder;
use bytes::Bytes;
use std::collections::HashMap;
use std::sync::{Arc, RwLock};

/// Storage configuration
#[derive(Debug, Clone)]
pub struct StorageConfig {
    /// Chunk size in bytes
    pub chunk_size: usize,
    /// Number of data shards for erasure coding
    pub data_shards: usize,
    /// Number of parity shards
    pub parity_shards: usize,
    /// Enable encryption
    pub encrypt: bool,
    /// Maximum storage size
    pub max_storage: usize,
}

impl Default for StorageConfig {
    fn default() -> Self {
        Self {
            chunk_size: 256 * 1024, // 256 KB
            data_shards: 3,
            parity_shards: 2,
            encrypt: true,
            max_storage: 1024 * 1024 * 1024, // 1 GB
        }
    }
}

/// Content-addressed storage
pub struct ContentStore {
    /// Configuration
    config: StorageConfig,
    /// Chunk storage (hash -> data)
    chunks: Arc<RwLock<HashMap<[u8; 32], Bytes>>>,
    /// File metadata (content hash -> chunk list)
    metadata: Arc<RwLock<HashMap<[u8; 32], Vec<ChunkInfo>>>>,
    /// Current storage size
    current_size: Arc<RwLock<usize>>,
}

impl ContentStore {
    /// Create new content store
    pub fn new(config: StorageConfig) -> Self {
        Self {
            config,
            chunks: Arc::new(RwLock::new(HashMap::new())),
            metadata: Arc::new(RwLock::new(HashMap::new())),
            current_size: Arc::new(RwLock::new(0)),
        }
    }

    /// Store data and return content hash
    pub fn store(&self, data: &[u8]) -> Result<[u8; 32]> {
        // Check storage limit
        let current = *self.current_size.read().unwrap();
        if current + data.len() > self.config.max_storage {
            return Err(ShadowError::Storage("Storage full".into()));
        }

        // Chunk the data
        let chunker = Chunker::new(self.config.chunk_size);
        let chunks = chunker.chunk(data)?;

        // Store each chunk
        let mut chunk_infos = Vec::new();
        let mut chunks_map = self.chunks.write().unwrap();
        let mut size = self.current_size.write().unwrap();

        for (info, chunk_data) in chunks {
            // Only store if not already present (deduplication)
            if !chunks_map.contains_key(&info.hash) {
                chunks_map.insert(info.hash, chunk_data);
                *size += info.size;
            }
            chunk_infos.push(info);
        }

        // Calculate content hash
        let content_hash = Chunker::content_hash(&chunk_infos);

        // Store metadata
        self.metadata.write().unwrap().insert(content_hash, chunk_infos);

        Ok(content_hash)
    }

    /// Retrieve data by content hash
    pub fn retrieve(&self, content_hash: &[u8; 32]) -> Result<Bytes> {
        // Get metadata
        let metadata = self.metadata.read().unwrap();
        let chunk_infos = metadata.get(content_hash)
            .ok_or_else(|| ShadowError::Storage("Content not found".into()))?
            .clone();

        // Retrieve chunks
        let chunks_map = self.chunks.read().unwrap();
        let mut chunks = Vec::new();

        for info in chunk_infos {
            let chunk_data = chunks_map.get(&info.hash)
                .ok_or_else(|| ShadowError::Storage(format!(
                    "Chunk {} missing", info.index
                )))?
                .clone();
            
            chunks.push((info, chunk_data));
        }

        // Reassemble
        let chunker = Chunker::new(self.config.chunk_size);
        chunker.reassemble(&chunks)
    }

    /// Check if content exists
    pub fn contains(&self, content_hash: &[u8; 32]) -> bool {
        self.metadata.read().unwrap().contains_key(content_hash)
    }

    /// Delete content
    pub fn delete(&self, content_hash: &[u8; 32]) -> Result<()> {
        let mut metadata = self.metadata.write().unwrap();
        
        if let Some(chunk_infos) = metadata.remove(content_hash) {
            let mut chunks_map = self.chunks.write().unwrap();
            let mut size = self.current_size.write().unwrap();

            // Remove chunks (check if other files use them first)
            for info in chunk_infos {
                // Simple deletion - in production, implement reference counting
                if let Some(chunk) = chunks_map.remove(&info.hash) {
                    *size = size.saturating_sub(chunk.len());
                }
            }
        }

        Ok(())
    }

    /// Get storage statistics
    pub fn stats(&self) -> StorageStats {
        let chunks_count = self.chunks.read().unwrap().len();
        let files_count = self.metadata.read().unwrap().len();
        let current_size = *self.current_size.read().unwrap();

        StorageStats {
            chunks: chunks_count,
            files: files_count,
            size_bytes: current_size,
            max_bytes: self.config.max_storage,
        }
    }

    /// List all stored content hashes
    pub fn list(&self) -> Vec<[u8; 32]> {
        self.metadata.read().unwrap().keys().copied().collect()
    }
}

impl Default for ContentStore {
    fn default() -> Self {
        Self::new(StorageConfig::default())
    }
}

/// Storage statistics
#[derive(Debug, Clone)]
pub struct StorageStats {
    pub chunks: usize,
    pub files: usize,
    pub size_bytes: usize,
    pub max_bytes: usize,
}

impl StorageStats {
    pub fn usage_percent(&self) -> f64 {
        (self.size_bytes as f64 / self.max_bytes as f64) * 100.0
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_store_retrieve() {
        let store = ContentStore::default();
        let data = b"Hello, Shadow Network Storage!";
        
        let hash = store.store(data).unwrap();
        let retrieved = store.retrieve(&hash).unwrap();
        
        assert_eq!(retrieved.as_ref(), data);
    }

    #[test]
    fn test_deduplication() {
        let store = ContentStore::default();
        let data = b"Same data";
        
        let hash1 = store.store(data).unwrap();
        let initial_size = store.stats().size_bytes;
        
        let hash2 = store.store(data).unwrap();
        let final_size = store.stats().size_bytes;
        
        assert_eq!(hash1, hash2);
        assert_eq!(initial_size, final_size); // Size shouldn't increase
    }

    #[test]
    fn test_delete() {
        let store = ContentStore::default();
        let data = b"Temporary data";
        
        let hash = store.store(data).unwrap();
        assert!(store.contains(&hash));
        
        store.delete(&hash).unwrap();
        assert!(!store.contains(&hash));
    }

    #[test]
    fn test_stats() {
        let store = ContentStore::default();
        let stats1 = store.stats();
        
        store.store(b"Test data").unwrap();
        
        let stats2 = store.stats();
        
        assert!(stats2.size_bytes > stats1.size_bytes);
        assert!(stats2.files > stats1.files);
    }
}