ipfrs 0.2.0

Next-generation distributed file system with content-addressing, semantic search, and logic programming
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

//! Repository management and analysis operations for Node

use ipfrs_core::{Cid, Result};
use ipfrs_storage::{OrphanGarbageCollector, OrphanGcConfig};

use crate::fsck::{FilesystemChecker, FsckConfig};
use crate::gc::{GarbageCollector, GcConfig};

use super::{FsckResult, GcResult, Node, OrphanGcResult};

impl Node {
    /// Run garbage collection
    pub async fn repo_gc(&self, dry_run: bool) -> Result<GcResult> {
        self.repo_gc_with_options(dry_run, 3600).await
    }

    /// Run orphan block garbage collection using [`OrphanGarbageCollector`].
    ///
    /// Collects blocks that are present in the store but are not referenced by
    /// any pinned CID.  When `dry_run` is `true` the orphans are reported but
    /// not actually deleted.  The `min_age_secs` parameter is stored in the
    /// config for future use when per-block timestamps become available.
    pub async fn gc_blocks(&self, dry_run: bool, min_age_secs: u64) -> Result<OrphanGcResult> {
        let storage = self.storage()?;

        // Build the pinned CID set from the local pin manager.
        let pinned_cids: std::collections::HashSet<String> = self
            .pin_manager
            .list()
            .into_iter()
            .map(|pin| pin.cid.to_string())
            .collect();

        let config = OrphanGcConfig {
            dry_run,
            min_age_secs,
            batch_size: 1000,
        };
        let collector = OrphanGarbageCollector::new(config);
        let result = collector.collect(storage.as_ref(), &pinned_cids).await?;
        Ok(result)
    }

    /// Run garbage collection with explicit age filter.
    ///
    /// `min_age_secs` – blocks younger than this many seconds are spared
    /// (passed through to the underlying GC config).
    pub async fn repo_gc_with_options(&self, dry_run: bool, min_age_secs: u64) -> Result<GcResult> {
        let storage = self.storage()?;
        let gc = GarbageCollector::new(storage.clone(), self.pin_manager.clone());

        let config = GcConfig {
            dry_run,
            min_age_seconds: min_age_secs,
            ..Default::default()
        };

        let stats = gc.collect(config).await?;

        Ok(GcResult {
            blocks_collected: stats.blocks_collected,
            bytes_freed: stats.bytes_freed,
            blocks_marked: stats.blocks_marked,
            blocks_scanned: stats.blocks_scanned,
            duration: stats.duration,
            cancelled: stats.cancelled,
        })
    }

    /// Verify repository integrity
    pub async fn repo_fsck(&self) -> Result<FsckResult> {
        let storage = self.storage()?;
        let fsck = FilesystemChecker::new(storage.clone());

        let config = FsckConfig::default();
        let result = fsck.check(config).await?;

        Ok(FsckResult {
            blocks_checked: result.blocks_checked,
            blocks_valid: result.blocks_valid,
            blocks_corrupt: result.blocks_corrupt,
            blocks_missing: result.blocks_missing,
        })
    }

    /// Run quick filesystem check (only verify CIDs match content)
    pub async fn repo_fsck_quick(&self) -> Result<FsckResult> {
        let storage = self.storage()?;
        let fsck = FilesystemChecker::new(storage.clone());

        let result = fsck.quick_check().await?;

        Ok(FsckResult {
            blocks_checked: result.blocks_checked,
            blocks_valid: result.blocks_valid,
            blocks_corrupt: result.blocks_corrupt,
            blocks_missing: result.blocks_missing,
        })
    }

    /// Get garbage collection statistics (without running GC)
    pub fn gc_stats(&self) -> Result<(usize, usize)> {
        let storage = self.storage()?;
        let gc = GarbageCollector::new(storage.clone(), self.pin_manager.clone());

        let unpinned_count = gc.count_unpinned()?;
        let pinned_count = self.pin_manager.count();

        Ok((pinned_count, unpinned_count))
    }

    /// Get comprehensive repository statistics
    pub async fn repo_stat(&self) -> Result<crate::repo::RepoStats> {
        let storage = self.storage()?;
        let analyzer = crate::repo::RepoAnalyzer::new(storage.clone(), self.pin_manager.clone());
        analyzer.analyze().await
    }

    /// Get block size distribution
    pub async fn block_distribution(&self) -> Result<crate::repo::BlockDistribution> {
        let storage = self.storage()?;
        let analyzer = crate::repo::RepoAnalyzer::new(storage.clone(), self.pin_manager.clone());
        analyzer.block_distribution().await
    }

    /// Find duplicate blocks (same content, different CIDs)
    pub async fn find_duplicates(&self) -> Result<Vec<Vec<Cid>>> {
        let storage = self.storage()?;
        let analyzer = crate::repo::RepoAnalyzer::new(storage.clone(), self.pin_manager.clone());
        analyzer.find_duplicates().await
    }

    /// Get largest blocks in the repository
    pub async fn largest_blocks(&self, limit: usize) -> Result<Vec<(Cid, u64)>> {
        let storage = self.storage()?;
        let analyzer = crate::repo::RepoAnalyzer::new(storage.clone(), self.pin_manager.clone());
        analyzer.largest_blocks(limit).await
    }

    /// Find orphaned blocks (not pinned and not referenced)
    pub async fn find_orphaned(&self) -> Result<Vec<Cid>> {
        let storage = self.storage()?;
        let analyzer = crate::repo::RepoAnalyzer::new(storage.clone(), self.pin_manager.clone());
        analyzer.find_orphaned_blocks().await
    }
}