void_core/ops/

diagnostics.rs

//! Debug helpers for inspecting shard layout and changes.

use std::collections::HashMap;

use crate::cid;
use crate::crypto::CommitReader;
use crate::ContentHash;
use crate::VoidContext;
use crate::metadata::{Commit, MetadataBundle};
use crate::metadata::manifest_tree::TreeManifest;

use crate::store::ObjectStoreExt;
use crate::Result;

/// Diagnostics snapshot for a sealed commit.
#[derive(Debug, Clone)]
pub struct ShardDiagnostics {
    /// File path → shard ID.
    pub file_to_shard: HashMap<String, u64>,
    /// File path → content hash.
    pub file_hashes: HashMap<String, ContentHash>,
    /// Shard ID → CID string.
    pub shard_cids: HashMap<u64, String>,
    /// Shard ID → sorted file list.
    pub shard_files: HashMap<u64, Vec<String>>,
    /// Shard ID → compressed body size.
    pub shard_sizes: HashMap<u64, u64>,
    /// Shard ID → directory listing count.
    pub dir_listing_counts: HashMap<u64, usize>,
}

/// Differences between two diagnostics snapshots.
#[derive(Debug, Clone)]
pub struct ShardDiff {
    pub new_files: Vec<String>,
    pub removed_files: Vec<String>,
    pub moved_files: Vec<(String, u64, u64)>,
    pub modified_files: Vec<String>,
}

impl ShardDiagnostics {
    /// Builds diagnostics from a TreeManifest (no shard decryption needed).
    pub fn from_manifest(manifest: &TreeManifest, metadata: &MetadataBundle) -> Result<Self> {
        let mut file_to_shard = HashMap::new();
        let mut file_hashes = HashMap::new();
        let mut shard_cids: HashMap<u64, String> = HashMap::new();
        let mut shard_files: HashMap<u64, Vec<String>> = HashMap::new();
        let mut shard_sizes: HashMap<u64, u64> = HashMap::new();

        // Build shard CID map from metadata ranges
        for range in &metadata.shard_map.ranges {
            if let Some(cid_bytes) = range.cid.as_ref() {
                if let Ok(shard_cid) = crate::cid::from_bytes(cid_bytes.as_bytes()) {
                    shard_cids.insert(range.shard_id, shard_cid.to_string());
                }
                shard_sizes.insert(range.shard_id, range.compressed_size);
            }
        }

        // Build shard sizes from manifest shard references
        for (idx, sref) in manifest.shards().iter().enumerate() {
            shard_sizes.insert(idx as u64, sref.size_compressed);
        }

        // Build file maps from manifest entries
        for entry_result in manifest.iter() {
            let entry = entry_result?;
            let shard_id = entry.shard_index as u64;
            file_to_shard.insert(entry.path.clone(), shard_id);
            file_hashes.insert(entry.path.clone(), entry.content_hash);
            shard_files.entry(shard_id).or_default().push(entry.path.clone());
        }

        // Sort file lists within each shard
        for files in shard_files.values_mut() {
            files.sort();
        }

        Ok(Self {
            file_to_shard,
            file_hashes,
            shard_cids,
            shard_files,
            shard_sizes,
            dir_listing_counts: HashMap::new(), // No longer tracked
        })
    }

    /// Builds diagnostics by loading the manifest from a commit.
    pub fn from_commit(ctx: &VoidContext, commit: &Commit, metadata: &MetadataBundle, reader: &CommitReader) -> Result<Self> {
        let store = ctx.open_store()?;
        let manifest = TreeManifest::from_commit(&store, commit, reader)?
            .ok_or_else(|| crate::VoidError::NotFound("commit has no manifest".into()))?;
        Self::from_manifest(&manifest, metadata)
    }

    /// Convenience: loads HEAD commit and builds diagnostics.
    ///
    /// Used by tests that have a VoidContext + MetadataBundle but not the commit object.
    pub fn from_metadata(ctx: &VoidContext, metadata: &MetadataBundle, reader: &CommitReader) -> Result<Self> {
        let store = ctx.open_store()?;
        // Load HEAD commit
        let head_cid = crate::refs::resolve_head(&ctx.paths.void_dir)?
            .ok_or_else(|| crate::VoidError::NotFound("HEAD".into()))?;
        let commit_cid = cid::from_bytes(head_cid.as_bytes())?;
        let commit_encrypted: void_crypto::EncryptedCommit = store.get_blob(&commit_cid)?;
        let (commit_bytes, _) = CommitReader::open_with_vault(&ctx.crypto.vault, &commit_encrypted)?;
        let commit = commit_bytes.parse()?;

        let manifest = TreeManifest::from_commit(&store, &commit, reader)?
            .ok_or_else(|| crate::VoidError::NotFound("commit has no manifest".into()))?;
        Self::from_manifest(&manifest, metadata)
    }

    /// Returns the number of files indexed in the diagnostics snapshot.
    pub fn total_files(&self) -> usize {
        self.file_to_shard.len()
    }

    /// Returns the number of shards with data in the snapshot.
    pub fn shard_count(&self) -> usize {
        self.shard_files.len()
    }

    /// Computes differences between two snapshots.
    pub fn diff(&self, next: &Self) -> ShardDiff {
        let mut new_files = Vec::new();
        let mut removed_files = Vec::new();
        let mut moved_files = Vec::new();
        let mut modified_files = Vec::new();

        for (file, shard_id) in &next.file_to_shard {
            let prev_id = match self.file_to_shard.get(file) {
                Some(id) => id,
                None => {
                    new_files.push(file.clone());
                    continue;
                }
            };

            if prev_id != shard_id {
                moved_files.push((file.clone(), *prev_id, *shard_id));
            }

            if self
                .file_hashes
                .get(file)
                .zip(next.file_hashes.get(file))
                .map(|(prev, next)| prev != next)
                .unwrap_or(false)
            {
                modified_files.push(file.clone());
            }
        }

        for file in self.file_to_shard.keys() {
            if !next.file_to_shard.contains_key(file) {
                removed_files.push(file.clone());
            }
        }

        new_files.sort();
        removed_files.sort();
        moved_files.sort_by(|a, b| a.0.cmp(&b.0));
        modified_files.sort();

        ShardDiff {
            new_files,
            removed_files,
            moved_files,
            modified_files,
        }
    }
}