use std::fs;
use std::path::PathBuf;
use std::sync::{Mutex, OnceLock};
use crate::error::{Error, Result};
pub(crate) const IN_MEMORY: &str = ":memory:";
#[derive(Default)]
struct Registry {
active: Option<String>,
refs: usize,
}
fn registry() -> &'static Mutex<Registry> {
static REGISTRY: OnceLock<Mutex<Registry>> = OnceLock::new();
REGISTRY.get_or_init(|| Mutex::new(Registry::default()))
}
#[derive(Debug)]
pub(crate) struct Slot {
key: String,
remove_on_last: Option<PathBuf>,
}
impl Slot {
pub(crate) fn remove_on_last(&mut self, dir: PathBuf) {
self.remove_on_last = Some(dir);
}
}
impl Drop for Slot {
fn drop(&mut self) {
let mut registry = match registry().lock() {
Ok(registry) => registry,
Err(poisoned) => poisoned.into_inner(),
};
registry.refs = registry.refs.saturating_sub(1);
if registry.refs == 0 {
registry.active = None;
if let Some(dir) = self.remove_on_last.take() {
let _ = fs::remove_dir_all(dir);
}
}
debug_assert!(
registry.refs == 0 || registry.active.as_deref() == Some(self.key.as_str()),
"the registry holds {:?} while a slot for {:?} was released",
registry.active,
self.key
);
}
}
pub(crate) fn acquire(key: String) -> Result<Slot> {
let mut registry = match registry().lock() {
Ok(registry) => registry,
Err(poisoned) => poisoned.into_inner(),
};
match registry.active.as_deref() {
Some(active) if active != key => {
return Err(Error::PathConflict {
active: active.to_string(),
requested: key,
})
}
Some(_) => {}
None => registry.active = Some(key.clone()),
}
registry.refs += 1;
Ok(Slot {
key,
remove_on_last: None,
})
}
pub(crate) fn active_path() -> Option<String> {
match registry().lock() {
Ok(registry) => registry.active.clone(),
Err(poisoned) => poisoned.into_inner().active.clone(),
}
}
pub(crate) fn refs() -> usize {
match registry().lock() {
Ok(registry) => registry.refs,
Err(poisoned) => poisoned.into_inner().refs,
}
}
pub(crate) fn key_from_args(args: &[&str]) -> String {
args.iter()
.find_map(|arg| arg.strip_prefix("--path="))
.map_or_else(|| IN_MEMORY.to_string(), resolve_key)
}
pub(crate) fn resolve_key(path: &str) -> String {
if path.is_empty() {
return IN_MEMORY.to_string();
}
path.to_string()
}
#[cfg(test)]
mod test {
use super::*;
#[test]
fn no_path_argument_means_in_memory() {
assert_eq!(key_from_args(&[]), IN_MEMORY);
assert_eq!(key_from_args(&["--log-level=debug"]), IN_MEMORY);
assert_eq!(key_from_args(&["--path=:memory:"]), IN_MEMORY);
}
#[test]
fn the_path_argument_is_found_among_others() {
let key = key_from_args(&["--log-level=debug", "--path=/tmp", "--max_threads=2"]);
assert_eq!(key, resolve_key("/tmp"));
}
#[test]
fn two_spellings_of_one_directory_are_two_keys() {
assert_ne!(resolve_key("/tmp"), resolve_key("/tmp/"));
assert_ne!(resolve_key("db"), resolve_key("./db"));
assert_ne!(resolve_key("file:/tmp"), resolve_key("/tmp"));
}
#[test]
fn an_identical_spelling_is_one_key() {
assert_eq!(resolve_key("/tmp/db"), resolve_key("/tmp/db"));
}
}