dnx_core/

cache.rs

use crate::errors::{DnxError, Result};
use crate::integrity::{integrity_to_path_safe, verify_integrity};
use flate2::read::GzDecoder;
use serde::Serialize;
use std::collections::HashSet;
use std::fs;
use std::path::{Path, PathBuf};
use std::sync::{Arc, RwLock};
use tar::Archive;
use walkdir::WalkDir;

/// Content-addressable cache for storing package tarballs
#[derive(Debug, Clone)]
pub struct ContentCache {
    root: PathBuf,
    /// In-memory index of known integrity hashes in the cache.
    /// Avoids filesystem stat calls on every `has()` check.
    index: Arc<RwLock<HashSet<String>>>,
}

/// Statistics from cleaning the cache
#[derive(Debug, Default, Serialize)]
pub struct CleanStats {
    pub removed: usize,
    pub freed_bytes: u64,
}

impl ContentCache {
    /// Create a new ContentCache with the given root directory
    /// If root is None, uses the default cache directory
    pub fn new(root: Option<PathBuf>) -> Self {
        let root = root.unwrap_or_else(Self::default_cache_dir);

        let cache = Self {
            root,
            index: Arc::new(RwLock::new(HashSet::new())),
        };

        // Create cache directories if they don't exist
        fs::create_dir_all(cache.content_dir()).unwrap_or_else(|e| {
            eprintln!("Warning: Failed to create cache content directory: {}", e)
        });
        fs::create_dir_all(cache.tmp_dir())
            .unwrap_or_else(|e| eprintln!("Warning: Failed to create cache tmp directory: {}", e));

        // Populate in-memory index from existing content directory
        cache.populate_index();

        cache
    }

    /// Scan content directory and populate the in-memory index.
    /// Only indexes entries that have a complete `package/` subdirectory.
    /// Auto-repairs entries where the tarball extracted to a non-standard root
    /// (e.g. `react/` instead of `package/`) by renaming to `package/`.
    fn populate_index(&self) {
        let content_dir = self.content_dir();
        if let Ok(entries) = fs::read_dir(&content_dir) {
            let mut index = self.index.write().unwrap_or_else(|e| e.into_inner());
            for entry in entries.flatten() {
                if let Some(name) = entry.file_name().to_str() {
                    let entry_path = entry.path();
                    if entry_path.join("package").exists() {
                        index.insert(name.to_string());
                    } else if entry_path.is_dir() {
                        // Try to auto-repair: if there's exactly one subdirectory,
                        // rename it to "package" (tarball had non-standard root).
                        if let Ok(sub_entries) = fs::read_dir(&entry_path) {
                            let dirs: Vec<_> = sub_entries
                                .filter_map(|e| e.ok())
                                .filter(|e| e.file_type().map(|t| t.is_dir()).unwrap_or(false))
                                .collect();
                            if dirs.len() == 1 {
                                let target = entry_path.join("package");
                                if fs::rename(dirs[0].path(), &target).is_ok() {
                                    index.insert(name.to_string());
                                }
                            }
                        }
                    }
                }
            }
        }
    }

    /// Get the default cache directory (~/.dnx/cache)
    pub fn default_cache_dir() -> PathBuf {
        dirs::home_dir()
            .unwrap_or_else(|| std::env::current_dir().unwrap_or_else(|_| PathBuf::from(".")))
            .join(".dnx")
            .join("cache")
    }

    /// Get the content directory path
    pub fn content_dir(&self) -> PathBuf {
        self.root.join("content")
    }

    /// Get the temporary directory path
    pub fn tmp_dir(&self) -> PathBuf {
        self.root.join("tmp")
    }

    /// Check if content with the given integrity exists in the cache (O(1) memory lookup)
    pub fn has(&self, integrity: &str) -> bool {
        let safe = integrity_to_path_safe(integrity);
        if let Ok(index) = self.index.read() {
            index.contains(&safe)
        } else {
            // Fallback to filesystem check if lock is poisoned
            self.content_dir().join(&safe).exists()
        }
    }

    /// Get the path to cached content for the given integrity
    pub fn get_path(&self, integrity: &str) -> PathBuf {
        self.content_dir()
            .join(integrity_to_path_safe(integrity))
            .join("package")
    }

    /// Store tarball data in the cache after verifying its integrity
    /// Returns the path to the extracted package directory
    pub fn store(&self, integrity: &str, tarball_data: &[u8]) -> Result<PathBuf> {
        // Compute or verify integrity
        let effective_integrity = if integrity.is_empty() || !integrity.starts_with("sha512-") {
            // No usable integrity hash - compute SHA-512 from tarball data
            crate::integrity::compute_sha512(tarball_data)
        } else {
            // Verify the integrity of the tarball data
            if !verify_integrity(tarball_data, integrity)? {
                return Err(DnxError::Integrity(format!(
                    "Integrity check failed (expected {})",
                    integrity
                )));
            }
            integrity.to_string()
        };

        // If the package directory already exists on disk, return it.
        // Content-addressed: same integrity hash ⇒ same content, no need to re-extract.
        let cached_path = self.get_path(&effective_integrity);
        if cached_path.exists() {
            // Ensure in-memory index is consistent
            let safe = integrity_to_path_safe(&effective_integrity);
            if let Ok(mut index) = self.index.write() {
                index.insert(safe);
            }
            return Ok(cached_path);
        }

        // Self-heal: remove corrupt cache entry (directory exists but package/ doesn't)
        let safe_integrity = integrity_to_path_safe(&effective_integrity);
        let existing_dir = self.content_dir().join(&safe_integrity);
        if existing_dir.exists() {
            let _ = fs::remove_dir_all(&existing_dir);
            if let Ok(mut index) = self.index.write() {
                index.remove(&safe_integrity);
            }
        }

        // Create a temporary directory for extraction
        let temp_dir = tempfile::tempdir_in(self.tmp_dir())
            .map_err(|e| DnxError::Cache(format!("Failed to create temp directory: {}", e)))?;

        // Streaming decompress + extract (no intermediate buffer)
        let decoder = GzDecoder::new(tarball_data);
        let mut archive = Archive::new(decoder);
        archive
            .unpack(temp_dir.path())
            .map_err(|e| DnxError::Cache(format!("Failed to extract tarball: {}", e)))?;

        // Normalize root directory: npm tarballs usually extract to "package/"
        // but some packages (e.g. @types/*) use the package name instead.
        // Rename the root to "package" for consistent cache layout.
        let package_subdir = temp_dir.path().join("package");
        if !package_subdir.exists() {
            // Find the single root directory and rename it to "package"
            let entries: Vec<_> = fs::read_dir(temp_dir.path())
                .map_err(|e| DnxError::Cache(format!("Failed to read temp dir: {}", e)))?
                .filter_map(|e| e.ok())
                .filter(|e| e.file_type().map(|t| t.is_dir()).unwrap_or(false))
                .collect();

            if entries.len() == 1 {
                fs::rename(entries[0].path(), &package_subdir).map_err(|e| {
                    DnxError::Cache(format!(
                        "Failed to normalize tarball root '{}' to 'package': {}",
                        entries[0].file_name().to_string_lossy(),
                        e
                    ))
                })?;
            } else if entries.is_empty() {
                return Err(DnxError::Cache(
                    "Tarball extraction produced no directories".to_string(),
                ));
            }
            // If multiple dirs, leave as-is (unusual but don't break)
        }

        // Consume TempDir to get a plain PathBuf — prevents the destructor from
        // removing the directory after we rename/move it to the final location.
        let temp_path = temp_dir.keep();

        // Prepare the final destination path (reuse safe_integrity from above)
        let final_path = self.content_dir().join(&safe_integrity);

        // Ensure the parent directory exists
        if let Some(parent) = final_path.parent() {
            fs::create_dir_all(parent).map_err(|e| {
                DnxError::Cache(format!("Failed to create parent directory: {}", e))
            })?;
        }

        // Move the temp directory to the final location.
        // Another process may have stored the same content concurrently —
        // if the final path appeared while we were extracting, just discard our copy.
        if final_path.exists() {
            let _ = fs::remove_dir_all(&temp_path);
        } else {
            // On Windows, fs::rename can fail across different drives/volumes
            // so we need to handle that case with copy+delete
            let move_result = fs::rename(&temp_path, &final_path);
            if let Err(ref e) = move_result {
                // If rename fails, try copy and delete
                copy_dir_all(&temp_path, &final_path).map_err(|copy_err| {
                    DnxError::Cache(format!(
                        "Failed to move cache content (rename error: {}, copy error: {})",
                        e, copy_err
                    ))
                })?;
            }
            // Clean up the temp directory (no-op if rename succeeded, removes original if copied)
            let _ = fs::remove_dir_all(&temp_path);
        }

        // Update in-memory index
        if let Ok(mut index) = self.index.write() {
            index.insert(safe_integrity.clone());
        }

        // If the original integrity differs from effective (e.g., sha1 → computed sha512),
        // create an alias so lookups with the original integrity also work.
        if !integrity.is_empty() && integrity != effective_integrity {
            let original_safe = integrity_to_path_safe(integrity);
            if original_safe != safe_integrity {
                let alias_path = self.content_dir().join(&original_safe);
                if !alias_path.exists() {
                    // Create a directory junction/symlink from original → effective
                    #[cfg(windows)]
                    {
                        let _ = junction::create(&final_path, &alias_path);
                    }
                    #[cfg(unix)]
                    {
                        let _ = std::os::unix::fs::symlink(&final_path, &alias_path);
                    }
                    if let Ok(mut index) = self.index.write() {
                        index.insert(original_safe);
                    }
                }
            }
        }

        Ok(self.get_path(&effective_integrity))
    }

    /// Calculate the total disk usage of the cache
    pub fn disk_usage(&self) -> Result<u64> {
        let mut total_size = 0u64;

        for entry in WalkDir::new(self.content_dir())
            .into_iter()
            .filter_map(|e| e.ok())
        {
            if entry.file_type().is_file() {
                if let Ok(metadata) = entry.metadata() {
                    total_size += metadata.len();
                }
            }
        }

        Ok(total_size)
    }

    /// Clean the cache, removing entries not in the keep set
    /// Returns statistics about the cleaning operation
    pub fn clean(&self, keep: &HashSet<String>) -> Result<CleanStats> {
        let mut stats = CleanStats::default();
        let content_dir = self.content_dir();

        if !content_dir.exists() {
            return Ok(stats);
        }

        // Iterate over entries in the content directory
        let entries = fs::read_dir(&content_dir)
            .map_err(|e| DnxError::Cache(format!("Failed to read content directory: {}", e)))?;

        for entry in entries {
            let entry = entry
                .map_err(|e| DnxError::Cache(format!("Failed to read directory entry: {}", e)))?;

            let path = entry.path();

            // Get the directory name (which is the safe integrity hash)
            if let Some(dir_name) = path.file_name().and_then(|n| n.to_str()) {
                // Check if this entry should be kept
                if !keep.contains(dir_name) {
                    // Calculate size before removing
                    let size = calculate_dir_size(&path);

                    // Remove the directory
                    if let Err(e) = fs::remove_dir_all(&path) {
                        eprintln!("Warning: Failed to remove {}: {}", path.display(), e);
                        continue;
                    }

                    stats.removed += 1;
                    stats.freed_bytes += size;
                }
            }
        }

        // Also clean up temporary files
        let tmp_dir = self.tmp_dir();
        if tmp_dir.exists() {
            if let Ok(entries) = fs::read_dir(&tmp_dir) {
                for entry in entries.flatten() {
                    let path = entry.path();
                    let size = calculate_dir_size(&path);
                    if fs::remove_dir_all(&path).is_ok() {
                        stats.removed += 1;
                        stats.freed_bytes += size;
                    }
                }
            }
        }

        Ok(stats)
    }
}

/// Helper function to copy a directory recursively
fn copy_dir_all(src: &std::path::Path, dst: &std::path::Path) -> std::io::Result<()> {
    fs::create_dir_all(dst)?;

    for entry in fs::read_dir(src)? {
        let entry = entry?;
        let ty = entry.file_type()?;
        let src_path = entry.path();
        let dst_path = dst.join(entry.file_name());

        if ty.is_dir() {
            copy_dir_all(&src_path, &dst_path)?;
        } else {
            fs::copy(&src_path, &dst_path)?;
        }
    }

    Ok(())
}

/// Helper function to calculate the total size of a directory
fn calculate_dir_size(path: &std::path::Path) -> u64 {
    let mut total_size = 0u64;

    for entry in WalkDir::new(path).into_iter().filter_map(|e| e.ok()) {
        if entry.file_type().is_file() {
            if let Ok(metadata) = entry.metadata() {
                total_size += metadata.len();
            }
        }
    }

    total_size
}

/// Cache for package build outputs (side effects of install scripts).
/// After a package runs its install scripts (preinstall, install, postinstall),
/// the resulting output is cached keyed by (package, version, platform, arch).
pub struct SideEffectsCache {
    cache_dir: PathBuf,
}

impl SideEffectsCache {
    /// Create a new SideEffectsCache, storing cached outputs under the given directory.
    pub fn new(base_dir: Option<PathBuf>) -> Self {
        let cache_dir = base_dir.unwrap_or_else(|| {
            dirs::home_dir()
                .unwrap_or_else(|| PathBuf::from("."))
                .join(".dnx")
                .join("side-effects")
        });
        Self { cache_dir }
    }

    /// Generate a cache key for a package's side effects.
    fn cache_key(package_name: &str, version: &str) -> String {
        let platform = std::env::consts::OS;
        let arch = std::env::consts::ARCH;
        format!(
            "{}_{}_{}_{}",
            package_name.replace(['/', '@'], "_"),
            version,
            platform,
            arch
        )
    }

    /// Check if side effects are cached for a given package.
    pub fn has(&self, package_name: &str, version: &str) -> bool {
        let key = Self::cache_key(package_name, version);
        self.cache_dir.join(&key).exists()
    }

    /// Store the side effects (built output) for a package.
    /// `package_dir` is the directory of the installed package after scripts ran.
    pub fn store(&self, package_name: &str, version: &str, package_dir: &Path) -> Result<()> {
        let key = Self::cache_key(package_name, version);
        let dest = self.cache_dir.join(&key);

        // Create cache directory
        std::fs::create_dir_all(&dest).map_err(|e| {
            DnxError::Cache(format!("Failed to create side-effects cache dir: {}", e))
        })?;

        // Copy the built files that are typically modified by install scripts
        // Common patterns: binding.gyp outputs, .node files, build/ directories
        let side_effect_patterns = ["build", "prebuilds", "Release", "Debug"];

        for entry in std::fs::read_dir(package_dir)
            .map_err(|e| DnxError::Cache(format!("Failed to read package dir: {}", e)))?
        {
            let entry =
                entry.map_err(|e| DnxError::Cache(format!("Failed to read dir entry: {}", e)))?;
            let name = entry.file_name();
            let name_str = name.to_string_lossy();

            // Cache built artifacts and .node files
            let should_cache = side_effect_patterns.iter().any(|p| *p == name_str.as_ref())
                || name_str.ends_with(".node");

            if should_cache && entry.path().exists() {
                let target = dest.join(&name);
                if entry.path().is_dir() {
                    copy_dir_all(&entry.path(), &target).map_err(|e| {
                        DnxError::Cache(format!("Failed to cache side effect: {}", e))
                    })?;
                } else {
                    std::fs::copy(entry.path(), &target).map_err(|e| {
                        DnxError::Cache(format!("Failed to cache side effect file: {}", e))
                    })?;
                }
            }
        }

        Ok(())
    }

    /// Restore cached side effects into a package directory.
    /// Returns true if side effects were restored, false if not cached.
    pub fn restore(&self, package_name: &str, version: &str, package_dir: &Path) -> Result<bool> {
        let key = Self::cache_key(package_name, version);
        let source = self.cache_dir.join(&key);

        if !source.exists() {
            return Ok(false);
        }

        // Check if the cache entry has any files
        let has_entries = std::fs::read_dir(&source)
            .map(|mut entries| entries.next().is_some())
            .unwrap_or(false);

        if !has_entries {
            return Ok(false);
        }

        // Copy cached artifacts back into the package directory
        for entry in std::fs::read_dir(&source)
            .map_err(|e| DnxError::Cache(format!("Failed to read side-effects cache: {}", e)))?
        {
            let entry =
                entry.map_err(|e| DnxError::Cache(format!("Failed to read cache entry: {}", e)))?;
            let target = package_dir.join(entry.file_name());

            if entry.path().is_dir() {
                copy_dir_all(&entry.path(), &target).map_err(|e| {
                    DnxError::Cache(format!("Failed to restore side effect: {}", e))
                })?;
            } else {
                std::fs::copy(entry.path(), &target).map_err(|e| {
                    DnxError::Cache(format!("Failed to restore side effect file: {}", e))
                })?;
            }
        }

        Ok(true)
    }

    /// Clean all cached side effects.
    pub fn clean(&self) -> Result<usize> {
        if !self.cache_dir.exists() {
            return Ok(0);
        }
        let mut removed = 0;
        for entry in std::fs::read_dir(&self.cache_dir)
            .map_err(|e| DnxError::Cache(format!("Failed to read side-effects cache: {}", e)))?
            .flatten()
        {
            if entry.path().is_dir() {
                let _ = std::fs::remove_dir_all(entry.path());
                removed += 1;
            }
        }
        Ok(removed)
    }
}

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

    #[test]
    fn test_cache_paths() {
        let temp_dir = tempfile::tempdir().unwrap();
        let cache = ContentCache::new(Some(temp_dir.path().to_path_buf()));

        assert_eq!(cache.content_dir(), temp_dir.path().join("content"));
        assert_eq!(cache.tmp_dir(), temp_dir.path().join("tmp"));
        assert!(cache.content_dir().exists());
        assert!(cache.tmp_dir().exists());
    }

    #[test]
    fn test_has_returns_false_for_nonexistent() {
        let temp_dir = tempfile::tempdir().unwrap();
        let cache = ContentCache::new(Some(temp_dir.path().to_path_buf()));

        assert!(!cache.has("sha512-nonexistent"));
    }

    #[test]
    fn test_get_path() {
        let temp_dir = tempfile::tempdir().unwrap();
        let cache = ContentCache::new(Some(temp_dir.path().to_path_buf()));

        let integrity = "sha512-test";
        let expected = cache
            .content_dir()
            .join(integrity_to_path_safe(integrity))
            .join("package");

        assert_eq!(cache.get_path(integrity), expected);
    }

    #[test]
    fn test_disk_usage_empty() {
        let temp_dir = tempfile::tempdir().unwrap();
        let cache = ContentCache::new(Some(temp_dir.path().to_path_buf()));

        let usage = cache.disk_usage().unwrap();
        assert_eq!(usage, 0);
    }

    #[test]
    fn test_clean_stats_default() {
        let stats = CleanStats::default();
        assert_eq!(stats.removed, 0);
        assert_eq!(stats.freed_bytes, 0);
    }
}