entropyfs 0.7.17

Entropy-native Linux filesystem: persist irreducible state, materialize structure, preserve exact bytes.
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

//! Engine API smoke (Phase 12E.8, stage 8): the minimal embeddable-engine
//! exercise the distribution court runs in every container.
//!
//! Creates a store, puts a blob, gets it back, verifies byte identity,
//! syncs, closes, reopens, verifies again. Prints one line per step and
//! `engine smoke: OK` at the end; exits non-zero on any failure.
//!
//! Usage: entropyfs-engine-smoke <store-dir> [--io-backend sync|uring]

use std::path::PathBuf;

fn main() {
    let args: Vec<String> = std::env::args().collect();
    let dir = args
        .get(1)
        .map(PathBuf::from)
        .expect("usage: engine_smoke <store-dir> [--io-backend sync|uring]");
    let io_backend = match args.iter().position(|a| a == "--io-backend") {
        Some(i) => args
            .get(i + 1)
            .map(|s| entropyfs::store::io::IoBackendKind::parse(s).expect("backend"))
            .unwrap_or(entropyfs::store::io::IoBackendKind::Sync),
        None => entropyfs::store::io::IoBackendKind::Sync,
    };

    let opts = entropyfs::engine::EngineOpenOptions {
        io_backend,
        ..Default::default()
    };
    let payload = b"distro-court engine smoke payload: 0123456789abcdef".to_vec();

    let engine = entropyfs::engine::Engine::create(&dir, &opts).expect("engine create");
    let id = engine.put_blob(&payload).expect("put");
    let got = engine.get_blob(id).expect("get");
    assert_eq!(got, payload, "byte identity after put/get");
    println!("put/get byte-exact: ok ({} bytes)", payload.len());
    engine.sync().expect("sync");
    let m = engine.metrics().expect("metrics");
    println!(
        "metrics: blob_count={} format={}.{} backend={}",
        m.accounting.blob_count, m.format.format_major, m.format.format_minor, m.format.io_backend
    );
    engine.close().expect("close");

    let engine = entropyfs::engine::Engine::open(&dir, &opts).expect("engine reopen");
    let got2 = engine.get_blob(id).expect("get after reopen");
    assert_eq!(got2, payload, "byte identity after reopen");
    engine.close().expect("close");

    println!("engine smoke: OK");
}