batpak 0.8.0

Event sourcing with causal graphs and caller-defined gates. Sync API, no async runtime.
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

use crate::store::stats::MmapEvidence;
use crate::store::StoreError;
use memmap2::Mmap;
use std::fs::File;

#[derive(Clone, Copy, Debug)]
pub(crate) struct SealedSegmentMmapAdmission {
    _private: (),
}

#[derive(Clone, Copy, Debug)]
pub(crate) struct MmapIndexAdmission {
    _private: (),
}

pub(crate) fn admit_mmap_index(evidence: MmapEvidence) -> Result<MmapIndexAdmission, StoreError> {
    match evidence {
        MmapEvidence::FileBacked => Ok(MmapIndexAdmission { _private: () }),
        MmapEvidence::Unknown | MmapEvidence::ObservedUnsupported | MmapEvidence::ProbeFailed => {
            Err(StoreError::PlatformAdmissionFailed {
                capability: "mmap index",
                reason: format!("mmap index evidence {evidence:?} is not admissible"),
            })
        }
    }
}

pub(crate) fn admit_sealed_segment_mmap(
    evidence: MmapEvidence,
) -> Result<SealedSegmentMmapAdmission, StoreError> {
    match evidence {
        MmapEvidence::FileBacked => Ok(SealedSegmentMmapAdmission { _private: () }),
        MmapEvidence::Unknown | MmapEvidence::ObservedUnsupported | MmapEvidence::ProbeFailed => {
            Err(StoreError::PlatformAdmissionFailed {
                capability: "sealed segment mmap",
                reason: format!("sealed segment mmap evidence {evidence:?} is not admissible"),
            })
        }
    }
}

/// Map a file using the target mmap primitive.
///
/// # Safety
/// Callers own the semantic proof that the mapped file will not be mutated in a
/// way that violates the store path using the mapping.
pub(crate) unsafe fn map_mmap_index_file(
    file: &File,
    _admission: MmapIndexAdmission,
) -> std::io::Result<Mmap> {
    unsafe { Mmap::map(file) }
}

/// Map a sealed segment using an admitted mmap token.
///
/// # Safety
/// The admission token proves only the target mmap mechanism. Callers still own
/// the store semantic proof that this segment is sealed and immutable.
pub(crate) unsafe fn map_sealed_segment_file(
    file: &File,
    _admission: SealedSegmentMmapAdmission,
) -> std::io::Result<Mmap> {
    unsafe { Mmap::map(file) }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn mmap_index_admission_only_accepts_file_backed_evidence() {
        assert!(
            admit_mmap_index(MmapEvidence::FileBacked).is_ok(),
            "PROPERTY: file-backed mmap evidence must admit index mmap"
        );
        for evidence in [
            MmapEvidence::Unknown,
            MmapEvidence::ObservedUnsupported,
            MmapEvidence::ProbeFailed,
        ] {
            assert!(
                matches!(
                    admit_mmap_index(evidence),
                    Err(StoreError::PlatformAdmissionFailed {
                        capability: "mmap index",
                        ..
                    })
                ),
                "PROPERTY: mmap index evidence {evidence:?} must reject with a mmap-index admission failure"
            );
        }
    }

    #[test]
    fn sealed_segment_mmap_admission_only_accepts_file_backed_evidence() {
        assert!(
            admit_sealed_segment_mmap(MmapEvidence::FileBacked).is_ok(),
            "PROPERTY: file-backed mmap evidence must admit sealed-segment mmap"
        );
        for evidence in [
            MmapEvidence::Unknown,
            MmapEvidence::ObservedUnsupported,
            MmapEvidence::ProbeFailed,
        ] {
            assert!(
                matches!(
                    admit_sealed_segment_mmap(evidence),
                    Err(StoreError::PlatformAdmissionFailed {
                        capability: "sealed segment mmap",
                        ..
                    })
                ),
                "PROPERTY: sealed-segment mmap evidence {evidence:?} must reject with a sealed-segment admission failure"
            );
        }
    }
}