use std::collections::HashMap;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{Arc, Mutex, Weak};
use futures::channel::mpsc;
use crate::backend::api::{Backend, Op, ScanRequest, Table};
use crate::backend::KeyRange;
use crate::codec::{default_chain, type_tag, FilterChain};
use crate::error::{Error, Result};
use crate::handle::{Job, JOB_QUEUE};
use crate::key::LockerId;
use crate::locker::eager::EagerValues;
use crate::locker::inner::Inner;
use crate::locker::transaction::TxMode;
use crate::locker::{LazyLocker, Locker, LockerConfig};
use serde::{de::DeserializeOwned, Serialize};
pub const FORMAT_VERSION: u32 = 1;
const META_FORMAT_VERSION: &[u8] = b"format_version";
const META_NEXT_LOCKER_ID: &[u8] = b"next_locker_id";
const META_LOCKER_PREFIX: &[u8] = b"locker::";
const META_SCHEMA_PREFIX: &[u8] = b"schema::";
const META_CHAIN_PREFIX: &[u8] = b"chain::";
fn locker_key(name: &str) -> Vec<u8> {
let mut k = META_LOCKER_PREFIX.to_vec();
k.extend_from_slice(name.as_bytes());
k
}
fn schema_key(id: LockerId) -> Vec<u8> {
let mut k = META_SCHEMA_PREFIX.to_vec();
k.extend_from_slice(&id.to_be_bytes());
k
}
fn chain_key(id: LockerId) -> Vec<u8> {
let mut k = META_CHAIN_PREFIX.to_vec();
k.extend_from_slice(&id.to_be_bytes());
k
}
fn u32_from(bytes: &[u8], what: &str) -> Result<u32> {
<[u8; 4]>::try_from(bytes)
.map(u32::from_be_bytes)
.map_err(|_| Error::Corrupt(format!("{what} is not a 4-byte integer")))
}
struct OpenLocker {
inner: Weak<Inner>,
resident: Weak<crate::locker::resident::Resident>,
values: Option<Weak<dyn std::any::Any + Send + Sync>>,
kind: TxMode,
type_tag: String,
config: LockerConfig,
}
struct Shared {
inner: Arc<Inner>,
resident: Arc<crate::locker::resident::Resident>,
values: Option<Arc<dyn std::any::Any + Send + Sync>>,
kind: TxMode,
type_tag: String,
config: LockerConfig,
}
impl OpenLocker {
fn upgrade(&self) -> Option<Shared> {
let inner = self.inner.upgrade()?;
if inner.is_closed() {
return None;
}
let resident = self.resident.upgrade()?;
let values = match self.values.as_ref() {
Some(weak) => Some(weak.upgrade()?),
None => None,
};
Some(Shared {
inner,
resident,
values,
kind: self.kind,
type_tag: self.type_tag.clone(),
config: self.config.clone(),
})
}
}
fn kind_word(kind: TxMode) -> &'static str {
match kind {
TxMode::Eager => "eager",
TxMode::Lazy => "lazy",
}
}
fn config_conflict(open: &LockerConfig, requested: &LockerConfig) -> Option<&'static str> {
if open.max_inline != requested.max_inline {
return Some("max_inline");
}
if open.eager_budget != requested.eager_budget {
return Some("eager_budget");
}
if open.policy != requested.policy {
return Some("policy");
}
if open.commit != requested.commit {
return Some("commit");
}
if open.durability != requested.durability {
return Some("durability");
}
if open.on_corrupt != requested.on_corrupt {
return Some("on_corrupt");
}
if open.chunk_size != requested.chunk_size {
return Some("chunk_size");
}
if open.chain_id() != requested.chain_id() {
return Some("filter chain");
}
None
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub enum Location {
Memory,
Path(std::path::PathBuf),
Web(String),
}
#[derive(Debug, Clone)]
pub struct BankConfig {
pub location: Location,
pub coherence: bool,
pub chain: Option<Arc<FilterChain>>,
}
impl BankConfig {
pub fn memory() -> Self {
Self {
location: Location::Memory,
coherence: false,
chain: None,
}
}
pub fn at(path: impl Into<std::path::PathBuf>) -> Self {
Self {
location: Location::Path(path.into()),
coherence: false,
chain: None,
}
}
pub fn web(name: impl Into<String>) -> Self {
Self {
location: Location::Web(name.into()),
coherence: false,
chain: None,
}
}
pub fn with_coherence(mut self, on: bool) -> Self {
self.coherence = on;
self
}
pub fn with_chain(mut self, chain: Arc<FilterChain>) -> Self {
self.chain = Some(chain);
self
}
}
pub struct Bank {
backend: Arc<dyn Backend>,
chain: Arc<FilterChain>,
registry: Mutex<HashMap<String, LockerId>>,
chains: Mutex<HashMap<u8, Arc<FilterChain>>>,
job_sender: mpsc::Sender<Job>,
job_receiver: Mutex<Option<mpsc::Receiver<Job>>>,
open_lockers: Mutex<HashMap<String, OpenLocker>>,
residents: Mutex<Vec<Weak<crate::locker::resident::Resident>>>,
shared: Arc<crate::locker::inner::Shared>,
closed: AtomicBool,
#[cfg(not(target_arch = "wasm32"))]
tracked_path: Mutex<Option<std::path::PathBuf>>,
}
#[cfg(not(target_arch = "wasm32"))]
impl Drop for Bank {
fn drop(&mut self) {
self.release_tracked_path();
}
}
impl std::fmt::Debug for Bank {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("Bank").field("chain", &self.chain).finish()
}
}
impl Bank {
pub async fn persist(&self) -> Result<bool> {
#[cfg(not(target_arch = "wasm32"))]
{
let _ = self;
Ok(true)
}
#[cfg(target_arch = "wasm32")]
{
let _ = self;
let Some(window) = web_sys::window() else {
return Ok(false);
};
match window.navigator().storage().persist() {
Ok(promise) => {
let value = wasm_bindgen_futures::JsFuture::from(promise)
.await
.map_err(|e| Error::backend(format!("{e:?}")))?;
Ok(value.as_bool().unwrap_or(false))
}
Err(_) => Ok(false),
}
}
}
pub async fn usage(&self) -> Result<Option<crate::backend::Usage>> {
self.ensure_open()?;
self.backend.usage().await
}
pub async fn is_persisted(&self) -> Result<bool> {
#[cfg(not(target_arch = "wasm32"))]
{
self.ensure_open()?;
Ok(true)
}
#[cfg(target_arch = "wasm32")]
{
self.ensure_open()?;
let Some(window) = web_sys::window() else {
return Ok(false);
};
match window.navigator().storage().persisted() {
Ok(promise) => {
let value = wasm_bindgen_futures::JsFuture::from(promise)
.await
.map_err(|e| Error::backend(format!("{e:?}")))?;
Ok(value.as_bool().unwrap_or(false))
}
Err(_) => Ok(false),
}
}
}
fn ensure_open(&self) -> Result<()> {
if self.is_closed() {
return Err(Error::Closed);
}
Ok(())
}
pub async fn open(config: BankConfig) -> Result<Self> {
let coherence = match (&config.location, config.coherence) {
(Location::Web(name), true) => crate::coherence::Coherence::open(name),
_ => crate::coherence::Coherence::disabled(),
};
let chain = config
.chain
.clone()
.unwrap_or_else(|| Arc::new(default_chain()));
match config.location {
Location::Memory => {
Self::assembled(
Arc::new(crate::backend::MemoryBackend::new()),
chain,
coherence,
)
.await
}
Location::Path(path) => {
#[cfg(not(target_arch = "wasm32"))]
{
let located = path.clone();
let bank = Self::assembled(
Arc::new(crate::backend::RedbBackend::open(path)?),
chain,
coherence,
)
.await?;
let key = bank_key(&located);
register_open_bank(key.clone());
if let Ok(mut guard) = bank.tracked_path.lock() {
*guard = Some(key);
}
Ok(bank)
}
#[cfg(target_arch = "wasm32")]
{
let _ = path;
Err(Error::InvalidConfig(
"Location::Path is native-only; use Location::Web on wasm".into(),
))
}
}
Location::Web(name) => {
#[cfg(target_arch = "wasm32")]
{
let backend = crate::backend::IndexedDbBackend::open(&name).await?;
Self::assembled(Arc::new(backend), chain, coherence).await
}
#[cfg(not(target_arch = "wasm32"))]
{
let _ = name;
Err(Error::InvalidConfig(
"Location::Web is wasm-only; use Location::Path on native".into(),
))
}
}
}
}
pub async fn with_backend(backend: Arc<dyn Backend>) -> Result<Self> {
Self::with_backend_and_chain(backend, default_chain()).await
}
pub async fn with_backend_and_chain(
backend: Arc<dyn Backend>,
chain: FilterChain,
) -> Result<Self> {
Self::assembled(
backend,
Arc::new(chain),
crate::coherence::Coherence::disabled(),
)
.await
}
async fn assembled(
backend: Arc<dyn Backend>,
chain: Arc<FilterChain>,
coherence: crate::coherence::Coherence,
) -> Result<Self> {
let shared = Arc::new(crate::locker::inner::Shared {
coherence,
..Default::default()
});
let (job_sender, job_receiver) = mpsc::channel(JOB_QUEUE);
let bank = Self {
backend,
chain,
registry: Mutex::new(HashMap::new()),
chains: Mutex::new(HashMap::new()),
job_sender,
job_receiver: Mutex::new(Some(job_receiver)),
open_lockers: Mutex::new(HashMap::new()),
residents: Mutex::new(Vec::new()),
shared: shared.clone(),
closed: AtomicBool::new(false),
#[cfg(not(target_arch = "wasm32"))]
tracked_path: Mutex::new(None),
};
bank.check_or_write_format_version().await?;
Ok(bank)
}
pub fn backend(&self) -> &Arc<dyn Backend> {
&self.backend
}
pub fn chain(&self) -> &Arc<FilterChain> {
&self.chain
}
async fn check_or_write_format_version(&self) -> Result<()> {
match self.backend.get(Table::Meta, META_FORMAT_VERSION).await? {
Some(raw) => {
let found = u32_from(&raw, "format version")?;
if found != FORMAT_VERSION {
return Err(Error::UnsupportedVersion {
found: found.min(u8::MAX as u32) as u8,
supported: FORMAT_VERSION as u8,
});
}
Ok(())
}
None => {
self.backend
.commit(vec![Op::Put {
table: Table::Meta,
key: META_FORMAT_VERSION.to_vec(),
value: FORMAT_VERSION.to_be_bytes().to_vec(),
}])
.await
}
}
}
pub async fn locker_id(&self, name: &str) -> Result<LockerId> {
if let Some(id) = self.cached(name) {
return Ok(id);
}
let mut found = self
.backend
.get_many(
Table::Meta,
vec![locker_key(name), META_NEXT_LOCKER_ID.to_vec()],
)
.await?;
let next_raw = found.pop().flatten();
let registered = found.pop().flatten();
if let Some(raw) = registered {
let id = u32_from(&raw, "locker id")?;
self.cache(name, id);
return Ok(id);
}
let next = match next_raw {
Some(raw) => u32_from(&raw, "next locker id")?,
None => 0,
};
let id = next;
let bumped = next
.checked_add(1)
.ok_or_else(|| Error::backend("locker id space is exhausted"))?;
self.backend
.commit(vec![
Op::Put {
table: Table::Meta,
key: locker_key(name),
value: id.to_be_bytes().to_vec(),
},
Op::Put {
table: Table::Meta,
key: META_NEXT_LOCKER_ID.to_vec(),
value: bumped.to_be_bytes().to_vec(),
},
])
.await?;
self.cache(name, id);
Ok(id)
}
pub async fn locker<T>(&self, name: &str) -> Result<Locker<T>>
where
T: Serialize + DeserializeOwned + Send + Sync + 'static,
{
self.locker_with(name, LockerConfig::default()).await
}
pub async fn locker_with<T>(&self, name: &str, config: LockerConfig) -> Result<Locker<T>>
where
T: Serialize + DeserializeOwned + Send + Sync + 'static,
{
self.ensure_open()?;
let chain = self.chain_for(&config);
if let Some(open) = self.open_locker(name) {
return Self::share_eager(name, open, &config);
}
let id = self.prepare::<T>(name, &chain).await?;
let locker = Locker::open(
self.backend.clone(),
chain,
id,
name.to_string(),
config.clone(),
self.shared.clone(),
)
.await?;
let claim = OpenLocker {
inner: Arc::downgrade(locker.inner()),
resident: Arc::downgrade(locker.resident()),
values: Some(
Arc::downgrade(locker.shared_values()) as Weak<dyn std::any::Any + Send + Sync>
),
kind: TxMode::Eager,
type_tag: type_tag::<T>(),
config: config.clone(),
};
if let Some(open) = self.claim_open(name, claim) {
return Self::share_eager(name, open, &config);
}
self.register_resident(locker.resident());
locker.join_coherence();
Ok(locker)
}
fn share_eager<T>(name: &str, open: Shared, config: &LockerConfig) -> Result<Locker<T>>
where
T: Serialize + DeserializeOwned + Send + Sync + 'static,
{
Self::check_shared::<T>(name, &open, TxMode::Eager, config)?;
let values = open
.values
.clone()
.and_then(|erased| erased.downcast::<EagerValues<T>>().ok())
.ok_or_else(|| Error::SchemaMismatch {
stored: open.type_tag.clone(),
requested: type_tag::<T>(),
})?;
Ok(Locker::from_shared(open.inner, values, open.resident))
}
pub async fn lazy_locker<T>(&self, name: &str) -> Result<LazyLocker<T>>
where
T: Serialize + DeserializeOwned,
{
self.lazy_locker_with(name, LockerConfig::default()).await
}
pub async fn lazy_locker_with<T>(
&self,
name: &str,
config: LockerConfig,
) -> Result<LazyLocker<T>>
where
T: Serialize + DeserializeOwned,
{
self.ensure_open()?;
let chain = self.chain_for(&config);
if let Some(open) = self.open_locker(name) {
return Self::share_lazy(name, open, &config);
}
let id = self.prepare::<T>(name, &chain).await?;
let locker = LazyLocker::open(
self.backend.clone(),
chain,
id,
name.to_string(),
config.clone(),
self.shared.clone(),
)
.await?;
let claim = OpenLocker {
inner: Arc::downgrade(locker.inner()),
resident: Arc::downgrade(locker.resident()),
values: None,
kind: TxMode::Lazy,
type_tag: type_tag::<T>(),
config: config.clone(),
};
if let Some(open) = self.claim_open(name, claim) {
return Self::share_lazy(name, open, &config);
}
self.register_resident(locker.resident());
locker.join_coherence();
Ok(locker)
}
fn share_lazy<T>(name: &str, open: Shared, config: &LockerConfig) -> Result<LazyLocker<T>>
where
T: Serialize + DeserializeOwned,
{
Self::check_shared::<T>(name, &open, TxMode::Lazy, config)?;
Ok(LazyLocker::from_shared(open.inner, open.resident))
}
fn chain_for(&self, config: &LockerConfig) -> Arc<FilterChain> {
match config.chain.clone() {
Some(chain) => {
self.register_chain(chain.clone());
chain
}
None => self.chain.clone(),
}
}
pub fn register_chain(&self, chain: Arc<FilterChain>) {
if let Ok(mut guard) = self.chains.lock() {
guard.insert(chain.id(), chain);
}
}
async fn stored_chain_id(&self, id: LockerId) -> Result<Option<u8>> {
match self.backend.get(Table::Meta, &chain_key(id)).await? {
Some(raw) => {
let [stored] = raw[..] else {
return Err(Error::Corrupt(
"a locker's filter chain id is not a single byte".into(),
));
};
Ok(Some(stored))
}
None => Ok(None),
}
}
async fn locker_chain(&self, id: LockerId) -> Result<Option<Arc<FilterChain>>> {
let Some(stored) = self.stored_chain_id(id).await? else {
return Ok(Some(self.chain.clone()));
};
if stored == self.chain.id() {
return Ok(Some(self.chain.clone()));
}
Ok(self
.chains
.lock()
.ok()
.and_then(|guard| guard.get(&stored).cloned()))
}
async fn locker_chain_or_bank(&self, id: LockerId) -> Result<Arc<FilterChain>> {
Ok(self
.locker_chain(id)
.await?
.unwrap_or_else(|| self.chain.clone()))
}
async fn prepare<T>(&self, name: &str, chain: &FilterChain) -> Result<LockerId> {
let pre_existing = self.locker_exists(name).await?;
let id = self.locker_id(name).await?;
self.bind_schema(id, &type_tag::<T>()).await?;
self.bind_chain(id, chain, pre_existing).await?;
Ok(id)
}
async fn bind_chain(
&self,
id: LockerId,
chain: &FilterChain,
pre_existing: bool,
) -> Result<()> {
let key = chain_key(id);
match self.backend.get(Table::Meta, &key).await? {
Some(raw) => {
let [stored] = raw[..] else {
return Err(Error::Corrupt(
"a locker's filter chain id is not a single byte".into(),
));
};
if stored != chain.id() {
return Err(Error::SchemaMismatch {
stored: format!(
"filter chain {stored}; this locker's values were sealed with it"
),
requested: format!(
"{} — reopen the locker with the chain it was written under, \
or use a new locker name",
chain.describe()
),
});
}
Ok(())
}
None => {
let adopted = if pre_existing {
if chain.id() != self.chain.id() {
return Err(Error::SchemaMismatch {
stored: format!(
"no filter chain record; this locker predates per-locker \
chains, so its values were sealed with the bank chain \
({})",
self.chain.describe()
),
requested: format!(
"{} — reopen it under the bank chain, which records the \
chain id from then on, or copy its values into a new \
locker name",
chain.describe()
),
});
}
self.chain.id()
} else {
chain.id()
};
self.backend
.commit(vec![Op::Put {
table: Table::Meta,
key,
value: vec![adopted],
}])
.await
}
}
}
pub(crate) fn job_sender(&self) -> mpsc::Sender<Job> {
self.job_sender.clone()
}
pub(crate) fn take_job_receiver(&self) -> Option<mpsc::Receiver<Job>> {
self.job_receiver.lock().ok()?.take()
}
async fn raw_locker(&self, name: &str) -> Result<LockerId> {
let chain = self.chain.clone();
self.prepare::<Vec<u8>>(name, &chain).await
}
pub(crate) async fn raw_get(&self, locker: &str, key: &str) -> Result<Option<Vec<u8>>> {
let id = self.raw_locker(locker).await?;
let encoded = crate::key::encode(id, key);
match self.backend.get(Table::Records, &encoded).await? {
Some(stored) => Ok(Some(crate::codec::decode(&stored, &self.chain)?)),
None => Ok(None),
}
}
pub(crate) async fn raw_put(&self, locker: &str, key: &str, value: Vec<u8>) -> Result<()> {
let id = self.raw_locker(locker).await?;
let sealed = crate::codec::encode(&value, &self.chain)?;
self.backend
.commit(vec![Op::Put {
table: Table::Records,
key: crate::key::encode(id, key),
value: sealed,
}])
.await
}
pub(crate) async fn raw_delete(&self, locker: &str, key: &str) -> Result<()> {
let id = self.raw_locker(locker).await?;
self.backend
.commit(vec![Op::Delete {
table: Table::Records,
key: crate::key::encode(id, key),
}])
.await
}
pub(crate) async fn raw_clear(&self, locker: &str) -> Result<()> {
let id = self.raw_locker(locker).await?;
self.backend
.commit(vec![Op::DeleteRange {
table: Table::Records,
range: crate::key::locker_range(id),
}])
.await
}
pub(crate) async fn raw_keys(&self, locker: &str, prefix: &str) -> Result<Vec<String>> {
let id = self.raw_locker(locker).await?;
let mut range = crate::key::prefix_range(id, prefix);
let mut keys = Vec::new();
loop {
let page = self
.backend
.scan(ScanRequest {
table: Table::Records,
range: range.clone(),
reverse: false,
limit: 256,
want_values: false,
})
.await?;
for (encoded, _) in &page.items {
keys.push(crate::key::decode(id, encoded)?.to_string());
}
match page.resume {
Some(last) => range.start = std::ops::Bound::Excluded(last),
None => break,
}
}
Ok(keys)
}
pub(crate) async fn raw_get_many(
&self,
locker: &str,
keys: Vec<String>,
) -> Result<Vec<Option<Vec<u8>>>> {
if keys.is_empty() {
return Ok(Vec::new());
}
let id = self.raw_locker(locker).await?;
let encoded: Vec<Vec<u8>> = keys.iter().map(|k| crate::key::encode(id, k)).collect();
let stored = self.backend.get_many(Table::Records, encoded).await?;
stored
.into_iter()
.map(|slot| match slot {
Some(bytes) => Ok(Some(crate::codec::decode(&bytes, &self.chain)?)),
None => Ok(None),
})
.collect()
}
pub(crate) async fn raw_put_all(
&self,
locker: &str,
entries: Vec<(String, Vec<u8>)>,
) -> Result<()> {
if entries.is_empty() {
return Ok(());
}
let id = self.raw_locker(locker).await?;
let mut ops = Vec::with_capacity(entries.len());
for (key, value) in entries {
ops.push(Op::Put {
table: Table::Records,
key: crate::key::encode(id, &key),
value: crate::codec::encode(&value, &self.chain)?,
});
}
self.backend.commit(ops).await
}
pub(crate) async fn raw_delete_all(&self, locker: &str, keys: Vec<String>) -> Result<()> {
if keys.is_empty() {
return Ok(());
}
let id = self.raw_locker(locker).await?;
let ops = keys
.into_iter()
.map(|key| Op::Delete {
table: Table::Records,
key: crate::key::encode(id, &key),
})
.collect();
self.backend.commit(ops).await
}
pub(crate) async fn raw_entries(
&self,
locker: &str,
prefix: &str,
) -> Result<Vec<(String, Vec<u8>)>> {
let id = self.raw_locker(locker).await?;
let mut range = crate::key::prefix_range(id, prefix);
let mut entries = Vec::new();
let limit = self.backend.scan_page_size();
loop {
let page = self
.backend
.scan(ScanRequest {
table: Table::Records,
range: range.clone(),
reverse: false,
limit,
want_values: true,
})
.await?;
for (encoded, value) in &page.items {
let key = crate::key::decode(id, encoded)?.to_string();
let stored = value.as_deref().ok_or_else(|| {
Error::Corrupt(format!(
"the backend returned no value for {key:?} in a scan that asked for values"
))
})?;
entries.push((key, crate::codec::decode(stored, &self.chain)?));
}
match page.resume {
Some(last) => range.start = std::ops::Bound::Excluded(last),
None => break,
}
}
Ok(entries)
}
pub(crate) async fn raw_contains_key(&self, locker: &str, key: &str) -> Result<bool> {
let id = self.raw_locker(locker).await?;
let encoded = crate::key::encode(id, key);
Ok(self.backend.get(Table::Records, &encoded).await?.is_some())
}
pub(crate) async fn raw_len(&self, locker: &str) -> Result<usize> {
let id = self.raw_locker(locker).await?;
let mut range = crate::key::locker_range(id);
let mut total = 0usize;
let limit = self.backend.scan_page_size();
loop {
let page = self
.backend
.scan(ScanRequest {
table: Table::Records,
range: range.clone(),
reverse: false,
limit,
want_values: false,
})
.await?;
total += page.items.len();
match page.resume {
Some(last) => range.start = std::ops::Bound::Excluded(last),
None => break,
}
}
Ok(total)
}
pub async fn bind_schema(&self, id: LockerId, tag: &str) -> Result<()> {
let key = schema_key(id);
match self.backend.get(Table::Meta, &key).await? {
Some(raw) => {
let stored = String::from_utf8(raw)
.map_err(|e| Error::Corrupt(format!("schema tag is not UTF-8: {e}")))?;
if stored != tag {
return Err(Error::SchemaMismatch {
stored,
requested: tag.to_string(),
});
}
Ok(())
}
None => {
self.backend
.commit(vec![Op::Put {
table: Table::Meta,
key,
value: tag.as_bytes().to_vec(),
}])
.await
}
}
}
pub async fn locker_names(&self) -> Result<Vec<String>> {
let mut names = Vec::new();
let mut range = KeyRange::prefix(META_LOCKER_PREFIX);
loop {
let page = self
.backend
.scan(ScanRequest {
table: Table::Meta,
range: range.clone(),
reverse: false,
limit: 256,
want_values: false,
})
.await?;
for (key, _) in &page.items {
let raw = &key[META_LOCKER_PREFIX.len()..];
names.push(
String::from_utf8(raw.to_vec())
.map_err(|e| Error::Corrupt(format!("locker name is not UTF-8: {e}")))?,
);
}
match page.resume {
Some(last) => range.start = std::ops::Bound::Excluded(last),
None => break,
}
}
Ok(names)
}
fn maintenance_inner(&self, id: LockerId, name: &str, chain: Arc<FilterChain>) -> Arc<Inner> {
Arc::new(Inner {
write_lock: futures::lock::Mutex::new(()),
backend: self.backend.clone(),
chain,
id,
name: name.to_string(),
config: LockerConfig::default(),
shared: self.shared.clone(),
watchers: Default::default(),
closed: std::sync::atomic::AtomicBool::new(false),
epochs: Default::default(),
name_shared: std::sync::atomic::AtomicBool::new(true),
})
}
pub async fn locker_exists(&self, name: &str) -> Result<bool> {
if self.cached(name).is_some() {
return Ok(true);
}
Ok(self
.backend
.get(Table::Meta, &locker_key(name))
.await?
.is_some())
}
pub async fn locker_bytes(&self, name: &str) -> Result<u64> {
if !self.locker_exists(name).await? {
return Ok(0);
}
let id = self.locker_id(name).await?;
let chain = self.locker_chain_or_bank(id).await?;
let inner = self.maintenance_inner(id, name, chain);
let mut total: u64 = 0;
let mut chunked: Vec<u64> = Vec::new();
inner
.walk(
std::ops::Bound::Unbounded,
std::ops::Bound::Unbounded,
false,
true,
|_, value| {
if let Some(raw) = value {
total = total.saturating_add(raw.len() as u64);
if crate::locker::chunk::is_pointer(&raw) {
if let Ok(pointer) = crate::locker::chunk::ChunkPointer::parse(&raw) {
chunked.push(pointer.value_id);
}
}
}
Ok(())
},
)
.await?;
for value_id in chunked {
total = total.saturating_add(self.chunk_bytes(value_id).await?);
}
Ok(total)
}
async fn chunk_bytes(&self, value_id: u64) -> Result<u64> {
let mut range = crate::locker::chunk::chunk_range(value_id);
let mut total: u64 = 0;
loop {
let page = self
.backend
.scan(ScanRequest {
table: Table::Chunks,
range: range.clone(),
reverse: false,
limit: 256,
want_values: true,
})
.await?;
for (_, value) in &page.items {
if let Some(bytes) = value {
total = total.saturating_add(bytes.len() as u64);
}
}
match page.resume {
Some(last) => range.start = std::ops::Bound::Excluded(last),
None => break,
}
}
Ok(total)
}
pub async fn verify(&self, name: &str) -> Result<Vec<Vec<u8>>> {
if !self.locker_exists(name).await? {
return Ok(Vec::new());
}
let id = self.locker_id(name).await?;
let Some(chain) = self.locker_chain(id).await? else {
let stored = self.stored_chain_id(id).await?;
return Err(Error::SchemaMismatch {
stored: format!(
"filter chain {}; nothing in this process can open it",
stored.map(|s| s.to_string()).unwrap_or_else(|| "?".into())
),
requested: format!(
"locker {name:?} cannot be verified without its chain — register it \
with Bank::register_chain, or open the locker with it first"
),
});
};
let inner = self.maintenance_inner(id, name, chain);
let mut bad: Vec<Vec<u8>> = Vec::new();
let mut chunked: Vec<(Vec<u8>, crate::locker::chunk::ChunkPointer)> = Vec::new();
inner
.walk(
std::ops::Bound::Unbounded,
std::ops::Bound::Unbounded,
false,
true,
|key, value| {
let Some(raw) = value else {
bad.push(key);
return Ok(());
};
if crate::locker::chunk::is_pointer(&raw) {
match crate::locker::chunk::ChunkPointer::parse(&raw) {
Ok(pointer) => chunked.push((key, pointer)),
Err(_) => bad.push(key),
}
} else if inner.chain.open(&raw).is_err() {
bad.push(key);
}
Ok(())
},
)
.await?;
for (key, pointer) in chunked {
if inner.read_chunks(&pointer).await.is_err() {
bad.push(key);
}
}
bad.sort();
Ok(bad)
}
pub async fn quarantine(&self, name: &str, keys: &[&[u8]]) -> Result<usize> {
if self.is_locker_open(name) {
return Err(Error::InvalidConfig(format!(
"locker {name:?} is still open; close it before quarantining records"
)));
}
if keys.is_empty() || !self.locker_exists(name).await? {
return Ok(0);
}
let id = self.locker_id(name).await?;
let chain = self.locker_chain_or_bank(id).await?;
let inner = self.maintenance_inner(id, name, chain);
let mut ops = Vec::new();
let mut removed = 0usize;
for key in keys {
let Some(existing) = inner.fetch(key).await? else {
continue;
};
if crate::locker::chunk::is_pointer(&existing) {
if let Ok(pointer) = crate::locker::chunk::ChunkPointer::parse(&existing) {
ops.push(crate::locker::chunk::gc_ops(&pointer));
}
}
ops.push(inner.delete_op(key));
removed += 1;
}
if !ops.is_empty() {
self.backend.commit(ops).await?;
}
Ok(removed)
}
pub async fn delete_locker(&self, name: &str) -> Result<bool> {
if self.is_locker_open(name) {
return Err(Error::InvalidConfig(format!(
"locker {name:?} is still open; close it before deleting it"
)));
}
if !self.locker_exists(name).await? {
return Ok(false);
}
let id = self.locker_id(name).await?;
let chain = self.locker_chain_or_bank(id).await?;
let inner = self.maintenance_inner(id, name, chain);
let mut ops = inner.clear_value_ops().await?;
ops.push(Op::Delete {
table: Table::Meta,
key: locker_key(name),
});
ops.push(Op::Delete {
table: Table::Meta,
key: schema_key(id),
});
self.backend.commit(ops).await?;
if let Ok(mut guard) = self.registry.lock() {
guard.remove(name);
}
if let Ok(mut guard) = self.open_lockers.lock() {
guard.remove(name);
}
Ok(true)
}
pub async fn close(&self) -> Result<()> {
if self.is_closed() {
return Ok(());
}
let flushed = self.flush_all().await;
if self.closed.swap(true, Ordering::AcqRel) {
return flushed;
}
self.shared.coherence.close();
let closed = self.backend.close().await;
#[cfg(not(target_arch = "wasm32"))]
self.release_tracked_path();
flushed.and(closed)
}
#[cfg(not(target_arch = "wasm32"))]
fn release_tracked_path(&self) {
let taken = match self.tracked_path.lock() {
Ok(mut guard) => guard.take(),
Err(_) => None,
};
if let Some(key) = taken {
release_open_bank(&key);
}
}
pub fn is_closed(&self) -> bool {
self.closed.load(Ordering::Acquire)
}
fn register_resident(&self, resident: &Arc<crate::locker::resident::Resident>) {
if let Ok(mut guard) = self.residents.lock() {
guard.retain(|weak| weak.strong_count() > 0);
guard.push(Arc::downgrade(resident));
}
}
pub async fn flush_all(&self) -> Result<()> {
self.ensure_open()?;
let residents: Vec<Arc<crate::locker::resident::Resident>> = match self.residents.lock() {
Ok(mut guard) => {
guard.retain(|weak| weak.strong_count() > 0);
guard.iter().filter_map(|weak| weak.upgrade()).collect()
}
Err(_) => Vec::new(),
};
let mut first: Option<Error> = None;
for resident in residents {
if let Err(e) = resident.flush().await {
first.get_or_insert(e);
}
}
let flushed = self.backend.flush().await;
match first {
Some(e) => Err(e),
None => flushed,
}
}
fn claim_open(&self, name: &str, open: OpenLocker) -> Option<Shared> {
let mut guard = self.open_lockers.lock().ok()?;
Self::prune(&mut guard);
if let Some(winner) = guard.get(name).and_then(OpenLocker::upgrade) {
winner.inner.mark_name_shared();
if let Some(mine) = open.inner.upgrade() {
mine.mark_name_shared();
}
return Some(winner);
}
guard.insert(name.to_string(), open);
None
}
fn open_locker(&self, name: &str) -> Option<Shared> {
let mut guard = self.open_lockers.lock().ok()?;
Self::prune(&mut guard);
guard.get(name)?.upgrade()
}
fn check_shared<T>(
name: &str,
open: &Shared,
kind: TxMode,
config: &LockerConfig,
) -> Result<()> {
if open.kind != kind {
return Err(Error::SchemaMismatch {
stored: format!("{} locker {name:?}", kind_word(open.kind)),
requested: format!("{} locker {name:?}", kind_word(kind)),
});
}
let requested = type_tag::<T>();
if open.type_tag != requested {
return Err(Error::SchemaMismatch {
stored: open.type_tag.clone(),
requested,
});
}
if let Some(field) = config_conflict(&open.config, config) {
return Err(Error::InvalidConfig(format!(
"locker {name:?} is already open with a different {field}; every handle on \
one name shares its state, so they must be opened the same way. Close the \
open handle first, or open this one with the same config."
)));
}
Ok(())
}
pub fn is_locker_open(&self, name: &str) -> bool {
let Ok(mut guard) = self.open_lockers.lock() else {
return false;
};
Self::prune(&mut guard);
guard.contains_key(name)
}
pub fn open_locker_names(&self) -> Vec<String> {
let Ok(mut guard) = self.open_lockers.lock() else {
return Vec::new();
};
Self::prune(&mut guard);
let mut names: Vec<String> = guard.keys().cloned().collect();
names.sort();
names
}
fn prune(map: &mut HashMap<String, OpenLocker>) {
map.retain(|_, open| match open.inner.upgrade() {
Some(inner) => !inner.is_closed(),
None => false,
});
}
fn cached(&self, name: &str) -> Option<LockerId> {
self.registry.lock().ok()?.get(name).copied()
}
fn cache(&self, name: &str, id: LockerId) {
if let Ok(mut guard) = self.registry.lock() {
guard.insert(name.to_string(), id);
}
}
}
#[cfg(not(target_arch = "wasm32"))]
static OPEN_BANKS: std::sync::OnceLock<Mutex<std::collections::HashSet<std::path::PathBuf>>> =
std::sync::OnceLock::new();
#[cfg(not(target_arch = "wasm32"))]
fn open_banks() -> &'static Mutex<std::collections::HashSet<std::path::PathBuf>> {
OPEN_BANKS.get_or_init(|| Mutex::new(std::collections::HashSet::new()))
}
#[cfg(not(target_arch = "wasm32"))]
fn bank_key(path: &std::path::Path) -> std::path::PathBuf {
std::fs::canonicalize(path)
.or_else(|_| std::path::absolute(path))
.unwrap_or_else(|_| path.to_path_buf())
}
#[cfg(not(target_arch = "wasm32"))]
fn register_open_bank(key: std::path::PathBuf) {
if let Ok(mut guard) = open_banks().lock() {
guard.insert(key);
}
}
#[cfg(not(target_arch = "wasm32"))]
fn release_open_bank(key: &std::path::Path) {
if let Ok(mut guard) = open_banks().lock() {
guard.remove(key);
}
}
#[cfg(not(target_arch = "wasm32"))]
fn bank_is_open(key: &std::path::Path) -> bool {
match open_banks().lock() {
Ok(guard) => guard.contains(key),
Err(_) => true,
}
}
pub async fn delete_bank(config: &BankConfig) -> Result<()> {
match &config.location {
Location::Memory => Ok(()),
Location::Path(path) => {
#[cfg(not(target_arch = "wasm32"))]
{
if bank_is_open(&bank_key(path)) {
return Err(Error::InvalidConfig(format!(
"the bank at {} is still open in this process; \
close the bank first",
path.display()
)));
}
match std::fs::remove_file(path) {
Ok(()) => Ok(()),
Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(()),
Err(e) if cfg!(windows) && e.kind() == std::io::ErrorKind::PermissionDenied => {
Err(Error::InvalidConfig(format!(
"the bank file {} is held open by something else; \
close the bank first",
path.display()
)))
}
Err(e) => Err(Error::backend(format!(
"deleting the bank file {}: {e}",
path.display()
))),
}
}
#[cfg(target_arch = "wasm32")]
{
let _ = path;
Err(Error::InvalidConfig(
"Location::Path is native-only; use Location::Web on wasm".into(),
))
}
}
Location::Web(name) => {
#[cfg(target_arch = "wasm32")]
{
crate::backend::IndexedDbBackend::delete_database(name).await
}
#[cfg(not(target_arch = "wasm32"))]
{
let _ = name;
Err(Error::InvalidConfig(
"Location::Web is wasm-only; use Location::Path on native".into(),
))
}
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn the_coherence_flag_is_accepted_and_native_ignores_it() {
let config = BankConfig::memory().with_coherence(true);
assert!(config.coherence);
assert!(!BankConfig::memory().coherence, "never on by default");
let bank = block_on(Bank::open(config)).unwrap();
let locker = block_on(bank.lazy_locker::<String>("l")).unwrap();
block_on(locker.put("k", &"v".to_string())).unwrap();
assert_eq!(block_on(locker.get("k")).unwrap(), Some("v".to_string()));
block_on(bank.close()).unwrap();
}
use crate::backend::MemoryBackend;
use futures::executor::block_on;
fn bank() -> Bank {
block_on(Bank::with_backend(Arc::new(MemoryBackend::new()))).unwrap()
}
fn corrupt_record(bank: &Bank, id: LockerId, key: &str) {
block_on(bank.backend().commit(vec![Op::Put {
table: Table::Records,
key: crate::key::encode(id, key),
value: b"not a CBNK envelope".to_vec(),
}]))
.unwrap();
}
#[test]
fn a_corrupt_record_can_be_skipped_verified_and_quarantined() {
use crate::locker::OnCorrupt;
let b = bank();
let l = block_on(b.locker::<String>("l")).unwrap();
block_on(l.put("good", "keep".into())).unwrap();
block_on(l.put("bad", "lose".into())).unwrap();
let id = block_on(b.locker_id("l")).unwrap();
block_on(l.close()).unwrap();
corrupt_record(&b, id, "bad");
assert!(matches!(
block_on(b.locker::<String>("l")),
Err(Error::Corrupt(_))
));
let skipping = block_on(b.locker_with::<String>(
"l",
LockerConfig::default().with_on_corrupt(OnCorrupt::Skip),
))
.unwrap();
assert_eq!(skipping.corrupt_keys(), vec![b"bad".to_vec()]);
assert!(skipping.get("bad").is_none());
assert_eq!(skipping.get("good").as_deref(), Some(&"keep".to_string()));
assert_eq!(skipping.len(), 1);
assert_eq!(block_on(b.verify("l")).unwrap(), vec![b"bad".to_vec()]);
assert!(matches!(
block_on(b.quarantine("l", &[b"bad"])),
Err(Error::InvalidConfig(_))
));
block_on(skipping.close()).unwrap();
assert_eq!(block_on(b.quarantine("l", &[b"bad"])).unwrap(), 1);
assert!(block_on(b.verify("l")).unwrap().is_empty());
let healed = block_on(b.locker::<String>("l")).unwrap();
assert_eq!(healed.len(), 1);
assert_eq!(healed.get("good").as_deref(), Some(&"keep".to_string()));
}
#[test]
fn quarantining_an_absent_key_removes_nothing() {
let b = bank();
let l = block_on(b.lazy_locker::<String>("l")).unwrap();
block_on(l.put("k", &"v".to_string())).unwrap();
block_on(l.close()).unwrap();
assert_eq!(block_on(b.quarantine("l", &[b"ghost"])).unwrap(), 0);
assert_eq!(block_on(b.quarantine("l", &[])).unwrap(), 0);
assert_eq!(
block_on(b.quarantine("never_registered", &[b"k"])).unwrap(),
0
);
let reopened = block_on(b.lazy_locker::<String>("l")).unwrap();
assert_eq!(reopened.len(), 1);
}
#[test]
fn verifying_an_unknown_locker_is_empty_not_an_error() {
let b = bank();
assert!(block_on(b.verify("never_registered")).unwrap().is_empty());
}
#[test]
fn a_lazy_get_reports_corruption_even_when_skipping() {
use crate::locker::OnCorrupt;
let b = bank();
let l = block_on(b.lazy_locker::<String>("l")).unwrap();
block_on(l.put("bad", &"v".to_string())).unwrap();
let id = block_on(b.locker_id("l")).unwrap();
block_on(l.close()).unwrap();
corrupt_record(&b, id, "bad");
let skipping = block_on(b.lazy_locker_with::<String>(
"l",
LockerConfig::default().with_on_corrupt(OnCorrupt::Skip),
))
.unwrap();
assert!(skipping.corrupt_keys().is_empty(), "nothing read yet");
assert!(block_on(skipping.get("bad")).is_err());
assert_eq!(skipping.corrupt_keys(), vec![b"bad".to_vec()]);
assert!(skipping.contains_key("bad"));
}
#[test]
fn ids_are_stable_across_lookups() {
let b = bank();
let first = block_on(b.locker_id("settings")).unwrap();
let again = block_on(b.locker_id("settings")).unwrap();
assert_eq!(first, again);
}
#[test]
fn distinct_names_get_distinct_ids() {
let b = bank();
let a = block_on(b.locker_id("a")).unwrap();
let c = block_on(b.locker_id("b")).unwrap();
assert_ne!(a, c);
}
#[test]
fn ids_survive_reopening_over_the_same_backend() {
let backend: Arc<dyn Backend> = Arc::new(MemoryBackend::new());
let first = block_on(Bank::with_backend(backend.clone())).unwrap();
let settings = block_on(first.locker_id("settings")).unwrap();
let candles = block_on(first.locker_id("candles")).unwrap();
drop(first);
let second = block_on(Bank::with_backend(backend)).unwrap();
assert_eq!(block_on(second.locker_id("settings")).unwrap(), settings);
assert_eq!(block_on(second.locker_id("candles")).unwrap(), candles);
}
#[test]
fn a_fresh_name_after_reopen_does_not_reuse_an_id() {
let backend: Arc<dyn Backend> = Arc::new(MemoryBackend::new());
let first = block_on(Bank::with_backend(backend.clone())).unwrap();
let a = block_on(first.locker_id("a")).unwrap();
let b_id = block_on(first.locker_id("b")).unwrap();
drop(first);
let second = block_on(Bank::with_backend(backend)).unwrap();
let c = block_on(second.locker_id("c")).unwrap();
assert_ne!(c, a);
assert_ne!(c, b_id);
}
#[test]
fn locker_names_lists_every_registration() {
let b = bank();
for name in ["ui_settings", "candle_cache", "reports"] {
block_on(b.locker_id(name)).unwrap();
}
let mut names = block_on(b.locker_names()).unwrap();
names.sort();
assert_eq!(names, vec!["candle_cache", "reports", "ui_settings"]);
}
#[test]
fn locker_names_pages_past_one_scan_page() {
let b = bank();
for i in 0..300 {
block_on(b.locker_id(&format!("locker_{i:04}"))).unwrap();
}
assert_eq!(block_on(b.locker_names()).unwrap().len(), 300);
}
#[test]
fn a_locker_name_may_contain_awkward_bytes() {
let b = bank();
let weird = "name with spaces :: and 🍎";
block_on(b.locker_id(weird)).unwrap();
assert_eq!(block_on(b.locker_names()).unwrap(), vec![weird]);
}
#[test]
fn binding_the_same_schema_twice_is_fine() {
let b = bank();
let id = block_on(b.locker_id("x")).unwrap();
block_on(b.bind_schema(id, "Settings")).unwrap();
block_on(b.bind_schema(id, "Settings")).unwrap();
}
#[test]
fn rebinding_a_different_schema_is_refused() {
let b = bank();
let id = block_on(b.locker_id("x")).unwrap();
block_on(b.bind_schema(id, "Settings")).unwrap();
match block_on(b.bind_schema(id, "ReportMeta")) {
Err(Error::SchemaMismatch { stored, requested }) => {
assert_eq!(stored, "Settings");
assert_eq!(requested, "ReportMeta");
}
other => panic!("expected a schema mismatch, got {other:?}"),
}
}
#[test]
fn schemas_are_per_locker_not_global() {
let b = bank();
let one = block_on(b.locker_id("one")).unwrap();
let two = block_on(b.locker_id("two")).unwrap();
block_on(b.bind_schema(one, "Settings")).unwrap();
block_on(b.bind_schema(two, "ReportMeta")).unwrap();
}
#[test]
fn lockers_open_from_the_bank_and_persist() {
let backend: Arc<dyn Backend> = Arc::new(MemoryBackend::new());
let first = block_on(Bank::with_backend(backend.clone())).unwrap();
let settings = block_on(first.locker::<String>("ui_settings")).unwrap();
block_on(settings.put("theme", "dark".into())).unwrap();
let candles = block_on(first.lazy_locker::<String>("candle_cache")).unwrap();
block_on(candles.put("BTCUSDT::1", &"ohlc".to_string())).unwrap();
drop(first);
let second = block_on(Bank::with_backend(backend)).unwrap();
let settings = block_on(second.locker::<String>("ui_settings")).unwrap();
assert_eq!(settings.get("theme").as_deref(), Some(&"dark".to_string()));
let candles = block_on(second.lazy_locker::<String>("candle_cache")).unwrap();
assert_eq!(
block_on(candles.get("BTCUSDT::1")).unwrap(),
Some("ohlc".into())
);
}
#[test]
fn two_lockers_do_not_see_each_other() {
let b = bank();
let one = block_on(b.locker::<String>("one")).unwrap();
let two = block_on(b.locker::<String>("two")).unwrap();
block_on(one.put("k", "from one".into())).unwrap();
block_on(two.put("k", "from two".into())).unwrap();
assert_eq!(one.get("k").as_deref(), Some(&"from one".to_string()));
assert_eq!(two.get("k").as_deref(), Some(&"from two".to_string()));
}
#[test]
fn reopening_a_locker_as_a_different_type_is_refused() {
let b = bank();
block_on(b.locker::<String>("x")).unwrap();
match block_on(b.locker::<u64>("x")) {
Err(Error::SchemaMismatch { .. }) => {}
other => panic!("expected a schema mismatch, got {:?}", other.map(|_| "ok")),
}
}
#[test]
fn a_future_format_version_is_refused() {
let backend: Arc<dyn Backend> = Arc::new(MemoryBackend::new());
block_on(backend.commit(vec![Op::Put {
table: Table::Meta,
key: META_FORMAT_VERSION.to_vec(),
value: (FORMAT_VERSION + 1).to_be_bytes().to_vec(),
}]))
.unwrap();
assert!(matches!(
block_on(Bank::with_backend(backend)),
Err(Error::UnsupportedVersion { .. })
));
}
#[test]
fn open_memory_round_trips() {
let bank = block_on(Bank::open(BankConfig::memory())).unwrap();
let locker = block_on(bank.locker::<String>("ui_settings")).unwrap();
block_on(locker.put("theme", "dark".into())).unwrap();
assert_eq!(locker.get("theme").as_deref(), Some(&"dark".to_string()));
}
#[test]
fn open_web_is_refused_on_native() {
match block_on(Bank::open(BankConfig::web("should-not-open"))) {
Err(Error::InvalidConfig(msg)) => {
assert!(msg.contains("wasm-only"), "{msg}");
}
other => panic!("expected InvalidConfig, got {other:?}"),
}
}
#[cfg(not(target_arch = "wasm32"))]
#[test]
fn open_path_persists_across_handles() {
let dir = tempfile::TempDir::new().unwrap();
let path = dir.path().join("bank.redb");
{
let bank = block_on(Bank::open(BankConfig::at(&path))).unwrap();
let locker = block_on(bank.locker::<String>("ui_settings")).unwrap();
block_on(locker.put("theme", "dark".into())).unwrap();
}
let bank = block_on(Bank::open(BankConfig::at(&path))).unwrap();
let locker = block_on(bank.locker::<String>("ui_settings")).unwrap();
assert_eq!(locker.get("theme").as_deref(), Some(&"dark".to_string()));
}
#[cfg(not(target_arch = "wasm32"))]
#[test]
fn delete_bank_removes_the_file_and_tolerates_a_missing_one() {
let dir = tempfile::TempDir::new().unwrap();
let path = dir.path().join("bank.redb");
let config = BankConfig::at(&path);
let bank = block_on(Bank::open(config.clone())).unwrap();
let locker = block_on(bank.locker::<String>("s")).unwrap();
block_on(locker.put("k", "v".into())).unwrap();
block_on(bank.close()).unwrap();
block_on(delete_bank(&config)).unwrap();
assert!(!path.exists());
block_on(delete_bank(&config)).unwrap();
let reborn = block_on(Bank::open(config)).unwrap();
let locker = block_on(reborn.locker::<String>("s")).unwrap();
assert_eq!(locker.get("k"), None, "the data went with the file");
}
#[cfg(not(target_arch = "wasm32"))]
#[test]
fn delete_bank_refuses_while_the_bank_is_open() {
let dir = tempfile::TempDir::new().unwrap();
let path = dir.path().join("live.redb");
let config = BankConfig::at(&path);
let bank = block_on(Bank::open(config.clone())).unwrap();
let locker = block_on(bank.locker::<String>("s")).unwrap();
block_on(locker.put("k", "v".into())).unwrap();
let refused = block_on(delete_bank(&config));
match refused {
Err(Error::InvalidConfig(msg)) => assert!(
msg.contains("close the bank first"),
"the error must say what to do instead: {msg}"
),
other => panic!("deleting an open bank must be refused, got {other:?}"),
}
assert!(path.exists(), "the refusal must not remove the file");
block_on(locker.put("k2", "v2".into())).unwrap();
assert_eq!(locker.get("k").as_deref(), Some(&"v".to_string()));
block_on(bank.close()).unwrap();
block_on(delete_bank(&config)).unwrap();
assert!(!path.exists());
}
#[cfg(not(target_arch = "wasm32"))]
#[test]
fn dropping_a_bank_without_closing_it_frees_the_name() {
let dir = tempfile::TempDir::new().unwrap();
let path = dir.path().join("dropped.redb");
let config = BankConfig::at(&path);
{
let bank = block_on(Bank::open(config.clone())).unwrap();
let locker = block_on(bank.locker::<String>("s")).unwrap();
block_on(locker.put("k", "v".into())).unwrap();
assert!(block_on(delete_bank(&config)).is_err(), "still open here");
}
block_on(delete_bank(&config)).unwrap();
assert!(!path.exists());
}
#[cfg(not(target_arch = "wasm32"))]
#[test]
fn the_open_registry_sees_through_a_roundabout_path() {
let dir = tempfile::TempDir::new().unwrap();
let path = dir.path().join("twisty.redb");
let bank = block_on(Bank::open(BankConfig::at(&path))).unwrap();
let roundabout = dir.path().join("sub").join("..").join("twisty.redb");
std::fs::create_dir_all(dir.path().join("sub")).unwrap();
assert!(
block_on(delete_bank(&BankConfig::at(&roundabout))).is_err(),
"the same file spelled differently is the same open bank"
);
block_on(bank.close()).unwrap();
}
#[cfg(not(target_arch = "wasm32"))]
#[test]
fn delete_bank_refuses_a_web_location_on_native() {
assert!(matches!(
block_on(delete_bank(&BankConfig::web("nope"))),
Err(Error::InvalidConfig(_))
));
}
#[test]
fn deleting_a_memory_bank_is_a_no_op() {
block_on(delete_bank(&BankConfig::memory())).unwrap();
}
}