use std::collections::HashMap;
use std::path::Path;
use std::sync::{Arc, LazyLock, Mutex, Weak};
use parking_lot::RwLock;
use crate::concurrency::connection::{ReadConnection, WriteConnection};
use crate::concurrency::snapshot::Snapshot;
use crate::concurrency::writer_pipeline::WriterPipeline;
use crate::error::{Error, Result};
use crate::file::{CreateOptions, OpenMode, ValiseFile};
static DATABASE_REGISTRY: LazyLock<Mutex<HashMap<(u64, u64), Weak<Database>>>> =
LazyLock::new(|| Mutex::new(HashMap::new()));
type InodeKey = (u64, u64);
pub struct Database {
pub(crate) inner: RwLock<ValiseFile>,
pub(crate) pipeline: WriterPipeline,
pub(crate) writer_slot: Arc<parking_lot::Mutex<()>>,
inode_key: InodeKey,
}
impl Database {
pub fn open_read_write(path: impl AsRef<Path>) -> Result<Arc<Self>> {
Self::open(path, OpenMode::ReadWrite)
}
pub fn open_read_only(path: impl AsRef<Path>) -> Result<Arc<Self>> {
Self::open(path, OpenMode::ReadOnly)
}
pub fn open(path: impl AsRef<Path>, mode: OpenMode) -> Result<Arc<Self>> {
let path = path.as_ref();
let inode_key = inode_for_path(path)?;
if let Some(existing) = lookup_registered(inode_key) {
return Ok(existing);
}
let valise = ValiseFile::open(path, mode)?;
let mut registry = DATABASE_REGISTRY
.lock()
.map_err(|_| Error::Other("database registry poisoned".into()))?;
if let Some(weak) = registry.get(&inode_key)
&& let Some(arc) = weak.upgrade()
{
return Ok(arc);
}
let pipeline = WriterPipeline::new();
valise.install_commit_fsync_barrier(Arc::clone(&pipeline.commit_fsync));
let db = Arc::new(Database {
inner: RwLock::new(valise),
pipeline,
writer_slot: Arc::new(parking_lot::Mutex::new(())),
inode_key,
});
registry.insert(inode_key, Arc::downgrade(&db));
Ok(db)
}
pub fn create(path: impl AsRef<Path>) -> Result<Arc<Self>> {
Self::create_with_options(path, CreateOptions::default())
}
pub fn create_with_options(
path: impl AsRef<Path>,
options: CreateOptions,
) -> Result<Arc<Self>> {
let path = path.as_ref();
let valise = ValiseFile::create_with_options(path, options)?;
let inode_key = inode_for_path(path)?;
let mut registry = DATABASE_REGISTRY
.lock()
.map_err(|_| Error::Other("database registry poisoned".into()))?;
let pipeline = WriterPipeline::new();
valise.install_commit_fsync_barrier(Arc::clone(&pipeline.commit_fsync));
let db = Arc::new(Database {
inner: RwLock::new(valise),
pipeline,
writer_slot: Arc::new(parking_lot::Mutex::new(())),
inode_key,
});
registry.insert(inode_key, Arc::downgrade(&db));
Ok(db)
}
pub fn snapshot(&self) -> Arc<Snapshot> {
self.inner.read().snapshot()
}
pub fn reader(self: &Arc<Self>) -> ReadConnection {
ReadConnection::new(Arc::clone(self))
}
pub fn writer(self: &Arc<Self>) -> WriteConnection {
let guard = Arc::clone(&self.writer_slot).lock_arc();
WriteConnection::new(Arc::clone(self), guard)
}
pub fn try_writer(self: &Arc<Self>) -> Option<WriteConnection> {
let guard = Arc::clone(&self.writer_slot).try_lock_arc()?;
Some(WriteConnection::new(Arc::clone(self), guard))
}
pub fn inode_key(&self) -> (u64, u64) {
self.inode_key
}
pub fn set_durability(&self, durability: crate::io::Durability) {
self.inner.write().set_durability(durability);
}
}
impl Drop for Database {
fn drop(&mut self) {
if let Ok(mut registry) = DATABASE_REGISTRY.lock() {
if let Some(weak) = registry.get(&self.inode_key)
&& weak.strong_count() == 0
{
registry.remove(&self.inode_key);
}
}
}
}
fn inode_for_path(path: &Path) -> Result<InodeKey> {
use std::os::unix::fs::MetadataExt;
let metadata = std::fs::metadata(path)?;
Ok((metadata.dev(), metadata.ino()))
}
fn lookup_registered(inode_key: InodeKey) -> Option<Arc<Database>> {
let registry = DATABASE_REGISTRY.lock().ok()?;
registry.get(&inode_key)?.upgrade()
}