use crate::{Checkpoint, DbError, DbErrorKind, ModelContainer};
use std::{
future::Future,
panic::{AssertUnwindSafe, catch_unwind},
pin::Pin,
sync::{
Arc, Mutex,
atomic::{AtomicBool, Ordering},
mpsc::{self, SyncSender},
},
task::{Context, Poll},
};
type Job = Box<dyn FnOnce(&mut Session) -> Result<(), DbError> + Send>;
struct Session {
db: ModelContainer,
revision: u64,
undo: Option<day_model::UndoStack>,
needs_publish: bool,
observers: Vec<Box<dyn Observation>>,
}
trait Observation {
fn refresh(&mut self, db: &ModelContainer, revision: u64) -> Result<bool, DbError>;
}
impl Session {
fn publish(&mut self) -> Result<(), DbError> {
if !std::mem::take(&mut self.needs_publish) {
return Ok(());
}
let mut error = None;
self.observers.retain_mut(|o| {
if error.is_some() {
return true;
}
match o.refresh(&self.db, self.revision) {
Ok(keep) => keep,
Err(e) => {
error = Some(e);
true
}
}
});
error.map_or(Ok(()), Err)
}
}
#[derive(Clone, Debug, PartialEq)]
pub struct WorkerSnapshot<T> {
pub revision: u64,
pub value: T,
}
struct Latest<T> {
value: Option<Result<WorkerSnapshot<T>, DbError>>,
closed: bool,
waker: Option<std::task::Waker>,
}
pub struct WorkerSubscription<T> {
slot: Arc<Mutex<Latest<T>>>,
}
impl<T> WorkerSubscription<T> {
pub async fn next(&mut self) -> Option<Result<WorkerSnapshot<T>, DbError>> {
std::future::poll_fn(|cx| {
let mut slot = lock(&self.slot);
if let Some(value) = slot.value.take() {
return Poll::Ready(Some(value));
}
if slot.closed {
return Poll::Ready(None);
}
slot.waker = Some(cx.waker().clone());
Poll::Pending
})
.await
}
}
struct Projection<T, F> {
slot: std::sync::Weak<Mutex<Latest<T>>>,
project: F,
previous: Option<T>,
}
impl<T, F> Drop for Projection<T, F> {
fn drop(&mut self) {
if let Some(slot) = self.slot.upgrade() {
let waker = {
let mut slot = lock(&slot);
slot.closed = true;
slot.waker.take()
};
if let Some(waker) = waker {
waker.wake();
}
}
}
}
impl<T: Clone + PartialEq + Send + 'static, F: Fn(&ModelContainer) -> Result<T, DbError>>
Observation for Projection<T, F>
{
fn refresh(&mut self, db: &ModelContainer, revision: u64) -> Result<bool, DbError> {
let Some(slot) = self.slot.upgrade() else {
return Ok(false);
};
let value = match db.worker_read(|db| (self.project)(db)) {
Ok(value) if self.previous.as_ref() == Some(&value) => return Ok(true),
Ok(value) => {
self.previous = Some(value.clone());
Ok(WorkerSnapshot { revision, value })
}
Err(error) => {
self.previous = None;
Err(error)
}
};
let fatal = value
.as_ref()
.err()
.filter(|e| matches!(e.kind, DbErrorKind::Closed | DbErrorKind::Panicked))
.cloned();
let waker = {
let mut slot = lock(&slot);
slot.value = Some(value);
slot.waker.take()
};
if let Some(waker) = waker {
waker.wake();
}
fatal.map_or(Ok(true), Err)
}
}
#[derive(Clone, Debug)]
pub struct WorkerOptions {
pub capacity: usize,
pub name: String,
}
impl Default for WorkerOptions {
fn default() -> Self {
Self {
capacity: 256,
name: "day-persistence".into(),
}
}
}
struct Control {
sender: Option<SyncSender<Job>>,
finished: bool,
error: Option<DbError>,
waiters: Vec<day_async::Deliver<Result<(), DbError>>>,
thread: Option<std::thread::ThreadId>,
}
#[derive(Clone)]
pub struct DatabaseWorker {
control: Arc<Mutex<Control>>,
}
#[must_use = "await the request to observe completion and persistence errors"]
pub struct WorkerRequest<R> {
receiver: day_async::Oneshot<Result<R, DbError>>,
cancelled: Arc<AtomicBool>,
cancel_on_drop: bool,
}
impl<R> Future for WorkerRequest<R> {
type Output = Result<R, DbError>;
fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
Pin::new(&mut self.receiver)
.poll(cx)
.map(|r| r.unwrap_or_else(|_| Err(closed())))
}
}
impl<R> Drop for WorkerRequest<R> {
fn drop(&mut self) {
if self.cancel_on_drop {
self.cancelled.store(true, Ordering::Release);
}
}
}
fn committed<T>(result: &Result<T, DbError>) -> bool {
result.is_ok()
|| result
.as_ref()
.err()
.is_some_and(|e| e.kind == DbErrorKind::CommittedRefreshFailed)
}
fn closed() -> DbError {
DbError::new(DbErrorKind::Closed, "database worker is closed")
}
fn lock<T>(value: &Mutex<T>) -> std::sync::MutexGuard<'_, T> {
value
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner)
}
impl DatabaseWorker {
pub async fn open(
factory: impl FnOnce() -> Result<ModelContainer, DbError> + Send + 'static,
) -> Result<Self, DbError> {
Self::open_with(WorkerOptions::default(), factory).await
}
pub async fn open_with(
options: WorkerOptions,
factory: impl FnOnce() -> Result<ModelContainer, DbError> + Send + 'static,
) -> Result<Self, DbError> {
if options.capacity == 0 {
return Err(DbError::new(
DbErrorKind::Busy,
"worker capacity must be positive",
));
}
let (sender, receiver) = mpsc::sync_channel::<Job>(options.capacity);
let control = Arc::new(Mutex::new(Control {
sender: Some(sender),
finished: false,
error: None,
waiters: Vec::new(),
thread: None,
}));
let weak = Arc::downgrade(&control);
let (ready, opened) = day_async::oneshot();
std::thread::Builder::new()
.name(options.name)
.spawn(move || {
if let Some(control) = weak.upgrade() {
lock(&control).thread = Some(std::thread::current().id());
}
let result = catch_unwind(AssertUnwindSafe(|| {
let scope = day_reactive::Scope::detached();
let result = scope.enter(|| {
let container = match factory() {
Ok(container) => container,
Err(error) => {
ready.send(Err(error.clone()));
return Err(error);
}
};
ready.send(Ok(()));
let mut session = Session {
db: container,
revision: 0,
undo: None,
needs_publish: false,
observers: Vec::new(),
};
let result = catch_unwind(AssertUnwindSafe(|| {
while let Ok(job) = receiver.recv() {
job(&mut session)?;
for _ in 1..32 {
match receiver.try_recv() {
Ok(job) => job(&mut session)?,
Err(_) => break,
}
}
session.publish()?;
}
session.db.save()
}))
.unwrap_or_else(|_| {
Err(DbError::new(
DbErrorKind::Panicked,
"database worker panicked",
))
});
session.observers.clear();
session.undo.take();
session.db.worker_dispose_caches();
result
});
scope.dispose();
result
}))
.unwrap_or_else(|_| {
Err(DbError::new(
DbErrorKind::Panicked,
"database worker panicked",
))
});
if let Some(control) = weak.upgrade() {
let waiters = {
let mut state = lock(&control);
state.sender.take();
state.finished = true;
state.error = result.as_ref().err().cloned();
std::mem::take(&mut state.waiters)
};
for waiter in waiters {
waiter.send(result.clone());
}
}
})
.map_err(|e| DbError::driver(e.to_string()))?;
opened.await.map_err(|_| {
DbError::new(DbErrorKind::Panicked, "database worker failed during open")
})??;
Ok(Self { control })
}
pub fn read<R: Send + 'static>(
&self,
read: impl FnOnce(&ModelContainer) -> Result<R, DbError> + Send + 'static,
) -> WorkerRequest<R> {
self.submit(true, move |session| session.db.worker_read(read))
}
pub fn write<R: Send + 'static>(
&self,
write: impl FnOnce(&ModelContainer) -> Result<R, DbError> + Send + 'static,
) -> WorkerRequest<R> {
self.write_with_origin(crate::WriteOrigin::Local, write)
}
pub fn write_with_origin<R: Send + 'static>(
&self,
origin: crate::WriteOrigin,
write: impl FnOnce(&ModelContainer) -> Result<R, DbError> + Send + 'static,
) -> WorkerRequest<R> {
self.submit(false, move |session| {
let checkpoint = session.undo.as_ref().map(day_model::UndoStack::checkpoint);
let group = session.undo.as_ref().map(|undo| undo.begin_group("edit"));
let result = session.db.worker_write_origin(origin, write);
drop(group); if committed(&result) {
session.revision += 1;
session.needs_publish = true;
} else if let (Some(undo), Some(checkpoint)) = (&session.undo, checkpoint) {
undo.restore_checkpoint(checkpoint);
}
result
})
}
pub fn write_resetting_undo<R: Send + 'static>(
&self,
write: impl FnOnce(&ModelContainer) -> Result<R, DbError> + Send + 'static,
) -> WorkerRequest<R> {
self.submit(false, move |session| {
let checkpoint = session.undo.as_ref().map(day_model::UndoStack::checkpoint);
let result = session
.db
.worker_write(|db| day_model::with_author("reset", || write(db)));
if committed(&result) {
if let Some(undo) = &session.undo {
undo.clear();
}
session.revision += 1;
session.needs_publish = true;
} else if let (Some(undo), Some(checkpoint)) = (&session.undo, checkpoint) {
undo.restore_checkpoint(checkpoint);
}
result
})
}
pub fn enable_undo(&self, levels: usize) -> WorkerRequest<()> {
self.submit(false, move |session| {
if session.undo.is_some() {
return Err(DbError::driver("worker undo already installed"));
}
session.undo = Some(session.db.undo(levels));
Ok(())
})
}
pub fn undo_status(&self) -> WorkerRequest<(bool, bool)> {
self.submit(true, |session| {
Ok(session
.undo
.as_ref()
.map_or_default(|u| (u.can_undo().get_untracked(), u.can_redo().get_untracked())))
})
}
pub fn undo(&self, redo: bool) -> WorkerRequest<bool> {
self.submit(false, move |session| {
let Some(undo) = &session.undo else {
return Ok(false);
};
let checkpoint = undo.checkpoint();
let result = session
.db
.worker_write(|_| Ok(if redo { undo.redo() } else { undo.undo() }));
if committed(&result) {
session.revision += 1;
session.needs_publish = true;
} else {
undo.restore_checkpoint(checkpoint);
}
result
})
}
pub async fn observe<T: Clone + PartialEq + Send + 'static>(
&self,
project: impl Fn(&ModelContainer) -> Result<T, DbError> + Send + 'static,
) -> Result<WorkerSubscription<T>, DbError> {
let slot = Arc::new(Mutex::new(Latest {
value: None,
closed: false,
waker: None,
}));
let projection = Projection {
slot: Arc::downgrade(&slot),
project,
previous: None,
};
self.submit(true, move |session| {
session.observers.push(Box::new(projection));
session.needs_publish = true;
Ok(())
})
.await?;
Ok(WorkerSubscription { slot })
}
pub fn backup_to(&self, path: impl Into<std::path::PathBuf>) -> WorkerRequest<()> {
let path = path.into();
self.submit(true, move |session| session.db.backup_to(&path))
}
pub fn checkpoint(&self) -> WorkerRequest<Checkpoint> {
self.submit(true, |session| session.db.checkpoint())
}
pub fn check_external(&self) -> WorkerRequest<bool> {
self.submit(true, |session| {
let changed = session.db.check_external()?;
if changed {
session.revision += 1;
session.needs_publish = true;
}
Ok(changed)
})
}
fn submit<R: Send + 'static>(
&self,
read: bool,
operation: impl FnOnce(&mut Session) -> Result<R, DbError> + Send + 'static,
) -> WorkerRequest<R> {
let (deliver, receiver) = day_async::oneshot();
let cancelled = Arc::new(AtomicBool::new(false));
let cancel = cancelled.clone();
let completion = Arc::new(Mutex::new(Some(deliver)));
let done = completion.clone();
let job: Job = Box::new(move |db| {
let result = if read && cancel.load(Ordering::Acquire) {
Err(DbError::new(
DbErrorKind::Cancelled,
"database read cancelled before execution",
))
} else {
catch_unwind(AssertUnwindSafe(|| operation(db))).unwrap_or_else(|_| {
Err(DbError::new(
DbErrorKind::Panicked,
"database operation panicked",
))
})
};
let fatal = result
.as_ref()
.err()
.filter(|e| matches!(e.kind, DbErrorKind::Panicked | DbErrorKind::Closed))
.cloned();
let deliver = lock(&done).take();
if let Some(deliver) = deliver {
deliver.send(result);
}
fatal.map_or(Ok(()), Err)
});
let mut rejected_job = None;
let rejected = {
let state = lock(&self.control);
if state.thread == Some(std::thread::current().id()) {
Some(DbError::driver(
"a database worker cannot submit work to its own queue",
))
} else {
match &state.sender {
None => Some(state.error.clone().unwrap_or_else(closed)),
Some(sender) => match sender.try_send(job) {
Ok(()) => None,
Err(mpsc::TrySendError::Full(job)) => {
rejected_job = Some(job);
Some(DbError::new(
DbErrorKind::Busy,
"database worker queue is full",
))
}
Err(mpsc::TrySendError::Disconnected(job)) => {
rejected_job = Some(job);
Some(closed())
}
},
}
}
};
drop(rejected_job);
if let Some(error) = rejected {
let deliver = lock(&completion).take();
if let Some(deliver) = deliver {
deliver.send(Err(error));
}
}
WorkerRequest {
receiver,
cancelled,
cancel_on_drop: read,
}
}
pub fn close_blocking(&self) -> Result<(), DbError> {
struct Unpark(std::thread::Thread);
impl std::task::Wake for Unpark {
fn wake(self: Arc<Self>) {
self.0.unpark();
}
}
let waker = std::task::Waker::from(Arc::new(Unpark(std::thread::current())));
let mut context = Context::from_waker(&waker);
let mut close = std::pin::pin!(self.close());
loop {
match close.as_mut().poll(&mut context) {
Poll::Ready(result) => return result,
Poll::Pending => std::thread::park(),
}
}
}
pub async fn close(&self) -> Result<(), DbError> {
let (deliver, receiver) = day_async::oneshot();
{
let mut state = lock(&self.control);
if state.thread == Some(std::thread::current().id()) {
return Err(DbError::driver(
"a database worker cannot wait for its own close",
));
}
state.sender.take();
if state.finished {
return state.error.clone().map_or(Ok(()), Err);
}
state.waiters.push(deliver);
}
receiver.await.map_err(|_| closed())?
}
}