use std::collections::BTreeMap;
use std::ops::Bound;
use std::sync::atomic::AtomicBool;
use std::sync::{Arc, Mutex};
use serde::{de::DeserializeOwned, Serialize};
use crate::backend::api::Backend;
use crate::codec::FilterChain;
use crate::error::{Error, Result};
use crate::key::LockerId;
use super::inner::Inner;
use super::policy::{LockerConfig, OnCorrupt, Policy};
use super::resident::{Pending, Resident};
use super::transaction::{Staged, Transaction, TxMode};
use crate::watch::Event;
pub(crate) type EagerValues<T> = Mutex<BTreeMap<Vec<u8>, Arc<T>>>;
pub struct Locker<T> {
inner: Arc<Inner>,
values: Arc<EagerValues<T>>,
res: Arc<Resident>,
}
impl<T> std::fmt::Debug for Locker<T> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("Locker")
.field("name", &self.inner.name)
.field("entries", &self.len())
.finish()
}
}
impl<T> Locker<T>
where
T: Serialize + DeserializeOwned,
{
pub(crate) async fn open(
backend: Arc<dyn Backend>,
chain: Arc<FilterChain>,
id: LockerId,
name: String,
config: LockerConfig,
shared: Arc<super::inner::Shared>,
) -> Result<Self> {
if let Policy::Evictable { .. } = config.policy {
return Err(Error::InvalidConfig(format!(
"locker {name:?} is eager, which cannot use an evictable policy; \
use a lazy locker instead"
)));
}
let budget = config.eager_budget;
let on_corrupt = config.on_corrupt;
let inner = Arc::new(Inner {
write_lock: futures::lock::Mutex::new(()),
backend,
chain,
id,
name,
config,
shared,
watchers: Default::default(),
closed: AtomicBool::new(false),
epochs: Default::default(),
name_shared: AtomicBool::new(false),
});
let mut values = BTreeMap::new();
let mut corrupt: Vec<Vec<u8>> = Vec::new();
let mut loaded: u64 = 0;
let mut overflow: Option<u64> = None;
inner
.walk(
Bound::Unbounded,
Bound::Unbounded,
false,
true,
|key, raw| {
let bytes = raw.ok_or_else(|| {
Error::Corrupt(format!("backend omitted a value for key {key:?}"))
})?;
loaded = loaded.saturating_add(bytes.len() as u64);
if loaded > budget {
overflow.get_or_insert(loaded);
return Ok(());
}
match inner.open::<T>(&bytes) {
Ok(value) => {
values.insert(key, Arc::new(value));
}
Err(e) if on_corrupt == OnCorrupt::Skip && e.is_corruption() => {
corrupt.push(key);
}
Err(e) => return Err(e),
}
Ok(())
},
)
.await?;
if overflow.is_some() {
return Err(Error::LockerTooLarge {
bytes: loaded,
budget,
});
}
let res = Arc::new(Resident::new(inner.clone(), TxMode::Eager, None, None));
for key in corrupt {
res.note_corrupt(&key);
}
Ok(Self {
inner,
values: Arc::new(Mutex::new(values)),
res,
})
}
pub(crate) fn from_shared(
inner: Arc<Inner>,
values: Arc<EagerValues<T>>,
res: Arc<Resident>,
) -> Self {
Self { inner, values, res }
}
pub async fn put(&self, key: &str, value: T) -> Result<Arc<T>> {
self.put_by(key.as_bytes(), value).await
}
pub async fn put_by(&self, key: &[u8], value: T) -> Result<Arc<T>> {
self.inner.ensure_open()?;
let sealed = self.inner.seal(&value)?;
if sealed.len() > self.inner.config.max_inline {
return Err(Error::ValueTooLarge {
bytes: sealed.len(),
max_inline: self.inner.config.max_inline,
});
}
if self.res.is_deferred() {
let payload = postcard::to_allocvec(&value)
.map_err(|e| Error::Filter(format!("postcard serialisation failed: {e}")))?;
let full = self.res.stage(Pending::Put {
key: key.to_vec(),
payload,
})?;
let shared = Arc::new(value);
if let Ok(mut guard) = self.values.lock() {
guard.insert(key.to_vec(), shared.clone());
}
self.res.forget_dropped(key);
self.inner.announce(Event::Put { key: key.to_vec() });
if full {
let _guard = self.inner.write_lock.lock().await;
self.res.flush_locked().await?;
}
return Ok(shared);
}
let op = crate::backend::api::Op::Put {
table: crate::backend::api::Table::Records,
key: self.inner.encode_key(key),
value: sealed,
};
self.inner.commit(vec![op]).await?;
let shared = Arc::new(value);
if let Ok(mut guard) = self.values.lock() {
guard.insert(key.to_vec(), shared.clone());
}
self.res.forget_dropped(key);
self.inner.announce(Event::Put { key: key.to_vec() });
Ok(shared)
}
pub async fn flush(&self) -> Result<()> {
let staged = self.res.flush().await;
let forced = self.inner.flush_backend().await;
staged.and(forced)
}
pub fn pending(&self) -> usize {
self.res.pending_len().unwrap_or(0)
}
pub fn pending_bytes(&self) -> u64 {
self.res.pending_bytes().unwrap_or(0)
}
pub async fn transact<F, Fut>(&self, f: F) -> Result<()>
where
F: FnOnce(Transaction<T>) -> Fut,
Fut: std::future::Future<Output = Result<()>>,
{
self.inner.ensure_open()?;
let _guard = self.inner.write_lock.lock().await;
let tx = Transaction::new(self.inner.clone());
let staged = tx.staged_handle();
f(tx).await?;
let entries = {
let mut guard = staged
.lock()
.map_err(|_| Error::backend("transaction lock was poisoned"))?;
std::mem::take(&mut *guard)
};
if entries.is_empty() {
return Ok(());
}
let staged_before = self.res.take_staged()?;
let merged = super::lazy::merge_batches(&staged_before, &entries);
let ops =
match super::transaction::ops_for_pending(&self.inner, &merged, TxMode::Eager).await {
Ok(ops) => ops,
Err(e) => {
self.res.restage(staged_before);
return Err(e);
}
};
if let Err(e) = self.inner.commit(ops).await {
self.res.restage(staged_before);
return Err(e);
}
let mut removed_something = vec![true; entries.len()];
if let Ok(mut guard) = self.values.lock() {
for (entry, removed) in entries.iter().zip(removed_something.iter_mut()) {
match entry {
Staged::Put { key, value, .. } => {
guard.insert(key.clone(), value.clone());
}
Staged::Delete { key } => {
*removed = guard.remove(key).is_some() || self.res.stored_but_unheld(key);
self.res.forget_dropped(key);
}
Staged::Clear => {
guard.clear();
self.res.forget_all_dropped();
}
}
}
}
for (entry, removed) in entries.iter().zip(removed_something) {
match entry {
Staged::Put { key, .. } => self.inner.announce(Event::Put { key: key.clone() }),
Staged::Delete { key } if removed => {
self.inner.announce(Event::Deleted { key: key.clone() })
}
Staged::Delete { .. } => {}
Staged::Clear => self.inner.announce(Event::Cleared),
}
}
Ok(())
}
pub async fn delete(&self, key: &str) -> Result<()> {
self.delete_by(key.as_bytes()).await
}
pub async fn delete_by(&self, key: &[u8]) -> Result<()> {
self.inner.ensure_open()?;
let held = self.holds(key);
if !held && self.inner.index_is_authoritative() {
return Ok(());
}
if self.res.is_deferred() {
let full = self.res.stage(Pending::Delete { key: key.to_vec() })?;
if let Ok(mut guard) = self.values.lock() {
guard.remove(key);
}
self.res.forget_dropped(key);
if held {
self.inner.announce(Event::Deleted { key: key.to_vec() });
}
if full {
let _guard = self.inner.write_lock.lock().await;
self.res.flush_locked().await?;
}
return Ok(());
}
self.inner.commit(vec![self.inner.delete_op(key)]).await?;
if let Ok(mut guard) = self.values.lock() {
guard.remove(key);
}
self.res.forget_dropped(key);
if held {
self.inner.announce(Event::Deleted { key: key.to_vec() });
}
Ok(())
}
fn holds(&self, key: &[u8]) -> bool {
match self.values.lock() {
Ok(guard) => guard.contains_key(key) || self.res.stored_but_unheld(key),
Err(_) => true,
}
}
pub async fn put_all(&self, entries: impl IntoIterator<Item = (String, T)>) -> Result<()> {
let entries: Vec<(String, T)> = entries.into_iter().collect();
if entries.is_empty() {
return Ok(());
}
self.transact(move |tx| async move {
for (key, value) in entries {
tx.put(&key, value)?;
}
Ok(())
})
.await
}
pub async fn delete_all(&self, keys: impl IntoIterator<Item = impl AsRef<str>>) -> Result<()> {
let keys: Vec<String> = keys.into_iter().map(|k| k.as_ref().to_string()).collect();
if keys.is_empty() {
return Ok(());
}
self.transact(move |tx| async move {
for key in keys {
tx.delete(&key)?;
}
Ok(())
})
.await
}
pub async fn clear(&self) -> Result<()> {
self.inner.ensure_open()?;
if self.res.is_deferred() {
let full = self.res.stage(Pending::Clear)?;
if let Ok(mut guard) = self.values.lock() {
guard.clear();
}
self.res.forget_all_dropped();
self.inner.announce(Event::Cleared);
if full {
let _guard = self.inner.write_lock.lock().await;
self.res.flush_locked().await?;
}
return Ok(());
}
self.inner.commit(vec![self.inner.clear_op()]).await?;
if let Ok(mut guard) = self.values.lock() {
guard.clear();
}
self.res.forget_all_dropped();
self.inner.announce(Event::Cleared);
Ok(())
}
}
#[cfg_attr(not(target_arch = "wasm32"), allow(dead_code))]
pub(crate) struct EagerSink<T> {
inner: Arc<Inner>,
values: Arc<Mutex<BTreeMap<Vec<u8>, Arc<T>>>>,
res: std::sync::Weak<Resident>,
}
#[cfg_attr(not(target_arch = "wasm32"), allow(dead_code))]
impl<T: DeserializeOwned> crate::coherence::Sink for EagerSink<T> {
fn locker_id(&self) -> LockerId {
self.inner.id
}
fn apply(&self, announcement: &crate::coherence::Announcement) {
if self.inner.is_closed() {
return;
}
if announcement.epoch <= self.inner.epochs.applied() {
return;
}
self.inner.epochs.note_applied(announcement.epoch);
let res = self.res.upgrade();
if announcement.cleared {
if let Ok(mut values) = self.values.lock() {
values.clear();
}
if let Some(res) = res.as_ref() {
res.forget_all_dropped();
}
self.inner.epochs.forget_local();
self.inner.announce(Event::Cleared);
}
for change in &announcement.changes {
if self
.inner
.epochs
.local(&change.key)
.is_some_and(|mine| announcement.epoch <= mine)
{
continue;
}
let decoded = match (change.deleted, &change.value) {
(true, _) => None,
(false, Some(sealed)) => self.inner.open::<T>(sealed).ok().map(Arc::new),
(false, None) => None,
};
let event = match (&decoded, change.deleted) {
(Some(_), _) => Event::Put {
key: change.key.clone(),
},
(None, true) => Event::Deleted {
key: change.key.clone(),
},
(None, false) => Event::Stale {
key: change.key.clone(),
},
};
if let Ok(mut values) = self.values.lock() {
match decoded {
Some(value) => {
values.insert(change.key.clone(), value);
}
None => {
values.remove(change.key.as_slice());
}
}
}
if let Some(res) = res.as_ref() {
match event {
Event::Stale { .. } => res.note_dropped(&change.key),
_ => res.forget_dropped(&change.key),
}
}
self.inner.announce(event);
}
}
}
impl<T> Locker<T> {
#[cfg_attr(not(target_arch = "wasm32"), allow(dead_code))]
pub(crate) fn sink(&self) -> EagerSink<T> {
EagerSink {
inner: self.inner.clone(),
values: self.values.clone(),
res: Arc::downgrade(&self.res),
}
}
}
impl<T: DeserializeOwned + 'static> Locker<T> {
pub(crate) fn join_coherence(&self) {
#[cfg(target_arch = "wasm32")]
{
self.res
.join_coherence(|| crate::coherence::handle(self.sink()));
}
}
}
impl<T> Locker<T> {
pub fn name(&self) -> &str {
&self.inner.name
}
pub(crate) fn inner(&self) -> &Arc<Inner> {
&self.inner
}
pub(crate) fn resident(&self) -> &Arc<Resident> {
&self.res
}
pub(crate) fn shared_values(&self) -> &Arc<EagerValues<T>> {
&self.values
}
pub fn corrupt_keys(&self) -> Vec<Vec<u8>> {
self.res.corrupt_keys()
}
pub async fn close(&self) -> Result<()> {
let flushed = self.res.flush().await;
if flushed.is_ok() {
self.res.discard_staged();
}
let forced = self.inner.flush_backend().await;
self.inner.mark_closed();
if let Ok(mut guard) = self.values.lock() {
guard.clear();
}
flushed.and(forced)
}
pub fn is_closed(&self) -> bool {
self.inner.is_closed()
}
pub fn get(&self, key: &str) -> Option<Arc<T>> {
self.get_by(key.as_bytes())
}
pub fn get_by(&self, key: &[u8]) -> Option<Arc<T>> {
self.values.lock().ok()?.get(key).cloned()
}
pub fn get_cloned(&self, key: &str) -> Option<T>
where
T: Clone,
{
self.get(key).map(|v| (*v).clone())
}
pub fn get_or(&self, key: &str, default: T) -> Arc<T> {
self.get(key).unwrap_or_else(|| Arc::new(default))
}
pub fn with<R>(&self, key: &str, f: impl FnOnce(&T) -> R) -> Option<R> {
let value = self.get(key)?;
Some(f(&value))
}
pub fn contains_key(&self, key: &str) -> bool {
self.contains_key_by(key.as_bytes())
}
pub fn contains_key_by(&self, key: &[u8]) -> bool {
self.values
.lock()
.map(|v| v.contains_key(key))
.unwrap_or(false)
}
pub fn len(&self) -> usize {
self.values.lock().map(|v| v.len()).unwrap_or(0)
}
pub fn is_empty(&self) -> bool {
self.len() == 0
}
pub fn keys(&self) -> Vec<String> {
self.values
.lock()
.map(|v| v.keys().filter_map(|k| super::lazy::utf8(k)).collect())
.unwrap_or_default()
}
pub fn keys_bytes(&self) -> Vec<Vec<u8>> {
self.values
.lock()
.map(|v| v.keys().cloned().collect())
.unwrap_or_default()
}
pub fn has_non_utf8_keys(&self) -> bool {
self.values
.lock()
.map(|v| v.keys().any(|k| std::str::from_utf8(k).is_err()))
.unwrap_or(false)
}
pub fn keys_with_prefix(&self, prefix: &str) -> Vec<String> {
self.keys_with_prefix_by(prefix.as_bytes())
.iter()
.filter_map(|k| super::lazy::utf8(k))
.collect()
}
pub fn keys_with_prefix_by(&self, prefix: &[u8]) -> Vec<Vec<u8>> {
self.values
.lock()
.map(|v| {
v.range(prefix.to_vec()..)
.take_while(|(k, _)| k.starts_with(prefix))
.map(|(k, _)| k.clone())
.collect()
})
.unwrap_or_default()
}
pub fn watch(&self) -> crate::watch::EventStream {
self.inner
.watchers
.subscribe(None, crate::watch::DEFAULT_CAPACITY)
}
pub fn watch_keys(&self, keys: &[&str]) -> crate::watch::EventStream {
self.inner.watchers.subscribe(
Some(keys.iter().map(|k| k.as_bytes().to_vec()).collect()),
crate::watch::DEFAULT_CAPACITY,
)
}
pub fn watch_key(&self, key: &str) -> crate::watch::EventStream {
self.inner.watchers.subscribe(
Some(vec![key.as_bytes().to_vec()]),
crate::watch::DEFAULT_CAPACITY,
)
}
pub fn range<'a, R: std::ops::RangeBounds<&'a str>>(&self, range: R) -> Vec<(String, Arc<T>)> {
let start = crate::key::as_bytes(str_bound(range.start_bound()));
let end = crate::key::as_bytes(str_bound(range.end_bound()));
if crate::key::is_degenerate(start, end) {
return Vec::new();
}
self.values
.lock()
.map(|v| {
v.range::<[u8], _>((start, end))
.filter_map(|(k, val)| super::lazy::utf8(k).map(|k| (k, val.clone())))
.collect()
})
.unwrap_or_default()
}
pub fn to_map(&self) -> BTreeMap<String, Arc<T>> {
self.entries().into_iter().collect()
}
pub fn entries(&self) -> Vec<(String, Arc<T>)> {
self.values
.lock()
.map(|v| {
v.iter()
.filter_map(|(k, val)| super::lazy::utf8(k).map(|k| (k, val.clone())))
.collect()
})
.unwrap_or_default()
}
pub fn entries_bytes(&self) -> Vec<(Vec<u8>, Arc<T>)> {
self.values
.lock()
.map(|v| v.iter().map(|(k, val)| (k.clone(), val.clone())).collect())
.unwrap_or_default()
}
}
fn str_bound<'a>(bound: Bound<&&'a str>) -> Bound<&'a str> {
match bound {
Bound::Unbounded => Bound::Unbounded,
Bound::Included(s) => Bound::Included(s),
Bound::Excluded(s) => Bound::Excluded(s),
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::backend::MemoryBackend;
use crate::codec::default_chain;
use crate::coherence::{api::Change, Announcement, Sink};
use futures::executor::block_on;
use futures::StreamExt;
fn open_with(config: LockerConfig) -> Result<Locker<String>> {
block_on(Locker::open(
Arc::new(MemoryBackend::new()),
Arc::new(default_chain()),
1,
"test".into(),
config,
Default::default(),
))
}
fn locker() -> Locker<String> {
open_with(LockerConfig::default()).unwrap()
}
#[test]
fn a_sink_replaces_a_resident_value_from_an_inline_write() {
let l = locker();
block_on(l.put("k", "mine".into())).unwrap();
let mut events = l.watch();
let sealed = l.inner.seal(&"theirs".to_string()).unwrap();
l.sink().apply(&Announcement {
instance: 2,
locker_id: l.inner.id,
epoch: 1,
cleared: false,
changes: vec![Change {
key: b"k".to_vec(),
value: Some(sealed),
bytes: None,
deleted: false,
}],
});
assert_eq!(l.get("k").as_deref(), Some(&"theirs".to_string()));
assert_eq!(events.try_recv(), Some(Event::Put { key: b"k".to_vec() }));
}
#[test]
fn a_write_it_cannot_hold_goes_stale_rather_than_lying() {
let l = locker();
block_on(l.put("k", "mine".into())).unwrap();
let mut events = l.watch();
l.sink().apply(&Announcement {
instance: 2,
locker_id: l.inner.id,
epoch: 1,
cleared: false,
changes: vec![Change {
key: b"k".to_vec(),
value: None,
bytes: None,
deleted: false,
}],
});
assert_eq!(l.get("k"), None, "a value we cannot decode is not held");
assert_eq!(events.try_recv(), Some(Event::Stale { key: b"k".to_vec() }));
}
#[test]
fn a_key_dropped_as_stale_is_still_deleted() {
let backend = Arc::new(MemoryBackend::new());
let l: Locker<String> = block_on(Locker::open(
backend.clone(),
Arc::new(default_chain()),
1,
"test".into(),
LockerConfig::default(),
Default::default(),
))
.unwrap();
block_on(l.put("session", "mine".into())).unwrap();
let stored = l.inner.encode_key(b"session");
assert!(
block_on(backend.get(crate::backend::api::Table::Records, &stored))
.unwrap()
.is_some()
);
l.sink().apply(&Announcement {
instance: 2,
locker_id: l.inner.id,
epoch: 1,
cleared: false,
changes: vec![Change {
key: b"session".to_vec(),
value: None,
bytes: None,
deleted: false,
}],
});
assert_eq!(l.get("session"), None, "the resident copy is gone");
let mut events = l.watch();
block_on(l.delete("session")).unwrap();
assert_eq!(
block_on(backend.get(crate::backend::api::Table::Records, &stored)).unwrap(),
None,
"the delete must reach storage: the record was still there"
);
assert_eq!(
events.try_recv(),
Some(Event::Deleted {
key: b"session".to_vec()
}),
"and it really took something away, so it is news"
);
}
fn one_change(id: LockerId, epoch: u64, key: &[u8], sealed: Option<Vec<u8>>) -> Announcement {
Announcement {
instance: 2,
locker_id: id,
epoch,
cleared: false,
changes: vec![Change {
key: key.to_vec(),
value: sealed,
bytes: None,
deleted: false,
}],
}
}
#[test]
fn a_sink_ignores_an_announcement_it_has_already_overtaken() {
let l = locker();
let id = l.inner.id;
let sink = l.sink();
let newer = l.inner.seal(&"newer".to_string()).unwrap();
let older = l.inner.seal(&"older".to_string()).unwrap();
sink.apply(&one_change(id, 5, b"k", Some(newer)));
assert_eq!(l.get("k").as_deref(), Some(&"newer".to_string()));
sink.apply(&one_change(id, 5, b"k", Some(older.clone())));
assert_eq!(
l.get("k").as_deref(),
Some(&"newer".to_string()),
"a duplicate epoch must not be replayed"
);
sink.apply(&one_change(id, 3, b"k", Some(older)));
assert_eq!(
l.get("k").as_deref(),
Some(&"newer".to_string()),
"an out-of-order older epoch must not overwrite a newer one"
);
let newest = l.inner.seal(&"newest".to_string()).unwrap();
sink.apply(&one_change(id, 9, b"k", Some(newest)));
assert_eq!(l.get("k").as_deref(), Some(&"newest".to_string()));
}
#[test]
fn a_sink_will_not_undo_this_tabs_own_newer_commit() {
let l = locker();
let id = l.inner.id;
l.inner.epochs.note_local([b"k".to_vec()].into_iter(), 7);
block_on(l.put("k", "mine".into())).unwrap();
let theirs = l.inner.seal(&"theirs".to_string()).unwrap();
l.sink()
.apply(&one_change(id, 7, b"k", Some(theirs.clone())));
assert_eq!(
l.get("k").as_deref(),
Some(&"mine".to_string()),
"an equal epoch must not undo this tab's own commit"
);
l.sink().apply(&one_change(id, 8, b"k", Some(theirs)));
assert_eq!(
l.get("k").as_deref(),
Some(&"theirs".to_string()),
"a strictly newer epoch still wins"
);
}
#[test]
fn get_is_synchronous_and_returns_what_was_put() {
let l = locker();
block_on(l.put("theme", "dark".into())).unwrap();
assert_eq!(l.get("theme").as_deref(), Some(&"dark".to_string()));
}
#[test]
fn a_missing_key_is_none() {
let l = locker();
assert!(l.get("nope").is_none());
}
#[test]
fn overwriting_replaces() {
let l = locker();
block_on(l.put("k", "first".into())).unwrap();
block_on(l.put("k", "second".into())).unwrap();
assert_eq!(l.get("k").as_deref(), Some(&"second".to_string()));
assert_eq!(l.len(), 1);
}
#[test]
fn delete_removes_from_ram_and_storage() {
let l = locker();
block_on(l.put("k", "v".into())).unwrap();
block_on(l.delete("k")).unwrap();
assert!(l.get("k").is_none());
assert_eq!(l.len(), 0);
}
#[test]
fn deleting_an_absent_key_is_silent() {
let l = locker();
block_on(l.put("here", "v".into())).unwrap();
let mut events = l.watch();
block_on(l.delete("gone")).unwrap();
assert_eq!(
events.try_recv(),
None,
"a key that was never there is not news"
);
block_on(l.delete("here")).unwrap();
assert_eq!(
events.try_recv(),
Some(Event::Deleted {
key: b"here".to_vec()
})
);
assert_eq!(events.try_recv(), None, "exactly one event, not two");
block_on(l.delete("here")).unwrap();
assert_eq!(events.try_recv(), None);
}
#[test]
fn delete_all_announces_only_the_keys_it_took_away() {
let l = locker();
block_on(l.put("a", "1".into())).unwrap();
block_on(l.put("c", "3".into())).unwrap();
let mut events = l.watch();
block_on(l.delete_all(["a", "b", "c", "d"])).unwrap();
assert_eq!(
events.try_recv(),
Some(Event::Deleted { key: b"a".to_vec() })
);
assert_eq!(
events.try_recv(),
Some(Event::Deleted { key: b"c".to_vec() })
);
assert_eq!(events.try_recv(), None, "b and d were never there");
assert_eq!(l.len(), 0);
}
#[test]
fn a_deferred_delete_of_an_absent_key_stages_nothing() {
let l =
open_with(LockerConfig::default().with_commit(crate::Commit::Deferred { after: 64 }))
.unwrap();
block_on(l.put("here", "v".into())).unwrap();
let mut events = l.watch();
let staged = l.pending();
block_on(l.delete("gone")).unwrap();
assert_eq!(events.try_recv(), None);
assert_eq!(l.pending(), staged, "nothing was staged for an absent key");
}
#[test]
fn deleting_a_corrupt_skipped_key_still_removes_the_record() {
use crate::backend::api::{Backend, Op, Table};
use crate::locker::OnCorrupt;
let backend: Arc<dyn Backend> = Arc::new(MemoryBackend::new());
let stored = crate::key::encode(1, "bad");
block_on(backend.commit(vec![Op::Put {
table: Table::Records,
key: stored.clone(),
value: b"not a CBNK envelope".to_vec(),
}]))
.unwrap();
let l: Locker<String> = block_on(Locker::open(
backend.clone(),
Arc::new(default_chain()),
1,
"test".into(),
LockerConfig::default().with_on_corrupt(OnCorrupt::Skip),
Default::default(),
))
.unwrap();
assert_eq!(l.corrupt_keys(), vec![b"bad".to_vec()]);
assert!(l.get("bad").is_none(), "skipped, so not resident");
let mut events = l.watch();
block_on(l.delete("bad")).unwrap();
assert!(
block_on(backend.get(Table::Records, &stored))
.unwrap()
.is_none(),
"the corrupt bytes must really go"
);
assert_eq!(
events.try_recv(),
Some(Event::Deleted {
key: b"bad".to_vec()
}),
"a record that was there really did go away"
);
}
#[test]
fn a_transaction_updates_ram_only_after_it_commits() {
let l = locker();
block_on(l.transact(|tx| async move {
tx.put("a", "1".to_string())?;
tx.put("b", "2".to_string())?;
Ok(())
}))
.unwrap();
assert_eq!(l.len(), 2);
assert_eq!(l.get("a").as_deref(), Some(&"1".to_string()));
}
#[test]
fn a_failed_transaction_leaves_the_resident_copy_alone() {
let l = locker();
block_on(l.put("existing", "old".into())).unwrap();
let outcome: Result<()> = block_on(l.transact(|tx| async move {
tx.put("a", "1".to_string())?;
Err(Error::backend("nope"))
}));
assert!(outcome.is_err());
assert!(l.get("a").is_none());
assert_eq!(l.get("existing").as_deref(), Some(&"old".to_string()));
assert_eq!(l.len(), 1);
}
#[test]
fn a_transaction_respects_the_inline_size_limit() {
let l = open_with(LockerConfig::default().with_max_inline(64)).unwrap();
let outcome: Result<()> = block_on(l.transact(|tx| async move {
tx.put("big", "x".repeat(10_000))?;
Ok(())
}));
assert!(matches!(outcome, Err(Error::ValueTooLarge { .. })));
assert!(l.get("big").is_none());
}
#[test]
fn an_eager_locker_announces_its_writes() {
let l = locker();
let mut events = l.watch();
block_on(l.put("theme", "dark".into())).unwrap();
assert_eq!(
block_on(events.next()),
Some(crate::watch::Event::Put {
key: "theme".into()
})
);
}
#[test]
fn keys_are_ordered_and_prefix_filtering_stops_at_the_boundary() {
let l = locker();
for k in ["ui::b", "ui::a", "uj::a"] {
block_on(l.put(k, "v".into())).unwrap();
}
assert_eq!(l.keys(), vec!["ui::a", "ui::b", "uj::a"]);
assert_eq!(l.keys_with_prefix("ui::"), vec!["ui::a", "ui::b"]);
}
#[test]
fn an_oversized_value_is_refused_and_names_the_alternative() {
let l = open_with(LockerConfig::default().with_max_inline(64)).unwrap();
let big = "x".repeat(10_000);
match block_on(l.put("big", big)) {
Err(Error::ValueTooLarge { max_inline, .. }) => {
assert_eq!(max_inline, 64);
}
other => panic!("expected ValueTooLarge, got {other:?}"),
}
assert!(l.get("big").is_none());
}
#[test]
fn an_evictable_policy_is_refused_at_open() {
let config = LockerConfig::default().with_policy(Policy::Evictable { max_bytes: 1024 });
match open_with(config) {
Err(Error::InvalidConfig(msg)) => {
assert!(msg.contains("lazy locker"), "should name the fix: {msg}")
}
other => panic!("expected InvalidConfig, got {other:?}"),
}
}
#[test]
fn reopening_restores_every_value() {
let backend: Arc<dyn Backend> = Arc::new(MemoryBackend::new());
let chain = Arc::new(default_chain());
let first: Locker<String> = block_on(Locker::open(
backend.clone(),
chain.clone(),
1,
"l".into(),
LockerConfig::default(),
Default::default(),
))
.unwrap();
block_on(first.put("a", "alpha".into())).unwrap();
block_on(first.put("b", "beta".into())).unwrap();
drop(first);
let second: Locker<String> = block_on(Locker::open(
backend,
chain,
1,
"l".into(),
LockerConfig::default(),
Default::default(),
))
.unwrap();
assert_eq!(second.len(), 2);
assert_eq!(second.get("a").as_deref(), Some(&"alpha".to_string()));
}
#[test]
fn opening_over_too_much_data_fails_loudly() {
let backend: Arc<dyn Backend> = Arc::new(MemoryBackend::new());
let chain = Arc::new(default_chain());
let seed: Locker<String> = block_on(Locker::open(
backend.clone(),
chain.clone(),
1,
"l".into(),
LockerConfig::default(),
Default::default(),
))
.unwrap();
for i in 0..50 {
block_on(seed.put(&format!("k{i:03}"), "x".repeat(200))).unwrap();
}
drop(seed);
let reopened: Result<Locker<String>> = block_on(Locker::open(
backend,
chain,
1,
"l".into(),
LockerConfig::default().with_eager_budget(1024),
Default::default(),
));
match reopened {
Err(Error::LockerTooLarge { budget, .. }) => assert_eq!(budget, 1024),
other => panic!("expected LockerTooLarge, got {:?}", other.map(|_| "ok")),
}
}
#[test]
fn clear_empties_ram_and_storage() {
let l = locker();
block_on(l.put("a", "1".into())).unwrap();
block_on(l.clear()).unwrap();
assert_eq!(l.len(), 0);
assert!(l.get("a").is_none());
}
#[test]
fn binary_keys_live_alongside_text_ones() {
let l = locker();
block_on(l.put_by(&[0xFF], "high".into())).unwrap();
block_on(l.put_by(&[0x00], "low".into())).unwrap();
block_on(l.put("a", "text".into())).unwrap();
assert_eq!(l.get_by(&[0xFF]).as_deref(), Some(&"high".to_string()));
assert!(l.contains_key_by(&[0x00]));
assert_eq!(
l.keys_bytes(),
vec![vec![0x00], b"a".to_vec(), vec![0xFF]],
"keys must be ordered bytewise"
);
assert_eq!(l.keys(), vec!["\u{0}".to_string(), "a".to_string()]);
assert!(l.has_non_utf8_keys());
block_on(l.delete_by(&[0xFF])).unwrap();
assert!(l.get_by(&[0xFF]).is_none());
assert_eq!(l.len(), 2);
}
#[test]
fn a_locker_of_text_keys_reports_no_binary_ones() {
let l = locker();
block_on(l.put("a", "1".into())).unwrap();
assert!(!l.has_non_utf8_keys());
assert_eq!(l.keys_bytes(), vec![b"a".to_vec()]);
}
#[test]
fn get_ergonomics_cover_clone_default_and_borrow() {
let l = locker();
block_on(l.put("theme", "dark".into())).unwrap();
assert_eq!(l.get_cloned("theme"), Some("dark".to_string()));
assert_eq!(l.get_cloned("absent"), None);
assert_eq!(*l.get_or("theme", "light".into()), "dark".to_string());
assert_eq!(*l.get_or("absent", "light".into()), "light".to_string());
assert!(!l.contains_key("absent"));
assert_eq!(l.with("theme", |v| v.len()), Some(4));
assert_eq!(l.with("absent", |v| v.len()), None);
}
#[test]
fn put_all_lands_as_one_commit() {
let l = locker();
let entries: Vec<(String, String)> = (0..50)
.map(|i| (format!("k{i:03}"), format!("v{i}")))
.collect();
block_on(l.put_all(entries)).unwrap();
assert_eq!(l.len(), 50);
assert_eq!(l.get("k049").as_deref(), Some(&"v49".to_string()));
block_on(l.delete_all(["k000", "k001"])).unwrap();
assert_eq!(l.len(), 48);
assert!(l.get("k000").is_none());
}
#[test]
fn a_put_all_carrying_an_oversized_value_writes_nothing() {
let l = open_with(LockerConfig::default().with_max_inline(64)).unwrap();
let entries = vec![
("ok".to_string(), "small".to_string()),
("bad".to_string(), "x".repeat(10_000)),
];
assert!(matches!(
block_on(l.put_all(entries)),
Err(Error::ValueTooLarge { .. })
));
assert_eq!(l.len(), 0, "a refused put_all must write nothing at all");
}
#[test]
fn an_empty_bulk_operation_is_a_no_op() {
let l = locker();
block_on(l.put("k", "v".into())).unwrap();
block_on(l.put_all(Vec::<(String, String)>::new())).unwrap();
block_on(l.delete_all(Vec::<String>::new())).unwrap();
assert_eq!(l.len(), 1);
}
#[test]
fn range_and_to_map_read_straight_from_ram() {
let l = locker();
for k in ["a", "b", "c", "d"] {
block_on(l.put(k, k.to_uppercase())).unwrap();
}
let keys: Vec<String> = l.range("b".."d").into_iter().map(|(k, _)| k).collect();
assert_eq!(keys, vec!["b", "c"]);
assert_eq!(l.range(..).len(), 4);
let map = l.to_map();
assert_eq!(map.len(), 4);
assert_eq!(map.get("c").map(|v| v.as_str()), Some("C"));
}
#[test]
fn watch_keys_passes_any_named_key_and_every_clear() {
let l = locker();
let mut events = l.watch_keys(&["a", "b"]);
block_on(l.put("ignored", "x".into())).unwrap();
block_on(l.put("b", "y".into())).unwrap();
block_on(l.clear()).unwrap();
assert_eq!(
block_on(events.next()),
Some(crate::watch::Event::Put { key: b"b".to_vec() })
);
assert_eq!(block_on(events.next()), Some(crate::watch::Event::Cleared));
}
#[test]
fn values_are_shared_not_cloned_per_read() {
let l = locker();
let stored = block_on(l.put("k", "v".into())).unwrap();
let read = l.get("k").unwrap();
assert!(
Arc::ptr_eq(&stored, &read),
"reads should hand back the same Arc, not a fresh clone"
);
}
}