use std::{
collections::{BTreeMap, HashMap, VecDeque},
sync::{Arc, Mutex, MutexGuard},
time::{SystemTime, UNIX_EPOCH},
};
use futures_util::stream;
use tokio::sync::watch;
use crate::{
AppendOutcome, AtomicWrite, DurableStateStore, EventStream, Journal, PersistenceError,
PersistenceId, PersistenceResult, ReplayRange, Revision, SelectedSnapshot, SequenceNr,
SerializedPayload, SnapshotCriteria, SnapshotMetadata, SnapshotStore, StoredEvent, Tag,
VersionedState,
query::{
DeletedDurableState, DurableStateChange, DurableStateChangesQuery, EventEnvelope,
EventsByPersistenceIdQuery, EventsByTagQuery, Offset, PersistenceIdsQuery, QueryMode,
QueryStream, UpdatedDurableState,
},
};
#[derive(Debug, Default)]
struct JournalEntity {
highest_sequence_nr: SequenceNr,
events: BTreeMap<SequenceNr, Arc<StoredEvent>>,
}
#[derive(Debug)]
struct JournalEvent {
offset: u64,
event: Arc<StoredEvent>,
}
#[derive(Debug, Default)]
struct MemoryJournalState {
entities: HashMap<PersistenceId, JournalEntity>,
event_log: Vec<JournalEvent>,
persistence_ids: Vec<PersistenceId>,
last_offset: u64,
}
#[derive(Debug, Clone)]
pub struct MemoryJournal {
state: Arc<Mutex<MemoryJournalState>>,
changes: watch::Sender<u64>,
}
impl Default for MemoryJournal {
fn default() -> Self {
let (changes, _receiver) = watch::channel(0);
Self {
state: Arc::new(Mutex::new(MemoryJournalState::default())),
changes,
}
}
}
impl MemoryJournal {
#[must_use]
pub fn new() -> Self {
Self::default()
}
fn notify_queries(&self) {
self.changes
.send_modify(|generation| *generation = generation.wrapping_add(1));
}
}
#[async_trait::async_trait]
impl Journal for MemoryJournal {
async fn append(&self, writes: Vec<AtomicWrite>) -> PersistenceResult<Vec<AppendOutcome>> {
let mut state = lock(&self.state, "journal")?;
let mut outcomes = Vec::with_capacity(writes.len());
let mut changed = false;
for write in writes {
let outcome = append_write(&mut state, write);
changed |= outcome == AppendOutcome::Accepted;
outcomes.push(outcome);
}
drop(state);
if changed {
self.notify_queries();
}
Ok(outcomes)
}
async fn append_one(&self, write: AtomicWrite) -> PersistenceResult<AppendOutcome> {
let mut state = lock(&self.state, "journal")?;
let outcome = append_write(&mut state, write);
drop(state);
if outcome == AppendOutcome::Accepted {
self.notify_queries();
}
Ok(outcome)
}
async fn highest_sequence_nr(
&self,
persistence_id: &PersistenceId,
_from_hint: SequenceNr,
) -> PersistenceResult<SequenceNr> {
let state = lock(&self.state, "journal")?;
Ok(state
.entities
.get(persistence_id)
.map_or(SequenceNr::new(0), |entity| entity.highest_sequence_nr))
}
async fn replay(&self, range: ReplayRange) -> PersistenceResult<EventStream> {
if range.from > range.to || range.max == 0 {
return Ok(Box::pin(stream::empty()));
}
let state = lock(&self.state, "journal")?;
let limit = usize::try_from(range.max).unwrap_or(usize::MAX);
let events = state
.entities
.get(&range.persistence_id)
.map(|entity| {
entity
.events
.range(range.from..=range.to)
.take(limit)
.map(|(_, event)| Arc::clone(event))
.collect::<Vec<_>>()
})
.unwrap_or_default();
drop(state);
Ok(Box::pin(stream::iter(
events.into_iter().map(|event| Ok((*event).clone())),
)))
}
async fn delete_to(
&self,
persistence_id: &PersistenceId,
inclusive: SequenceNr,
) -> PersistenceResult<()> {
let mut state = lock(&self.state, "journal")?;
if let Some(entity) = state.entities.get_mut(persistence_id) {
entity
.events
.retain(|sequence_nr, _| *sequence_nr > inclusive);
}
Ok(())
}
}
#[async_trait::async_trait]
impl EventsByPersistenceIdQuery for MemoryJournal {
async fn events_by_persistence_id(
&self,
persistence_id: &PersistenceId,
from_sequence_nr: SequenceNr,
to_sequence_nr: SequenceNr,
mode: QueryMode,
) -> PersistenceResult<QueryStream<EventEnvelope>> {
if from_sequence_nr > to_sequence_nr {
return Ok(Box::pin(stream::empty()));
}
let state = lock(&self.state, "journal")?;
let boundary = state.last_offset;
let snapshot = state
.event_log
.iter()
.filter(|entry| {
entry.event.persistence_id == *persistence_id
&& entry.event.sequence_nr >= from_sequence_nr
&& entry.event.sequence_nr <= to_sequence_nr
&& is_current_event(&state, entry)
})
.map(event_envelope)
.collect::<VecDeque<_>>();
drop(state);
if mode == QueryMode::Current {
return Ok(Box::pin(stream::iter(snapshot.into_iter().map(Ok))));
}
let cursor = PersistenceIdEventCursor {
state: Arc::clone(&self.state),
changes: self.changes.subscribe(),
persistence_id: persistence_id.clone(),
from_sequence_nr,
to_sequence_nr,
offset: boundary,
snapshot,
};
Ok(Box::pin(stream::unfold(cursor, next_persistence_id_event)))
}
}
#[async_trait::async_trait]
impl EventsByTagQuery for MemoryJournal {
async fn events_by_tag(
&self,
tag: &Tag,
offset: Offset,
mode: QueryMode,
) -> PersistenceResult<QueryStream<EventEnvelope>> {
let resume_after = sequence_offset(offset)?;
let state = lock(&self.state, "journal")?;
let boundary = state.last_offset;
let snapshot = state
.event_log
.iter()
.filter(|entry| {
entry.offset > resume_after
&& entry.event.tags.contains(tag)
&& is_current_event(&state, entry)
})
.map(event_envelope)
.collect::<VecDeque<_>>();
drop(state);
if mode == QueryMode::Current {
return Ok(Box::pin(stream::iter(snapshot.into_iter().map(Ok))));
}
let cursor = TagEventCursor {
state: Arc::clone(&self.state),
changes: self.changes.subscribe(),
tag: tag.clone(),
offset: boundary,
snapshot,
};
Ok(Box::pin(stream::unfold(cursor, next_tag_event)))
}
}
#[async_trait::async_trait]
impl PersistenceIdsQuery for MemoryJournal {
async fn persistence_ids(
&self,
mode: QueryMode,
) -> PersistenceResult<QueryStream<PersistenceId>> {
let state = lock(&self.state, "journal")?;
let snapshot = state
.persistence_ids
.iter()
.cloned()
.collect::<VecDeque<_>>();
let cursor_index = state.persistence_ids.len();
drop(state);
if mode == QueryMode::Current {
return Ok(Box::pin(stream::iter(snapshot.into_iter().map(Ok))));
}
let cursor = PersistenceIdsCursor {
state: Arc::clone(&self.state),
changes: self.changes.subscribe(),
index: cursor_index,
snapshot,
};
Ok(Box::pin(stream::unfold(cursor, next_persistence_id)))
}
}
struct PersistenceIdEventCursor {
state: Arc<Mutex<MemoryJournalState>>,
changes: watch::Receiver<u64>,
persistence_id: PersistenceId,
from_sequence_nr: SequenceNr,
to_sequence_nr: SequenceNr,
offset: u64,
snapshot: VecDeque<EventEnvelope>,
}
async fn next_persistence_id_event(
mut cursor: PersistenceIdEventCursor,
) -> Option<(PersistenceResult<EventEnvelope>, PersistenceIdEventCursor)> {
if let Some(envelope) = cursor.snapshot.pop_front() {
return Some((Ok(envelope), cursor));
}
loop {
let (envelope, reached_end) = match scan_persistence_id_event(&mut cursor) {
Ok(result) => result,
Err(error) => return Some((Err(error), cursor)),
};
if let Some(envelope) = envelope {
return Some((Ok(envelope), cursor));
}
if reached_end {
return None;
}
if cursor.changes.changed().await.is_err() {
return None;
}
}
}
struct TagEventCursor {
state: Arc<Mutex<MemoryJournalState>>,
changes: watch::Receiver<u64>,
tag: Tag,
offset: u64,
snapshot: VecDeque<EventEnvelope>,
}
async fn next_tag_event(
mut cursor: TagEventCursor,
) -> Option<(PersistenceResult<EventEnvelope>, TagEventCursor)> {
if let Some(envelope) = cursor.snapshot.pop_front() {
return Some((Ok(envelope), cursor));
}
loop {
let envelope = match scan_tag_event(&mut cursor) {
Ok(envelope) => envelope,
Err(error) => return Some((Err(error), cursor)),
};
if let Some(envelope) = envelope {
return Some((Ok(envelope), cursor));
}
if cursor.changes.changed().await.is_err() {
return None;
}
}
}
struct PersistenceIdsCursor {
state: Arc<Mutex<MemoryJournalState>>,
changes: watch::Receiver<u64>,
index: usize,
snapshot: VecDeque<PersistenceId>,
}
async fn next_persistence_id(
mut cursor: PersistenceIdsCursor,
) -> Option<(PersistenceResult<PersistenceId>, PersistenceIdsCursor)> {
if let Some(persistence_id) = cursor.snapshot.pop_front() {
return Some((Ok(persistence_id), cursor));
}
loop {
let persistence_id = match scan_persistence_id(&mut cursor) {
Ok(persistence_id) => persistence_id,
Err(error) => return Some((Err(error), cursor)),
};
if let Some(persistence_id) = persistence_id {
return Some((Ok(persistence_id), cursor));
}
if cursor.changes.changed().await.is_err() {
return None;
}
}
}
#[derive(Debug, Default)]
pub struct MemorySnapshotStore {
snapshots: Mutex<HashMap<PersistenceId, BTreeMap<SequenceNr, SelectedSnapshot>>>,
}
impl MemorySnapshotStore {
#[must_use]
pub fn new() -> Self {
Self::default()
}
}
#[async_trait::async_trait]
impl SnapshotStore for MemorySnapshotStore {
async fn load(
&self,
persistence_id: &PersistenceId,
criteria: &SnapshotCriteria,
) -> PersistenceResult<Option<SelectedSnapshot>> {
let snapshots = lock(&self.snapshots, "snapshot store")?;
Ok(snapshots.get(persistence_id).and_then(|by_sequence_nr| {
by_sequence_nr
.values()
.filter(|snapshot| criteria.matches(&snapshot.metadata))
.max_by_key(|snapshot| {
(
snapshot.metadata.sequence_nr,
snapshot.metadata.timestamp_ms,
)
})
.cloned()
}))
}
async fn save(
&self,
metadata: SnapshotMetadata,
adapter_manifest: String,
state: SerializedPayload,
) -> PersistenceResult<()> {
let mut snapshots = lock(&self.snapshots, "snapshot store")?;
let persistence_id = metadata.persistence_id.clone();
snapshots.entry(persistence_id).or_default().insert(
metadata.sequence_nr,
SelectedSnapshot {
metadata,
adapter_manifest,
state,
},
);
Ok(())
}
async fn delete(&self, metadata: SnapshotMetadata) -> PersistenceResult<()> {
let mut snapshots = lock(&self.snapshots, "snapshot store")?;
if let Some(by_sequence_nr) = snapshots.get_mut(&metadata.persistence_id)
&& by_sequence_nr
.get(&metadata.sequence_nr)
.is_some_and(|snapshot| snapshot.metadata == metadata)
{
by_sequence_nr.remove(&metadata.sequence_nr);
}
Ok(())
}
async fn delete_matching(
&self,
persistence_id: &PersistenceId,
criteria: &SnapshotCriteria,
) -> PersistenceResult<()> {
let mut snapshots = lock(&self.snapshots, "snapshot store")?;
if let Some(by_sequence_nr) = snapshots.get_mut(persistence_id) {
by_sequence_nr.retain(|_, snapshot| !criteria.matches(&snapshot.metadata));
}
Ok(())
}
}
#[derive(Debug, Clone)]
struct DurableEntry {
versioned_state: VersionedState,
change_offset: u64,
change_timestamp_ms: i64,
change_tag: Option<Tag>,
}
#[derive(Debug, Default)]
struct MemoryDurableState {
entries: HashMap<PersistenceId, DurableEntry>,
last_offset: u64,
}
#[derive(Debug, Clone)]
pub struct MemoryDurableStateStore {
state: Arc<Mutex<MemoryDurableState>>,
changes: watch::Sender<u64>,
}
impl Default for MemoryDurableStateStore {
fn default() -> Self {
let (changes, _receiver) = watch::channel(0);
Self {
state: Arc::new(Mutex::new(MemoryDurableState::default())),
changes,
}
}
}
impl MemoryDurableStateStore {
#[must_use]
pub fn new() -> Self {
Self::default()
}
fn notify_queries(&self) {
self.changes
.send_modify(|generation| *generation = generation.wrapping_add(1));
}
}
#[async_trait::async_trait]
impl DurableStateStore for MemoryDurableStateStore {
async fn get(&self, persistence_id: &PersistenceId) -> PersistenceResult<VersionedState> {
let state = lock(&self.state, "durable-state store")?;
Ok(state
.entries
.get(persistence_id)
.map_or_else(VersionedState::default, |entry| {
entry.versioned_state.clone()
}))
}
async fn upsert(
&self,
persistence_id: &PersistenceId,
new_revision: Revision,
state_payload: SerializedPayload,
tag: Option<Tag>,
) -> PersistenceResult<()> {
let mut state = lock(&self.state, "durable-state store")?;
validate_revision(&state.entries, persistence_id, new_revision)?;
let change_offset = next_offset(state.last_offset, "durable-state query")?;
state.last_offset = change_offset;
state.entries.insert(
persistence_id.clone(),
DurableEntry {
versioned_state: VersionedState {
state: Some(state_payload),
revision: new_revision,
tag: tag.clone(),
},
change_offset,
change_timestamp_ms: timestamp_ms(),
change_tag: tag,
},
);
drop(state);
self.notify_queries();
Ok(())
}
async fn delete(
&self,
persistence_id: &PersistenceId,
new_revision: Revision,
) -> PersistenceResult<()> {
let mut state = lock(&self.state, "durable-state store")?;
validate_revision(&state.entries, persistence_id, new_revision)?;
let change_offset = next_offset(state.last_offset, "durable-state query")?;
let change_tag = state
.entries
.get(persistence_id)
.and_then(|entry| entry.change_tag.clone());
state.last_offset = change_offset;
state.entries.insert(
persistence_id.clone(),
DurableEntry {
versioned_state: VersionedState {
state: None,
revision: new_revision,
tag: None,
},
change_offset,
change_timestamp_ms: timestamp_ms(),
change_tag,
},
);
drop(state);
self.notify_queries();
Ok(())
}
}
#[async_trait::async_trait]
impl DurableStateChangesQuery for MemoryDurableStateStore {
async fn changes(
&self,
tag: &Tag,
offset: Offset,
mode: QueryMode,
) -> PersistenceResult<QueryStream<DurableStateChange>> {
let resume_after = sequence_offset(offset)?;
let state = lock(&self.state, "durable-state store")?;
let boundary = state.last_offset;
let mut snapshot = state
.entries
.iter()
.filter(|(_, entry)| {
entry.change_offset > resume_after && entry.change_tag.as_ref() == Some(tag)
})
.map(|(persistence_id, entry)| durable_change(persistence_id, entry))
.collect::<Vec<_>>();
snapshot.sort_by_key(DurableStateChange::offset);
let snapshot = VecDeque::from(snapshot);
drop(state);
if mode == QueryMode::Current {
return Ok(Box::pin(stream::iter(snapshot.into_iter().map(Ok))));
}
let cursor = DurableStateCursor {
state: Arc::clone(&self.state),
changes: self.changes.subscribe(),
tag: tag.clone(),
offset: boundary,
snapshot,
};
Ok(Box::pin(stream::unfold(cursor, next_durable_change)))
}
}
struct DurableStateCursor {
state: Arc<Mutex<MemoryDurableState>>,
changes: watch::Receiver<u64>,
tag: Tag,
offset: u64,
snapshot: VecDeque<DurableStateChange>,
}
async fn next_durable_change(
mut cursor: DurableStateCursor,
) -> Option<(PersistenceResult<DurableStateChange>, DurableStateCursor)> {
if let Some(change) = cursor.snapshot.pop_front() {
return Some((Ok(change), cursor));
}
loop {
let change = match scan_durable_change(&mut cursor) {
Ok(change) => change,
Err(error) => return Some((Err(error), cursor)),
};
if let Some(change) = change {
return Some((Ok(change), cursor));
}
if cursor.changes.changed().await.is_err() {
return None;
}
}
}
fn scan_persistence_id_event(
cursor: &mut PersistenceIdEventCursor,
) -> PersistenceResult<(Option<EventEnvelope>, bool)> {
let state = lock(&cursor.state, "journal")?;
let after = cursor.offset;
let mut envelope = None;
for entry in state.event_log.iter().filter(|entry| entry.offset > after) {
cursor.offset = entry.offset;
if entry.event.persistence_id == cursor.persistence_id
&& entry.event.sequence_nr >= cursor.from_sequence_nr
&& entry.event.sequence_nr <= cursor.to_sequence_nr
&& is_current_event(&state, entry)
{
envelope = Some(event_envelope(entry));
break;
}
}
let reached_end = cursor.to_sequence_nr != SequenceNr::new(u64::MAX)
&& state
.entities
.get(&cursor.persistence_id)
.map_or(cursor.to_sequence_nr == SequenceNr::new(0), |entity| {
entity.highest_sequence_nr >= cursor.to_sequence_nr
});
if envelope.is_none() {
cursor.offset = state.last_offset;
}
Ok((envelope, reached_end))
}
fn scan_tag_event(cursor: &mut TagEventCursor) -> PersistenceResult<Option<EventEnvelope>> {
let state = lock(&cursor.state, "journal")?;
let after = cursor.offset;
let mut envelope = None;
for entry in state.event_log.iter().filter(|entry| entry.offset > after) {
cursor.offset = entry.offset;
if entry.event.tags.contains(&cursor.tag) && is_current_event(&state, entry) {
envelope = Some(event_envelope(entry));
break;
}
}
if envelope.is_none() {
cursor.offset = state.last_offset;
}
Ok(envelope)
}
fn scan_persistence_id(
cursor: &mut PersistenceIdsCursor,
) -> PersistenceResult<Option<PersistenceId>> {
let state = lock(&cursor.state, "journal")?;
let persistence_id = state.persistence_ids.get(cursor.index).cloned();
if persistence_id.is_some() {
cursor.index += 1;
}
Ok(persistence_id)
}
fn scan_durable_change(
cursor: &mut DurableStateCursor,
) -> PersistenceResult<Option<DurableStateChange>> {
let state = lock(&cursor.state, "durable-state store")?;
let change = state
.entries
.iter()
.filter(|(_, entry)| {
entry.change_offset > cursor.offset && entry.change_tag.as_ref() == Some(&cursor.tag)
})
.min_by_key(|(_, entry)| entry.change_offset)
.map(|(persistence_id, entry)| durable_change(persistence_id, entry));
if let Some(change) = &change {
cursor.offset = match change.offset() {
Offset::Sequence(value) => value,
_ => state.last_offset,
};
} else {
cursor.offset = state.last_offset;
}
Ok(change)
}
fn append_write(state: &mut MemoryJournalState, write: AtomicWrite) -> AppendOutcome {
let persistence_id = write.persistence_id().clone();
let highest_sequence_nr = state
.entities
.get(&persistence_id)
.map_or(SequenceNr::new(0), |entity| entity.highest_sequence_nr);
let first_sequence_nr = write.events()[0].sequence_nr;
let Some(expected) = highest_sequence_nr.as_u64().checked_add(1) else {
return AppendOutcome::Rejected {
reason: format!(
"persistence id {persistence_id} already reached the maximum sequence number"
),
};
};
if first_sequence_nr != SequenceNr::new(expected) {
return AppendOutcome::Rejected {
reason: format!(
"expected first sequence number {expected} for {persistence_id}, got {first_sequence_nr}"
),
};
}
let Ok(event_count) = u64::try_from(write.events().len()) else {
return AppendOutcome::Rejected {
reason: "atomic write contains too many events for query offsets".into(),
};
};
let Some(last_offset) = state.last_offset.checked_add(event_count) else {
return AppendOutcome::Rejected {
reason: "in-memory journal query offset exhausted".into(),
};
};
let is_new_persistence_id = highest_sequence_nr == SequenceNr::new(0);
let events = write
.into_events()
.into_iter()
.map(Arc::new)
.collect::<Vec<_>>();
let last_sequence_nr = events[events.len() - 1].sequence_nr;
let entity = state.entities.entry(persistence_id.clone()).or_default();
for event in &events {
entity.events.insert(event.sequence_nr, Arc::clone(event));
}
entity.highest_sequence_nr = last_sequence_nr;
for event in events {
state.last_offset += 1;
state.event_log.push(JournalEvent {
offset: state.last_offset,
event,
});
}
debug_assert_eq!(state.last_offset, last_offset);
if is_new_persistence_id {
state.persistence_ids.push(persistence_id);
}
AppendOutcome::Accepted
}
fn validate_revision(
entries: &HashMap<PersistenceId, DurableEntry>,
persistence_id: &PersistenceId,
new_revision: Revision,
) -> PersistenceResult<()> {
let stored = entries
.get(persistence_id)
.map_or(Revision::new(0), |entry| entry.versioned_state.revision);
let expected = stored
.as_u64()
.checked_add(1)
.map(Revision::new)
.ok_or_else(|| PersistenceError::RevisionExhausted {
persistence_id: persistence_id.clone(),
})?;
if new_revision != expected {
return Err(PersistenceError::RevisionConflict {
persistence_id: persistence_id.clone(),
expected,
actual: new_revision,
});
}
Ok(())
}
fn event_envelope(entry: &JournalEvent) -> EventEnvelope {
EventEnvelope {
offset: Offset::Sequence(entry.offset),
persistence_id: entry.event.persistence_id.clone(),
sequence_nr: entry.event.sequence_nr,
timestamp_ms: entry.event.timestamp_ms,
adapter_manifest: entry.event.adapter_manifest.clone(),
payload: entry.event.payload.clone(),
metadata: entry.event.metadata.clone(),
tags: entry.event.tags.clone(),
}
}
fn durable_change(persistence_id: &PersistenceId, entry: &DurableEntry) -> DurableStateChange {
let offset = Offset::Sequence(entry.change_offset);
match &entry.versioned_state.state {
Some(state) => DurableStateChange::Updated(UpdatedDurableState {
offset,
persistence_id: persistence_id.clone(),
revision: entry.versioned_state.revision,
state: state.clone(),
timestamp_ms: entry.change_timestamp_ms,
}),
None => DurableStateChange::Deleted(DeletedDurableState {
offset,
persistence_id: persistence_id.clone(),
revision: entry.versioned_state.revision,
timestamp_ms: entry.change_timestamp_ms,
}),
}
}
fn is_current_event(state: &MemoryJournalState, entry: &JournalEvent) -> bool {
state
.entities
.get(&entry.event.persistence_id)
.and_then(|entity| entity.events.get(&entry.event.sequence_nr))
.is_some_and(|event| Arc::ptr_eq(event, &entry.event))
}
fn sequence_offset(offset: Offset) -> PersistenceResult<u64> {
match offset {
Offset::NoOffset => Ok(0),
Offset::Sequence(value) => Ok(value),
other => Err(PersistenceError::Failure(format!(
"the in-memory backend resumes only from Offset::Sequence positions, got {other:?}"
))),
}
}
fn next_offset(current: u64, name: &str) -> PersistenceResult<u64> {
current
.checked_add(1)
.ok_or_else(|| PersistenceError::Failure(format!("in-memory {name} offset exhausted")))
}
fn timestamp_ms() -> i64 {
let millis = SystemTime::now()
.duration_since(UNIX_EPOCH)
.unwrap_or_default()
.as_millis();
i64::try_from(millis).unwrap_or(i64::MAX)
}
fn memory_lock_error(name: &str) -> PersistenceError {
PersistenceError::Failure(format!("in-memory {name} lock was poisoned"))
}
fn lock<'a, T>(mutex: &'a Mutex<T>, name: &str) -> PersistenceResult<MutexGuard<'a, T>> {
mutex.lock().map_err(|_| memory_lock_error(name))
}