#![cfg_attr(not(target_arch = "wasm32"), allow(dead_code))]
use crate::key::LockerId;
pub(crate) const INLINE_LIMIT: usize = 4096;
#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct Change {
pub key: Vec<u8>,
pub value: Option<Vec<u8>>,
pub bytes: Option<u64>,
pub deleted: bool,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct Announcement {
pub instance: u32,
pub locker_id: LockerId,
pub epoch: u64,
pub cleared: bool,
pub changes: Vec<Change>,
}
pub(crate) trait Sink {
fn locker_id(&self) -> LockerId;
fn apply(&self, announcement: &Announcement);
}
pub(crate) fn announcement_from_ops(
instance: u32,
locker_id: LockerId,
epoch: u64,
ops: &[crate::backend::api::Op],
) -> Option<Announcement> {
use crate::backend::api::{Op, Table};
let mut changes: Vec<Change> = Vec::new();
let mut cleared = false;
let locker_range = crate::key::locker_range(locker_id);
for op in ops {
match op {
Op::Put {
table: Table::Records,
key,
value,
} => {
let Ok(user_key) = crate::key::decode_bytes(locker_id, key) else {
continue;
};
let pointer = crate::locker::chunk::is_pointer(value);
let inline = if value.len() <= INLINE_LIMIT && !pointer {
Some(value.clone())
} else {
None
};
let bytes = if pointer {
crate::locker::chunk::ChunkPointer::parse(value)
.ok()
.map(|p| p.total_len)
} else {
None
};
changes.push(Change {
key: user_key.to_vec(),
value: inline,
bytes,
deleted: false,
});
}
Op::Delete {
table: Table::Records,
key,
} => {
let Ok(user_key) = crate::key::decode_bytes(locker_id, key) else {
continue;
};
changes.push(Change {
key: user_key.to_vec(),
value: None,
bytes: None,
deleted: true,
});
}
Op::DeleteRange {
table: Table::Records,
range,
} if *range == locker_range => {
cleared = true;
changes.clear();
}
_ => {}
}
}
if !cleared && changes.is_empty() {
return None;
}
Some(Announcement {
instance,
locker_id,
epoch,
cleared,
changes,
})
}
#[cfg(test)]
mod tests {
use super::*;
use crate::backend::api::{Op, Table};
fn put(id: LockerId, key: &str, value: Vec<u8>) -> Op {
Op::Put {
table: Table::Records,
key: crate::key::encode(id, key),
value,
}
}
#[test]
fn a_small_write_carries_its_bytes() {
let a = announcement_from_ops(1, 7, 3, &[put(7, "k", vec![1, 2, 3])]).expect("news");
assert_eq!(a.locker_id, 7);
assert_eq!(a.epoch, 3);
assert!(!a.cleared);
assert_eq!(a.changes.len(), 1);
assert_eq!(a.changes[0].key, b"k".to_vec());
assert_eq!(a.changes[0].value, Some(vec![1, 2, 3]));
assert!(!a.changes[0].deleted);
}
#[test]
fn a_large_write_names_the_key_and_nothing_else() {
let big = vec![0u8; INLINE_LIMIT + 1];
let a = announcement_from_ops(1, 7, 0, &[put(7, "k", big)]).expect("news");
assert_eq!(a.changes[0].value, None);
assert!(
!a.changes[0].deleted,
"a large write is not a delete; a receiver must not drop the key"
);
}
#[test]
fn a_chunk_pointer_is_never_inlined() {
let pointer = crate::locker::chunk::ChunkPointer {
value_id: 1,
n_chunks: 2,
total_len: 9,
flags: crate::locker::chunk::FLAG_POSTCARD,
}
.encode();
let a = announcement_from_ops(1, 7, 0, &[put(7, "k", pointer)]).expect("news");
assert_eq!(a.changes[0].value, None);
assert!(!a.changes[0].deleted);
assert_eq!(
a.changes[0].bytes,
Some(9),
"a pointer states its payload length so a receiver can account for it"
);
}
#[test]
fn a_clear_supersedes_the_writes_before_it() {
let ops = vec![
put(7, "a", vec![1]),
Op::DeleteRange {
table: Table::Records,
range: crate::key::locker_range(7),
},
put(7, "b", vec![2]),
];
let a = announcement_from_ops(1, 7, 0, &ops).expect("news");
assert!(a.cleared);
assert_eq!(a.changes.len(), 1, "only the writes after the clear");
assert_eq!(a.changes[0].key, b"b".to_vec());
}
#[test]
fn bookkeeping_alone_is_not_news() {
let ops = vec![Op::Put {
table: Table::Meta,
key: b"next_tick".to_vec(),
value: vec![0; 8],
}];
assert!(announcement_from_ops(1, 7, 0, &ops).is_none());
}
}