use std::collections::BTreeMap;
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct SnapshotSeed {
pub version: u32,
pub declared_len: u64,
pub root_digest: u64,
pub entries: Vec<(u64, u64)>,
pub opaque_note: Vec<u8>,
}
pub fn seed_digest(entries: &[(u64, u64)]) -> u64 {
entries
.iter()
.fold(0xcbf2_9ce4_8422_2325_u64, |acc, (source, stamp)| {
acc.wrapping_mul(0x0100_0000_01b3)
.wrapping_add(*source)
.wrapping_mul(0x0100_0000_01b3)
.wrapping_add(*stamp)
})
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum SnapshotRefusal {
SeedBeyondCapacity { declared: u64, limit: u64 },
CapacityExceededMidDecode { consumed: u64, limit: u64 },
BindingRefusesExport(BindingClass),
GitattributesRequiresMutationPermit,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum RestoreOutcome {
Promoted { sources: usize },
SeedRejected { unproven: usize },
Quarantined { id: u64 },
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct QuarantineMetadata {
pub id: u64,
pub declared_digest: u64,
pub computed_digest: u64,
pub entry_count: usize,
pub opaque_len: usize,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum GitVisibility {
AlreadyTracked,
UntrackedVisible,
IgnoredForceAddRequired,
Unavailable,
}
impl GitVisibility {
pub const ALL: [GitVisibility; 4] = [
GitVisibility::AlreadyTracked,
GitVisibility::UntrackedVisible,
GitVisibility::IgnoredForceAddRequired,
GitVisibility::Unavailable,
];
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum BindingClass {
NormalWritable,
ExplicitProtected,
ReadOnly,
UserLocalOnly,
MemoryOnly,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct ExportReceipt {
pub visibility: GitVisibility,
}
impl ExportReceipt {
pub fn shareability(&self) -> Option<bool> {
match self.visibility {
GitVisibility::AlreadyTracked | GitVisibility::UntrackedVisible => Some(true),
GitVisibility::IgnoredForceAddRequired => Some(false),
GitVisibility::Unavailable => None,
}
}
}
struct QuarantineEntry {
metadata: QuarantineMetadata,
rollback_payload: Option<SnapshotSeed>,
}
impl std::fmt::Debug for QuarantineEntry {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("QuarantineEntry")
.field("metadata", &self.metadata)
.field(
"rollback_payload",
&self
.rollback_payload
.as_ref()
.map(|seed| format!("<retained, {} opaque bytes>", seed.opaque_note.len())),
)
.finish()
}
}
#[derive(Debug, Default)]
pub struct SnapshotStore {
v10: Vec<Vec<u8>>,
current: BTreeMap<u64, u64>,
quarantine: Vec<QuarantineEntry>,
next_quarantine: u64,
rebuild_required: bool,
team_artifacts: Vec<usize>,
diagnostics: Vec<String>,
}
impl SnapshotStore {
pub fn new() -> Self {
Self::default()
}
pub fn v10_write(&mut self, bytes: Vec<u8>) {
self.v10.push(bytes);
}
pub fn v10_namespace(&self) -> Vec<Vec<u8>> {
self.v10.clone()
}
pub fn restore(
&mut self,
seed: SnapshotSeed,
limit: u64,
mut decode: impl FnMut(&(u64, u64)) -> (u64, u64),
prove: impl Fn(u64, u64) -> bool,
) -> Result<RestoreOutcome, SnapshotRefusal> {
if seed.declared_len > limit {
return Err(SnapshotRefusal::SeedBeyondCapacity {
declared: seed.declared_len,
limit,
});
}
let mut decoded: Vec<(u64, u64)> = Vec::new();
let mut consumed: u64 = 0;
for entry in &seed.entries {
consumed += 16;
if consumed > limit {
return Err(SnapshotRefusal::CapacityExceededMidDecode { consumed, limit });
}
decoded.push(decode(entry));
}
let computed = seed_digest(&decoded);
if computed != seed.root_digest {
let id = self.next_quarantine;
self.next_quarantine += 1;
self.diagnostics.push(format!(
"seed {id}: digest mismatch, {} entries, opaque {} bytes",
decoded.len(),
seed.opaque_note.len()
));
self.quarantine.push(QuarantineEntry {
metadata: QuarantineMetadata {
id,
declared_digest: seed.root_digest,
computed_digest: computed,
entry_count: decoded.len(),
opaque_len: seed.opaque_note.len(),
},
rollback_payload: Some(seed),
});
self.rebuild_required = true;
return Ok(RestoreOutcome::Quarantined { id });
}
let unproven = decoded
.iter()
.filter(|(source, stamp)| !prove(*source, *stamp))
.count();
if unproven > 0 {
self.diagnostics.push(format!(
"seed rejected: {unproven} of {} entries lack current-process proof",
decoded.len()
));
self.rebuild_required = true;
return Ok(RestoreOutcome::SeedRejected { unproven });
}
let sources = decoded.len();
self.current = decoded.into_iter().collect();
self.diagnostics
.push(format!("seed promoted: {sources} sources"));
Ok(RestoreOutcome::Promoted { sources })
}
pub fn current(&self) -> BTreeMap<u64, u64> {
self.current.clone()
}
pub fn rebuild_required(&self) -> bool {
self.rebuild_required
}
pub fn quarantine_metadata(&self) -> Vec<QuarantineMetadata> {
self.quarantine
.iter()
.map(|entry| entry.metadata.clone())
.collect()
}
pub fn rollback(&mut self, id: u64) -> Option<SnapshotSeed> {
self.quarantine
.iter_mut()
.find(|entry| entry.metadata.id == id)
.and_then(|entry| entry.rollback_payload.take())
}
pub fn diagnostics(&self) -> Vec<String> {
self.diagnostics.clone()
}
pub fn export_team_artifact(
&mut self,
binding: BindingClass,
visibility: GitVisibility,
artifact: Vec<u8>,
) -> Result<ExportReceipt, SnapshotRefusal> {
if binding != BindingClass::NormalWritable {
return Err(SnapshotRefusal::BindingRefusesExport(binding));
}
self.team_artifacts.push(artifact.len());
Ok(ExportReceipt { visibility })
}
pub fn team_artifacts(&self) -> usize {
self.team_artifacts.len()
}
pub fn export_with_gitattributes_change(
&mut self,
binding: BindingClass,
visibility: GitVisibility,
) -> SnapshotRefusal {
let _ = (binding, visibility);
SnapshotRefusal::GitattributesRequiresMutationPermit
}
}