use crate::documents::{
Doc, DocDefinition, Owner, check_record_scope, check_record_version, materialize_document, resolve_address,
};
use crate::transaction::{Tx, TxScope};
use crate::{
ConversationId, DocumentAddress, DocumentCopySource, DocumentPoint, DocumentRecord, Seq, Storage, StorageError,
StorageWrite,
};
use chord_delta::{DeltaError, Op, Tracker};
use serde_json::Value;
use std::collections::HashMap;
use std::fmt;
use std::sync::{Arc, Condvar, Mutex, MutexGuard};
#[derive(Clone, Debug, PartialEq)]
pub enum SessionError {
Failed(Box<SessionError>),
ReadAfterWrite(&'static str),
Busy(ConversationId),
Closed,
Storage(StorageError),
Delta(DeltaError),
Type(String),
Error(String),
}
impl SessionError {
pub fn name(&self) -> &'static str {
match self {
SessionError::Failed(_) => "SessionFailed",
SessionError::ReadAfterWrite(_) => "ReadAfterWrite",
SessionError::Busy(_) => "ConversationBusy",
SessionError::Closed | SessionError::Error(_) => "Error",
SessionError::Storage(error) => error.name(),
SessionError::Delta(error) => error.name(),
SessionError::Type(_) => "TypeError",
}
}
}
impl fmt::Display for SessionError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
SessionError::Failed(_) => f.write_str("Session failed after a storage error; close and reopen it"),
SessionError::ReadAfterWrite(method) => {
write!(f, "Tx.{method}() cannot read tables after the first table write")
}
SessionError::Busy(id) => write!(f, "Conversation {} is busy", id.0),
SessionError::Closed => f.write_str("Session is closed"),
SessionError::Storage(error) => error.fmt(f),
SessionError::Delta(error) => error.fmt(f),
SessionError::Type(message) | SessionError::Error(message) => f.write_str(message),
}
}
}
impl std::error::Error for SessionError {}
impl From<StorageError> for SessionError {
fn from(error: StorageError) -> Self {
SessionError::Storage(error)
}
}
impl From<DeltaError> for SessionError {
fn from(error: DeltaError) -> Self {
SessionError::Delta(error)
}
}
pub type Result<T> = std::result::Result<T, SessionError>;
#[derive(Clone, Debug, PartialEq)]
pub enum SessionEnd {
Closed,
Failed(SessionError),
}
#[derive(Clone, Debug, PartialEq)]
#[allow(
clippy::large_enum_variant,
reason = "short-lived publication value; boxing would only complicate matching"
)]
pub enum CommitChange {
Table(StorageWrite),
Document {
record: DocumentRecord,
conversation_id: Option<ConversationId>,
version: Option<u64>,
value: Option<Arc<Value>>,
ops: Vec<Op>,
},
DocumentCopy {
record: DocumentRecord,
conversation_id: ConversationId,
source: DocumentCopySource,
},
}
#[derive(Clone, Debug, PartialEq)]
pub struct CommitPublication {
pub seq: Seq,
pub changes: Vec<CommitChange>,
}
pub(crate) struct LoadedDocument {
pub record: DocumentRecord,
pub stored_version: u64,
pub value_version: u64,
pub deltas_since_base: usize,
pub tracker: Tracker,
}
pub(crate) type Loaded = Arc<Mutex<LoadedDocument>>;
pub(crate) use jsrt::sync::lock;
pub(crate) struct LineState {
storage: Box<dyn Storage + Send>,
storage_closed: bool,
}
struct Line {
turn: Mutex<(u64, u64)>,
advanced: Condvar,
state: Mutex<LineState>,
}
pub(crate) struct LineGuard<'a> {
line: &'a Line,
state: Option<MutexGuard<'a, LineState>>,
}
impl Line {
fn enter(&self) -> LineGuard<'_> {
let mut turn = lock(&self.turn);
let ticket = turn.0;
turn.0 += 1;
while turn.1 != ticket {
turn = self
.advanced
.wait(turn)
.unwrap_or_else(|poisoned| poisoned.into_inner());
}
drop(turn);
LineGuard {
line: self,
state: Some(lock(&self.state)),
}
}
}
impl Drop for LineGuard<'_> {
fn drop(&mut self) {
self.state.take();
lock(&self.line.turn).1 += 1;
self.line.advanced.notify_all();
}
}
impl std::ops::Deref for LineGuard<'_> {
type Target = LineState;
fn deref(&self) -> &LineState {
self.state.as_ref().expect("held")
}
}
impl std::ops::DerefMut for LineGuard<'_> {
fn deref_mut(&mut self) -> &mut LineState {
self.state.as_mut().expect("held")
}
}
type CommitListener = Arc<dyn Fn(&CommitPublication) + Send + Sync>;
type CloseListener = Arc<dyn Fn() + Send + Sync>;
#[derive(Default)]
struct Listeners {
next: u64,
commits: Vec<(u64, CommitListener)>,
closes: Vec<(u64, CloseListener)>,
}
#[derive(Default)]
struct Status {
closing: bool,
failure: Option<SessionError>,
end: Option<SessionEnd>,
}
pub(crate) struct Inner {
line: Line,
pub(crate) documents: Mutex<HashMap<String, Loaded>>,
listeners: Mutex<Listeners>,
status: Mutex<Status>,
ended: Condvar,
pub(crate) now: Box<dyn Fn() -> u64 + Send + Sync>,
}
#[derive(Clone)]
pub struct Session {
inner: Arc<Inner>,
}
pub struct Subscription {
inner: Arc<Inner>,
id: u64,
}
impl Subscription {
pub fn unsubscribe(self) {
let mut listeners = lock(&self.inner.listeners);
listeners.commits.retain(|(id, _)| *id != self.id);
listeners.closes.retain(|(id, _)| *id != self.id);
}
}
fn wall_clock() -> u64 {
jsrt::date::now_ms() as u64
}
impl Session {
pub fn new(storage: impl Storage + Send + 'static) -> Session {
Session::with_clock(storage, wall_clock)
}
pub fn with_clock(
storage: impl Storage + Send + 'static,
now: impl Fn() -> u64 + Send + Sync + 'static,
) -> Session {
Session {
inner: Arc::new(Inner {
line: Line {
turn: Mutex::new((0, 0)),
advanced: Condvar::new(),
state: Mutex::new(LineState {
storage: Box::new(storage),
storage_closed: false,
}),
},
documents: Mutex::new(HashMap::new()),
listeners: Mutex::new(Listeners::default()),
status: Mutex::new(Status::default()),
ended: Condvar::new(),
now: Box::new(now),
}),
}
}
pub fn commit<T>(&self, change: impl FnOnce(&mut Tx<'_>) -> Result<T>) -> Result<T> {
self.commit_with(TxScope::default(), change)
}
pub fn commit_with<T>(&self, scope: TxScope, change: impl FnOnce(&mut Tx<'_>) -> Result<T>) -> Result<T> {
self.inner.assert_usable()?;
let mut line = self.inner.line.enter();
self.inner.assert_healthy()?;
let mut tx = Tx::new(&self.inner, &mut line, scope);
let result = match change(&mut tx) {
Ok(result) => result,
Err(error) => {
tx.discard();
return Err(error);
}
};
if let Err(error) = self.inner.assert_healthy() {
tx.discard();
return Err(error);
}
let (writes, plans) = tx.settle()?;
if writes.is_empty() {
return Ok(result);
}
let tables: Vec<StorageWrite> = writes
.iter()
.filter(|write| {
matches!(
write,
StorageWrite::Conversation { .. }
| StorageWrite::Entry { .. }
| StorageWrite::Task { .. }
| StorageWrite::Submission { .. }
)
})
.cloned()
.collect();
let seq = self.inner.guard(&mut line, false, |storage| storage.commit(writes))?;
let documents = match crate::transaction::adopt(&self.inner, plans, seq) {
Ok(documents) => documents,
Err(error) => {
self.inner.fail(&mut line, error.clone());
return Err(error);
}
};
let mut changes: Vec<CommitChange> = tables.into_iter().map(CommitChange::Table).collect();
changes.extend(documents);
self.inner.publish(&CommitPublication { seq, changes });
Ok(result)
}
pub fn snapshot(&self, doc: &Doc, owner: Owner) -> Result<Option<Arc<Value>>> {
self.inner.assert_usable()?;
let definition = doc.definition();
let resolved = resolve_address(definition, owner)?;
let cached = lock(&self.inner.documents).get(&resolved.id).cloned();
let loaded = match cached.filter(|loaded| lock(loaded).value_version == definition.version) {
Some(loaded) => Some(loaded),
None => {
let mut line = self.inner.line.enter();
self.inner.assert_healthy()?;
self.inner
.load(&mut line, definition, &resolved.id, &resolved.address)?
}
};
let Some(loaded) = loaded else { return Ok(None) };
let loaded = lock(&loaded);
check_record_scope(definition, &loaded.record.identity)?;
check_record_version(definition, &loaded.record.identity, loaded.stored_version)?;
Ok(Some(loaded.tracker.value().clone()))
}
pub fn fail(&self, error: SessionError) {
let mut line = self.inner.line.enter();
self.inner.fail(&mut line, error);
}
pub fn subscribe_commits(
&self,
listener: impl Fn(&CommitPublication) + Send + Sync + 'static,
) -> Result<Subscription> {
self.inner.assert_usable()?;
let mut listeners = lock(&self.inner.listeners);
listeners.next += 1;
let id = listeners.next;
listeners.commits.push((id, Arc::new(listener)));
Ok(Subscription {
inner: self.inner.clone(),
id,
})
}
pub fn subscribe_close(&self, listener: impl Fn() + Send + Sync + 'static) -> Result<Subscription> {
self.inner.assert_usable()?;
let mut listeners = lock(&self.inner.listeners);
listeners.next += 1;
let id = listeners.next;
listeners.closes.push((id, Arc::new(listener)));
Ok(Subscription {
inner: self.inner.clone(),
id,
})
}
pub fn close(&self) -> Result<()> {
let first = {
let mut status = lock(&self.inner.status);
!std::mem::replace(&mut status.closing, true)
};
if !first {
self.wait_closed();
return Ok(());
}
self.inner.notify_close();
let mut line = self.inner.line.enter();
lock(&self.inner.listeners).commits.clear();
lock(&self.inner.documents).clear();
let result = if line.storage_closed {
Ok(())
} else {
line.storage_closed = true;
line.storage.close()
};
let mut status = lock(&self.inner.status);
if let Err(error) = &result
&& status.failure.is_none()
{
status.failure = Some(SessionError::Storage(error.clone()));
}
status.end = Some(match &status.failure {
None => SessionEnd::Closed,
Some(failure) => SessionEnd::Failed(failure.clone()),
});
self.inner.ended.notify_all();
result.map_err(SessionError::Storage)
}
pub fn wait_closed(&self) -> SessionEnd {
let status = lock(&self.inner.status);
let status = self
.inner
.ended
.wait_while(status, |status| status.end.is_none())
.unwrap_or_else(|poisoned| poisoned.into_inner());
status.end.clone().expect("ended")
}
pub fn failure(&self) -> Option<SessionError> {
lock(&self.inner.status).failure.clone()
}
pub fn line_len(&self) -> u64 {
let turn = lock(&self.inner.line.turn);
turn.0 - turn.1
}
}
impl Inner {
pub(crate) fn assert_healthy(&self) -> Result<()> {
match &lock(&self.status).failure {
Some(failure) => Err(SessionError::Failed(Box::new(failure.clone()))),
None => Ok(()),
}
}
fn assert_usable(&self) -> Result<()> {
let status = lock(&self.status);
if let Some(failure) = &status.failure {
return Err(SessionError::Failed(Box::new(failure.clone())));
}
if status.closing {
return Err(SessionError::Closed);
}
Ok(())
}
pub(crate) fn guard<T>(
&self,
line: &mut LineState,
read: bool,
call: impl FnOnce(&mut dyn Storage) -> crate::Result<T>,
) -> Result<T> {
self.assert_healthy()?;
if line.storage_closed {
return Err(SessionError::Closed);
}
match call(line.storage.as_mut()) {
Ok(value) => Ok(value),
Err(error) => {
let exempt = read && matches!(error, StorageError::Request(_));
if !exempt {
self.fail(line, SessionError::Storage(error.clone()));
}
Err(SessionError::Storage(error))
}
}
}
pub(crate) fn fail(&self, line: &mut LineState, error: SessionError) {
{
let mut status = lock(&self.status);
if status.failure.is_some() {
return;
}
status.failure = Some(error.clone());
status.closing = true;
}
self.notify_close();
lock(&self.listeners).commits.clear();
lock(&self.documents).clear();
if !line.storage_closed {
line.storage_closed = true;
let _ = line.storage.close();
}
lock(&self.status).end = Some(SessionEnd::Failed(error));
self.ended.notify_all();
}
fn notify_close(&self) {
let closes = std::mem::take(&mut lock(&self.listeners).closes);
for (_, listener) in closes {
listener();
}
}
fn publish(&self, publication: &CommitPublication) {
let commits = lock(&self.listeners).commits.clone();
for (_, listener) in commits {
listener(publication);
}
}
pub(crate) fn load(
&self,
line: &mut LineState,
definition: &DocDefinition,
address_id: &str,
address: &DocumentAddress,
) -> Result<Option<Loaded>> {
let cached = lock(&self.documents).get(address_id).cloned();
if let Some(cached) = cached {
if lock(&cached).value_version == definition.version {
return Ok(Some(cached));
}
lock(&self.documents).remove(address_id);
}
let Some(record) = self.guard(line, true, |storage| {
storage.find_document(address, DocumentPoint::Current)
})?
else {
return Ok(None);
};
let id = record.identity.id;
let Some(stored) = self.guard(line, true, |storage| storage.document(id, DocumentPoint::Current))? else {
return Err(SessionError::Error(format!(
"Current document {} ({}) cannot be read",
id.0, record.identity.kind
)));
};
let value = materialize_document(definition, &stored)?;
let loaded = Arc::new(Mutex::new(LoadedDocument {
record: stored.record,
stored_version: stored.version,
value_version: definition.version,
deltas_since_base: stored.deltas_since_base,
tracker: Tracker::new(value),
}));
lock(&self.documents).insert(address_id.to_owned(), loaded.clone());
Ok(Some(loaded))
}
}