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

//! Pin management operations for Node

use ipfrs_core::{Cid, Result};
use ipfrs_storage::BlockStoreTrait;
use std::path::Path;

use crate::pin::{PinInfo, PinType};

use super::Node;

impl Node {
    /// Pin a block (prevent it from being garbage collected)
    pub async fn pin_add(&self, cid: &Cid, recursive: bool, name: Option<String>) -> Result<()> {
        // Verify the block exists
        if !self.storage()?.has(cid).await? {
            return Err(ipfrs_core::Error::NotFound(cid.to_string()));
        }

        let pin_type = if recursive {
            PinType::Recursive
        } else {
            PinType::Direct
        };

        self.pin_manager.pin(*cid, pin_type, name)?;

        // If recursive, traverse and mark all referenced blocks
        if recursive {
            self.mark_recursive_pins(cid).await?;
        }

        Ok(())
    }

    /// Mark all blocks referenced by a CID as indirectly pinned
    pub(super) async fn mark_recursive_pins(&self, root: &Cid) -> Result<()> {
        let storage = self.storage()?;
        let mut to_visit = vec![*root];
        let mut visited = std::collections::HashSet::new();

        while let Some(cid) = to_visit.pop() {
            if !visited.insert(cid) {
                continue;
            }

            // Get the block and try to parse as IPLD
            if let Some(block) = storage.get(&cid).await? {
                if let Ok(ipld) = ipfrs_core::Ipld::from_dag_cbor(block.data()) {
                    // Add all links as indirect pins
                    for link_cid in ipld.links() {
                        self.pin_manager.add_indirect(*root, link_cid);
                        to_visit.push(link_cid);
                    }
                }
            }
        }

        Ok(())
    }

    /// Unpin a block
    pub async fn pin_rm(&self, cid: &Cid, recursive: bool) -> Result<()> {
        self.pin_manager.unpin(cid, recursive)
    }

    /// List all pinned blocks
    pub fn pin_ls(&self) -> Result<Vec<PinInfo>> {
        Ok(self.pin_manager.list())
    }

    /// Verify all pins are available
    pub async fn pin_verify(&self) -> Result<Vec<(Cid, bool)>> {
        let storage = self.storage()?;
        let pins = self.pin_manager.list();
        let mut results = Vec::new();

        for pin in pins {
            let exists = storage.has(&pin.cid).await?;
            results.push((pin.cid, exists));
        }

        Ok(results)
    }

    /// Save pin index to disk
    pub async fn pin_save(&self, path: impl AsRef<Path>) -> Result<()> {
        self.pin_manager.save(path).await
    }

    /// Load pin index from disk
    pub async fn pin_load(&self, path: impl AsRef<Path>) -> Result<()> {
        self.pin_manager.load(path).await
    }
}