use std::collections::BTreeMap;
use std::ops::Bound;
use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
use std::sync::{Arc, Mutex};
use serde::{de::DeserializeOwned, Serialize};
use crate::backend::api::{Backend, CommitOptions, Op, ScanRequest, Table};
use crate::codec::{self, FilterChain};
use crate::error::{Error, Result};
use crate::key::{self, LockerId};
use super::chunk::{
chunk_key, gc_ops, is_pointer, ChunkPointer, ValueIds, FLAG_POSTCARD, FLAG_RAW,
};
use super::lru::Ticks;
use super::policy::LockerConfig;
use crate::coherence::Coherence;
use crate::watch::{Event, Watchers};
pub(crate) use crate::backend::api::DEFAULT_SCAN_PAGE as SCAN_PAGE;
const CHUNK_FETCH_GROUP: u32 = 64;
#[derive(Debug, Default)]
pub(crate) struct Shared {
pub(crate) values: ValueIds,
pub(crate) ticks: Ticks,
pub(crate) coherence: Coherence,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub(crate) enum Prior {
#[default]
Unknown,
Absent,
Inline,
}
impl Prior {
fn needs_read(self) -> bool {
matches!(self, Prior::Unknown)
}
}
pub(crate) struct Inner {
pub(crate) write_lock: futures::lock::Mutex<()>,
pub(crate) backend: Arc<dyn Backend>,
pub(crate) chain: Arc<FilterChain>,
pub(crate) id: LockerId,
pub(crate) name: String,
pub(crate) config: LockerConfig,
pub(crate) shared: Arc<Shared>,
pub(crate) watchers: Watchers,
pub(crate) closed: AtomicBool,
pub(crate) epochs: Epochs,
pub(crate) name_shared: AtomicBool,
}
#[derive(Debug, Default)]
pub(crate) struct Epochs {
local: Mutex<BTreeMap<Vec<u8>, u64>>,
applied: AtomicU64,
}
pub(crate) const EPOCH_MEMORY: usize = 4096;
impl Epochs {
pub(crate) fn note_local(&self, keys: impl Iterator<Item = Vec<u8>>, epoch: u64) {
let Ok(mut guard) = self.local.lock() else {
return;
};
for key in keys {
guard.insert(key, epoch);
}
if guard.len() > EPOCH_MEMORY {
guard.clear();
}
}
pub(crate) fn local(&self, key: &[u8]) -> Option<u64> {
self.local.lock().ok()?.get(key).copied()
}
pub(crate) fn applied(&self) -> u64 {
self.applied.load(Ordering::Acquire)
}
pub(crate) fn note_applied(&self, epoch: u64) {
self.applied.fetch_max(epoch, Ordering::AcqRel);
}
pub(crate) fn forget_local(&self) {
if let Ok(mut guard) = self.local.lock() {
guard.clear();
}
}
}
impl std::fmt::Debug for Inner {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("Locker")
.field("name", &self.name)
.field("id", &self.id)
.finish()
}
}
impl Inner {
pub(crate) fn is_closed(&self) -> bool {
self.closed.load(Ordering::Acquire)
}
pub(crate) fn mark_closed(&self) -> bool {
!self.closed.swap(true, Ordering::AcqRel)
}
pub(crate) fn ensure_open(&self) -> Result<()> {
if self.is_closed() {
return Err(Error::Closed);
}
Ok(())
}
pub(crate) fn mark_name_shared(&self) {
self.name_shared.store(true, Ordering::Release);
}
pub(crate) fn index_is_authoritative(&self) -> bool {
if self.name_shared.load(Ordering::Acquire) {
return false;
}
if cfg!(target_arch = "wasm32") && !self.shared.coherence.is_enabled() {
return false;
}
true
}
pub(crate) fn encode_key(&self, key: &[u8]) -> Vec<u8> {
key::encode_bytes(self.id, key)
}
pub(crate) fn seal<T: Serialize>(&self, value: &T) -> Result<Vec<u8>> {
codec::encode(value, &self.chain)
}
pub(crate) fn open<T: DeserializeOwned>(&self, stored: &[u8]) -> Result<T> {
codec::decode(stored, &self.chain)
}
pub(crate) fn delete_op(&self, key: &[u8]) -> Op {
Op::Delete {
table: Table::Records,
key: self.encode_key(key),
}
}
pub(crate) fn clear_op(&self) -> Op {
Op::DeleteRange {
table: Table::Records,
range: key::locker_range(self.id),
}
}
pub(crate) async fn fetch(&self, key: &[u8]) -> Result<Option<Vec<u8>>> {
let encoded = self.encode_key(key);
self.backend.get(Table::Records, &encoded).await
}
pub(crate) async fn flush_backend(&self) -> Result<()> {
if !self.config.is_eventual() {
return Ok(());
}
self.backend.flush().await
}
pub(crate) async fn commit(&self, ops: Vec<Op>) -> Result<()> {
let news = self.shared.coherence.prepare(self.id, &ops);
self.backend
.commit_with(
ops,
CommitOptions {
durability: self.config.durability,
},
)
.await?;
if let Some(news) = news {
self.epochs
.note_local(news.changes.iter().map(|c| c.key.clone()), news.epoch);
if news.cleared {
self.epochs.forget_local();
}
self.shared.coherence.post(news);
}
Ok(())
}
pub(crate) async fn load_payload(&self, stored: &[u8]) -> Result<Vec<u8>> {
if is_pointer(stored) {
let pointer = ChunkPointer::parse(stored)?;
self.read_chunks(&pointer).await
} else {
self.chain.open(stored)
}
}
pub(crate) async fn decode_record<T: serde::de::DeserializeOwned>(
&self,
stored: &[u8],
) -> Result<T> {
let payload = self.load_payload(stored).await?;
if is_pointer(stored) && ChunkPointer::parse(stored)?.flags == FLAG_RAW {
let wrapped = postcard::to_allocvec(&payload)
.map_err(|e| Error::Filter(format!("postcard wrap of raw chunks failed: {e}")))?;
postcard::from_bytes(&wrapped)
.map_err(|e| Error::Corrupt(format!("raw chunk reconstruct failed: {e}")))
} else {
postcard::from_bytes(&payload)
.map_err(|e| Error::Corrupt(format!("postcard deserialisation failed: {e}")))
}
}
pub(crate) async fn load_value<T: serde::de::DeserializeOwned>(
&self,
key: &[u8],
) -> Result<Option<T>> {
match self.fetch(key).await? {
None => Ok(None),
Some(raw) => Ok(Some(self.decode_record(&raw).await?)),
}
}
pub(crate) async fn read_chunks(&self, pointer: &ChunkPointer) -> Result<Vec<u8>> {
let mut out: Vec<u8> = Vec::new();
let mut seq = 0u32;
while seq < pointer.n_chunks {
let upto = seq.saturating_add(CHUNK_FETCH_GROUP).min(pointer.n_chunks);
let keys: Vec<Vec<u8>> = (seq..upto)
.map(|s| chunk_key(pointer.value_id, s))
.collect();
let sealed_pieces = self.backend.get_many(Table::Chunks, keys).await?;
for (offset, sealed) in sealed_pieces.into_iter().enumerate() {
let sealed = sealed.ok_or_else(|| {
Error::Corrupt(format!(
"missing chunk {} of {}",
seq as usize + offset,
pointer.value_id
))
})?;
let piece = self.chain.open(&sealed)?;
let room = pointer.total_len.saturating_sub(out.len() as u64);
out.reserve(piece.len().min(room as usize));
out.extend_from_slice(&piece);
if out.len() as u64 > pointer.total_len {
return Err(Error::Corrupt(format!(
"chunked value declared {} bytes and has already reassembled {}",
pointer.total_len,
out.len()
)));
}
}
seq = upto;
}
if out.len() as u64 != pointer.total_len {
return Err(Error::Corrupt(format!(
"chunked value declared {} bytes, reassembled {}",
pointer.total_len,
out.len()
)));
}
Ok(out)
}
pub(crate) async fn next_value_id(&self) -> Result<u64> {
self.shared.values.allocate(self.backend.as_ref()).await
}
pub(crate) fn value_counter_op(&self) -> Result<Option<Op>> {
self.shared.values.counter_op()
}
pub(crate) async fn put_payload_ops(
&self,
key: &[u8],
payload: Vec<u8>,
flags: u8,
prior: Prior,
) -> Result<Vec<Op>> {
let mut ops = Vec::new();
if prior.needs_read() {
if let Some(existing) = self.fetch(key).await? {
if is_pointer(&existing) {
ops.push(gc_ops(&ChunkPointer::parse(&existing)?));
}
}
}
if self.stores_inline(payload.len(), flags) {
let encoded = self.encode_key(key);
ops.push(Op::Put {
table: Table::Records,
key: encoded,
value: self.chain.seal(payload)?,
});
return Ok(ops);
}
let value_id = self.next_value_id().await?;
let chunk_size = self.config.chunk_size;
let mut seq = 0u32;
for piece in payload.chunks(chunk_size) {
ops.push(Op::Put {
table: Table::Chunks,
key: chunk_key(value_id, seq),
value: self.chain.seal_slice(piece)?,
});
seq = seq
.checked_add(1)
.ok_or_else(|| Error::backend("chunk sequence space is exhausted"))?;
}
let pointer = ChunkPointer {
value_id,
n_chunks: seq,
total_len: payload.len() as u64,
flags,
};
ops.push(Op::Put {
table: Table::Records,
key: self.encode_key(key),
value: pointer.encode(),
});
if let Some(op) = self.value_counter_op()? {
ops.push(op);
}
Ok(ops)
}
pub(crate) async fn delete_value_ops(&self, key: &[u8], prior: Prior) -> Result<Vec<Op>> {
let mut ops = Vec::new();
if prior.needs_read() {
if let Some(existing) = self.fetch(key).await? {
if is_pointer(&existing) {
ops.push(gc_ops(&ChunkPointer::parse(&existing)?));
}
}
}
ops.push(self.delete_op(key));
Ok(ops)
}
pub(crate) fn stores_inline(&self, payload_len: usize, flags: u8) -> bool {
payload_len <= self.config.chunk_size && flags == FLAG_POSTCARD
}
pub(crate) async fn clear_value_ops(&self) -> Result<Vec<Op>> {
let mut ops = Vec::new();
self.walk(
Bound::Unbounded,
Bound::Unbounded,
false,
true,
|_, value| {
if let Some(raw) = value {
if is_pointer(&raw) {
if let Ok(pointer) = ChunkPointer::parse(&raw) {
ops.push(gc_ops(&pointer));
}
}
}
Ok(())
},
)
.await?;
ops.push(self.clear_op());
Ok(ops)
}
pub(crate) fn announce(&self, event: Event) {
self.watchers.broadcast(&event);
}
pub(crate) async fn walk(
&self,
start: Bound<&[u8]>,
end: Bound<&[u8]>,
reverse: bool,
want_values: bool,
mut visit: impl FnMut(Vec<u8>, Option<Vec<u8>>) -> Result<()>,
) -> Result<()> {
if key::is_degenerate(start, end) {
return Ok(());
}
let mut range = key::encode_range_bytes(self.id, start, end);
loop {
let page = self
.backend
.scan(ScanRequest {
table: Table::Records,
range: range.clone(),
reverse,
limit: self.backend.scan_page_size(),
want_values,
})
.await?;
let resume = page.resume;
for (encoded, value) in page.items {
let user_key = key::decode_bytes(self.id, &encoded)?;
visit(user_key.to_vec(), value)?;
}
match resume {
Some(last) => {
if reverse {
range.end = Bound::Excluded(last);
} else {
range.start = Bound::Excluded(last);
}
}
None => break,
}
}
Ok(())
}
}