dig-capsule 0.5.0

The DIG Network .dig capsule data plane — one crate over the DIGS format, capsule read-crypto, compiler, staging, and the guest/host serve triad.
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

use crate::imp::core::Bytes32;
use std::path::{Path, PathBuf};

/// Pure builder for the §4.4 on-disk layout. Performs no filesystem I/O.
///
/// ```text
/// {data_dir}/
///   {store_id_hex}.staging.bin
///   config.toml
///   roots.log                         // append-only root history
///   generations/{roothash_hex}/manifest.json
///   generations/{roothash_hex}/chunks/{chunk_hash_hex}   // sparse after dedup
///   modules/{store_id_hex}-{roothash_hex}.dig
/// ```
#[derive(Debug, Clone)]
pub struct StorePaths {
    root: PathBuf,
    store_id_hex: String,
}

impl StorePaths {
    pub fn new(data_dir: impl AsRef<Path>, store_id: Bytes32) -> Self {
        Self {
            root: data_dir.as_ref().to_path_buf(),
            store_id_hex: store_id.to_hex(),
        }
    }

    pub fn root(&self) -> PathBuf {
        self.root.clone()
    }

    pub fn config_file(&self) -> PathBuf {
        self.root.join("config.toml")
    }

    pub fn history_file(&self) -> PathBuf {
        self.root.join("roots.log")
    }

    pub fn staging_file(&self) -> PathBuf {
        self.root.join(format!("{}.staging.bin", self.store_id_hex))
    }

    pub fn generations_dir(&self) -> PathBuf {
        self.root.join("generations")
    }

    pub fn modules_dir(&self) -> PathBuf {
        self.root.join("modules")
    }

    pub fn generation_dir(&self, root_hex: &str) -> PathBuf {
        self.generations_dir().join(root_hex)
    }

    pub fn generation_manifest(&self, root_hex: &str) -> PathBuf {
        self.generation_dir(root_hex).join("manifest.json")
    }

    pub fn generation_chunks_dir(&self, root_hex: &str) -> PathBuf {
        self.generation_dir(root_hex).join("chunks")
    }

    pub fn chunk_file(&self, root_hex: &str, chunk_hash_hex: &str) -> PathBuf {
        self.generation_chunks_dir(root_hex).join(chunk_hash_hex)
    }

    pub fn module_file(&self, root_hex: &str) -> PathBuf {
        self.modules_dir()
            .join(format!("{}-{}.dig", self.store_id_hex, root_hex))
    }

    pub fn store_id_hex(&self) -> &str {
        &self.store_id_hex
    }
}

#[cfg(all(test, not(target_arch = "wasm32")))]
mod tests {
    use super::*;
    use crate::imp::core::Bytes32;
    use std::path::PathBuf;

    fn sid() -> Bytes32 {
        Bytes32([0x11u8; 32])
    }

    #[test]
    fn root_and_top_level_files() {
        let p = StorePaths::new("/data", sid());
        assert_eq!(p.root(), PathBuf::from("/data"));
        assert_eq!(p.config_file(), PathBuf::from("/data/config.toml"));
        let hex = "11".repeat(32);
        assert_eq!(
            p.staging_file(),
            PathBuf::from(format!("/data/{hex}.staging.bin"))
        );
    }

    #[test]
    fn generation_subtree() {
        let p = StorePaths::new("/data", sid());
        let root_hex = "ab".repeat(32);
        let gen = p.generation_dir(&root_hex);
        assert_eq!(gen, PathBuf::from(format!("/data/generations/{root_hex}")));
        assert_eq!(
            p.generation_manifest(&root_hex),
            PathBuf::from(format!("/data/generations/{root_hex}/manifest.json"))
        );
        assert_eq!(
            p.generation_chunks_dir(&root_hex),
            PathBuf::from(format!("/data/generations/{root_hex}/chunks"))
        );
        assert_eq!(
            p.chunk_file(&root_hex, "cc"),
            PathBuf::from(format!("/data/generations/{root_hex}/chunks/cc"))
        );
    }

    #[test]
    fn module_and_history_paths() {
        let p = StorePaths::new("/data", sid());
        let sid_hex = "11".repeat(32);
        let root_hex = "ab".repeat(32);
        assert_eq!(
            p.module_file(&root_hex),
            PathBuf::from(format!("/data/modules/{sid_hex}-{root_hex}.dig"))
        );
        assert_eq!(p.generations_dir(), PathBuf::from("/data/generations"));
        assert_eq!(p.modules_dir(), PathBuf::from("/data/modules"));
        assert_eq!(p.history_file(), PathBuf::from("/data/roots.log"));
    }
}