use std::{
collections::VecDeque,
panic::{AssertUnwindSafe, catch_unwind},
sync::{
Arc, LazyLock,
atomic::{AtomicU64, Ordering},
},
time::{Duration, Instant, SystemTime, UNIX_EPOCH},
};
use datum::{
RestartSettings, Topic, TopicOverflow,
actor::{Actor, ActorProcessingErr, ActorRef, Message},
};
use futures_util::StreamExt;
use tokio::sync::oneshot;
use super::{
EventSourcedBehavior, EventSourcedHandle, EventSourcedRuntime, EventSourcedSignal,
EventSourcedState, PublishedEvent, Recovery, RetentionCriteria, SnapshotSelection,
effect::{ChainedEffect, Effect, EventWithMetadata, MainEffect},
};
use crate::{
AppendOutcome, AtomicWrite, EventAdapter, PersistenceError, PersistenceResult, ReplayRange,
SequenceNr, SerializedPayload, SerializerCatalog, SnapshotCriteria, SnapshotMetadata,
StateAdapter, StoredEvent,
};
static NEXT_WRITER_ID: AtomicU64 = AtomicU64::new(1);
static WRITER_STARTUP_NANOS: LazyLock<u128> = LazyLock::new(|| {
SystemTime::now()
.duration_since(UNIX_EPOCH)
.map(|duration| duration.as_nanos())
.unwrap_or_default()
});
static BACKOFF_RANDOM_SEED: AtomicU64 = AtomicU64::new(0x517c_c1b7_2722_0a95);
pub(crate) fn next_writer_uuid() -> String {
format!(
"datum-persistence-{}-{}-{}",
std::process::id(),
*WRITER_STARTUP_NANOS,
NEXT_WRITER_ID.fetch_add(1, Ordering::Relaxed)
)
}
pub(crate) struct EventCodec<E, J> {
adapter: Arc<dyn EventAdapter<E, J>>,
catalog: Arc<SerializerCatalog<J>>,
}
impl<E, J> EventCodec<E, J> {
pub(crate) fn new<A>(adapter: A, catalog: SerializerCatalog<J>) -> Self
where
A: EventAdapter<E, J>,
{
Self {
adapter: Arc::new(adapter),
catalog: Arc::new(catalog),
}
}
}
pub(crate) trait StateCodec<S>: Send + Sync + 'static {
fn encode(&self, state: &S) -> PersistenceResult<(String, SerializedPayload)>;
fn decode(&self, adapter_manifest: &str, state: &SerializedPayload) -> PersistenceResult<S>;
}
pub(crate) struct AdaptedStateCodec<S, J> {
adapter: Arc<dyn StateAdapter<S, J>>,
catalog: SerializerCatalog<J>,
}
impl<S, J> AdaptedStateCodec<S, J> {
pub(crate) fn new<A>(adapter: A, catalog: SerializerCatalog<J>) -> Self
where
A: StateAdapter<S, J>,
{
Self {
adapter: Arc::new(adapter),
catalog,
}
}
}
impl<S, J> StateCodec<S> for AdaptedStateCodec<S, J>
where
S: 'static,
J: 'static,
{
fn encode(&self, state: &S) -> PersistenceResult<(String, SerializedPayload)> {
let (adapter_manifest, journal_state) = self.adapter.to_journal(state)?;
let frame = self.catalog.encode(&journal_state)?;
Ok((adapter_manifest, frame))
}
fn decode(&self, adapter_manifest: &str, state: &SerializedPayload) -> PersistenceResult<S> {
let journal_state = self.catalog.decode(state)?;
self.adapter.from_journal(adapter_manifest, journal_state)
}
}
pub struct EventSourcedMessage<C, S>(RuntimeMessage<C, S>);
impl<C, S> EventSourcedMessage<C, S> {
#[must_use]
pub fn command(command: C) -> Self {
Self(RuntimeMessage::Command(command))
}
pub(crate) fn get_state(reply: oneshot::Sender<EventSourcedState<S>>) -> Self {
Self(RuntimeMessage::GetState(reply))
}
}
enum RuntimeMessage<C, S> {
Recover,
Command(C),
GetState(oneshot::Sender<EventSourcedState<S>>),
BackoffElapsed,
RetentionSignal(EventSourcedSignal),
RetentionCleanupFinished,
}
pub(crate) struct EventSourcedActor<C, E: Send + Sync + 'static, S, J> {
behavior: EventSourcedBehavior<C, E, S, J>,
runtime: EventSourcedRuntime,
topic: Option<Topic<PublishedEvent<E>>>,
}
pub(crate) struct RuntimeState<C, S> {
state: S,
sequence_nr: SequenceNr,
manual_stash: VecDeque<C>,
backoff_stash: VecDeque<C>,
unstash_remaining: usize,
retention_in_flight: bool,
phase: RuntimePhase,
backoff: PersistenceBackoff,
}
#[derive(Clone, Copy, PartialEq, Eq)]
enum RuntimePhase {
Running,
BackingOff,
}
struct PersistenceBackoff {
failures: u32,
restarts_in_window: usize,
window_started: Instant,
}
struct RetentionTaskGuard<C: Message, S: Send + 'static> {
actor: ActorRef<EventSourcedMessage<C, S>>,
}
impl<C: Message, S: Send + 'static> Drop for RetentionTaskGuard<C, S> {
fn drop(&mut self) {
let _ = self.actor.cast(EventSourcedMessage(
RuntimeMessage::RetentionCleanupFinished,
));
}
}
impl PersistenceBackoff {
fn new() -> Self {
Self {
failures: 0,
restarts_in_window: 0,
window_started: Instant::now(),
}
}
fn reset(&mut self) {
self.failures = 0;
self.restarts_in_window = 0;
self.window_started = Instant::now();
}
fn next_delay(&mut self, settings: &RestartSettings) -> Option<Duration> {
let now = Instant::now();
if now.duration_since(self.window_started) > settings.max_restarts_within() {
self.reset();
}
if self.restarts_in_window >= settings.max_restarts() {
return None;
}
let factor = 1_u32.checked_shl(self.failures.min(31)).unwrap_or(u32::MAX);
let base = settings
.min_backoff()
.checked_mul(factor)
.unwrap_or(settings.max_backoff())
.min(settings.max_backoff());
self.failures = self.failures.saturating_add(1);
self.restarts_in_window += 1;
if settings.random_factor() == 0.0 || base.is_zero() {
Some(base)
} else {
let jitter = base.mul_f64(next_random_fraction() * settings.random_factor());
Some(base.saturating_add(jitter))
}
}
}
pub(crate) async fn spawn<C, E, S, J>(
behavior: EventSourcedBehavior<C, E, S, J>,
mut runtime: EventSourcedRuntime,
) -> PersistenceResult<EventSourcedHandle<C, E, S>>
where
C: Message,
E: Send + Sync + 'static,
S: Clone + Send + Sync + 'static,
J: Send + 'static,
{
if behavior.event_codec.is_none() {
return Err(PersistenceError::Serialization(
"event adapter and serializer catalog must be configured before spawn".into(),
));
}
if let RetentionCriteria::SnapshotEvery { every, keep, .. } = behavior.retention {
if every == 0 {
return Err(PersistenceError::Rejected(
"snapshot frequency must be greater than zero".into(),
));
}
if keep == 0 {
return Err(PersistenceError::Rejected(
"snapshot retention count must be greater than zero".into(),
));
}
}
if runtime.writer_uuid.is_none() {
runtime.writer_uuid = Some(next_writer_uuid());
}
let topic = if behavior.publish_events {
Some(
Topic::new(runtime.topic_capacity, TopicOverflow::Dropping).map_err(|error| {
PersistenceError::Failure(format!("published-event topic failed to start: {error}"))
})?,
)
} else {
None
};
let initial_state = RuntimeState {
state: behavior.empty_state.clone(),
sequence_nr: SequenceNr::new(0),
manual_stash: VecDeque::new(),
backoff_stash: VecDeque::new(),
unstash_remaining: 0,
retention_in_flight: false,
phase: RuntimePhase::Running,
backoff: PersistenceBackoff::new(),
};
let actor = EventSourcedActor {
behavior,
runtime,
topic: topic.clone(),
};
let (control, _control_join) =
Actor::spawn(None, actor, initial_state)
.await
.map_err(|error| {
PersistenceError::Failure(format!("event-sourced actor failed to spawn: {error}"))
})?;
Ok(EventSourcedHandle {
control,
published_events: topic,
})
}
impl<C, E, S, J> Actor for EventSourcedActor<C, E, S, J>
where
C: Message,
E: Send + Sync + 'static,
S: Clone + Send + Sync + 'static,
J: Send + 'static,
{
type Msg = EventSourcedMessage<C, S>;
type State = RuntimeState<C, S>;
type Arguments = RuntimeState<C, S>;
async fn pre_start(
&self,
myself: ActorRef<Self::Msg>,
state: Self::Arguments,
) -> Result<Self::State, ActorProcessingErr> {
myself
.cast(EventSourcedMessage(RuntimeMessage::Recover))
.map_err(|error| {
Box::new(PersistenceError::Failure(format!(
"failed to enqueue initial recovery: {error}"
))) as ActorProcessingErr
})?;
Ok(state)
}
async fn handle(
&self,
myself: ActorRef<Self::Msg>,
message: Self::Msg,
state: &mut Self::State,
) -> Result<(), ActorProcessingErr> {
if let Err(error) = self.handle_runtime_message(&myself, message, state).await {
myself.stop(Some(error.to_string()));
}
Ok(())
}
async fn post_stop(
&self,
_myself: ActorRef<Self::Msg>,
_state: &mut Self::State,
) -> Result<(), ActorProcessingErr> {
self.close_topic();
Ok(())
}
}
impl<C, E, S, J> EventSourcedActor<C, E, S, J>
where
C: Message,
E: Send + Sync + 'static,
S: Clone + Send + Sync + 'static,
J: Send + 'static,
{
async fn handle_runtime_message(
&self,
myself: &ActorRef<EventSourcedMessage<C, S>>,
message: EventSourcedMessage<C, S>,
state: &mut RuntimeState<C, S>,
) -> Result<(), ActorProcessingErr> {
match message.0 {
RuntimeMessage::Recover => self.recover(state).await.map_err(boxed),
RuntimeMessage::Command(command) => {
if state.phase == RuntimePhase::BackingOff {
state.backoff_stash.push_back(command);
return Ok(());
}
let stop = self.process_commands(command, myself, state).await?;
if stop {
myself.stop(None);
}
Ok(())
}
RuntimeMessage::GetState(reply) => {
let _ = reply.send(EventSourcedState {
state: state.state.clone(),
sequence_nr: state.sequence_nr,
});
Ok(())
}
RuntimeMessage::BackoffElapsed => {
state.phase = RuntimePhase::Running;
self.recover(state).await.map_err(boxed)?;
while state.phase == RuntimePhase::Running {
let Some(command) = state.backoff_stash.pop_front() else {
break;
};
if self.process_commands(command, myself, state).await? {
myself.stop(None);
break;
}
}
Ok(())
}
RuntimeMessage::RetentionSignal(signal) => {
self.signal(&state.state, &signal)?;
Ok(())
}
RuntimeMessage::RetentionCleanupFinished => {
state.retention_in_flight = false;
Ok(())
}
}
}
}
fn boxed(error: PersistenceError) -> ActorProcessingErr {
Box::new(error)
}
enum PersistError {
Rejected {
sequence_nr: SequenceNr,
reason: String,
},
Failed {
sequence_nr: SequenceNr,
error: PersistenceError,
},
Behavior(PersistenceError),
}
struct PendingPublication<E> {
event: E,
sequence_nr: SequenceNr,
timestamp_ms: i64,
tags: Vec<crate::Tag>,
}
enum SnapshotReason {
Predicate,
Retention,
}
impl<C, E, S, J> EventSourcedActor<C, E, S, J>
where
C: Message,
E: Send + Sync + 'static,
S: Clone + Send + Sync + 'static,
J: Send + 'static,
{
async fn recover(&self, state: &mut RuntimeState<C, S>) -> PersistenceResult<()> {
state.state = self.behavior.empty_state.clone();
state.sequence_nr = SequenceNr::new(0);
let result = self.recover_inner(state).await;
match result {
Ok(()) => {
self.signal(&state.state, &EventSourcedSignal::RecoveryCompleted)?;
Ok(())
}
Err(error) => {
let signal_error = error.clone();
let _ = self.signal(
&state.state,
&EventSourcedSignal::RecoveryFailed(signal_error),
);
Err(error)
}
}
}
async fn recover_inner(&self, state: &mut RuntimeState<C, S>) -> PersistenceResult<()> {
let Recovery::Enabled(selection) = self.behavior.recovery else {
state.sequence_nr = self
.runtime
.journal
.highest_sequence_nr(&self.behavior.persistence_id, SequenceNr::new(0))
.await?;
return Ok(());
};
if selection != SnapshotSelection::None
&& let Some(snapshot_store) = &self.runtime.snapshot_store
{
let criteria = selection.criteria();
if let Some(snapshot) = snapshot_store
.load(&self.behavior.persistence_id, &criteria)
.await?
{
let codec = self.behavior.state_codec.as_ref().ok_or_else(|| {
PersistenceError::Serialization(
"a state adapter and serializer catalog are required to recover snapshots"
.into(),
)
})?;
state.state = codec.decode(&snapshot.adapter_manifest, &snapshot.state)?;
state.sequence_nr = snapshot.metadata.sequence_nr;
self.signal(
&state.state,
&EventSourcedSignal::SnapshotRecovered(snapshot.metadata),
)?;
}
}
let highest = self
.runtime
.journal
.highest_sequence_nr(&self.behavior.persistence_id, state.sequence_nr)
.await?;
if state.sequence_nr != SequenceNr::new(u64::MAX) {
let from = SequenceNr::new(state.sequence_nr.as_u64() + 1);
if from <= highest {
let mut replay = self
.runtime
.journal
.replay(ReplayRange {
persistence_id: self.behavior.persistence_id.clone(),
from,
to: highest,
max: u64::MAX,
})
.await?;
while let Some(stored) = replay.next().await {
let stored = stored?;
let codec = self
.behavior
.event_codec
.as_ref()
.expect("spawn validates event codec");
let journal_event = codec.catalog.decode(&stored.payload)?;
let events = codec
.adapter
.from_journal_events(&stored.adapter_manifest, journal_event)?;
for event in events {
state.state = self.apply_event(&state.state, &event)?;
}
state.sequence_nr = stored.sequence_nr;
}
}
}
state.sequence_nr = state.sequence_nr.max(highest);
Ok(())
}
async fn process_commands(
&self,
mut command: C,
myself: &ActorRef<EventSourcedMessage<C, S>>,
state: &mut RuntimeState<C, S>,
) -> Result<bool, ActorProcessingErr> {
loop {
let effect = catch_unwind(AssertUnwindSafe(|| {
(self.behavior.command_handler)(&state.state, command)
}))
.map_err(|panic| boxed(handler_panic("command handler", panic)))?;
let effect = Self::resolve_async(effect).await;
let mut stop = false;
match effect.main {
MainEffect::Persist(events) if events.is_empty() => {
stop = self.apply_chained(effect.chained, state)?;
}
MainEffect::Persist(events) => match self.persist(events, myself, state).await {
Ok(()) => {
state.backoff.reset();
stop = self.apply_chained(effect.chained, state)?;
}
Err(PersistError::Rejected {
sequence_nr,
reason,
}) => {
self.signal(
&state.state,
&EventSourcedSignal::PersistRejected {
sequence_nr,
reason: reason.clone(),
},
)?;
return Err(boxed(PersistenceError::Rejected(reason)));
}
Err(PersistError::Failed { sequence_nr, error }) => {
self.signal(
&state.state,
&EventSourcedSignal::PersistFailed {
sequence_nr,
error: error.clone(),
},
)?;
let Some(settings) = self.behavior.persist_failure_backoff.as_ref() else {
return Err(boxed(error));
};
let Some(delay) = state.backoff.next_delay(settings) else {
return Err(boxed(error));
};
state.phase = RuntimePhase::BackingOff;
std::mem::drop(myself.send_after(delay, || {
EventSourcedMessage(RuntimeMessage::BackoffElapsed)
}));
}
Err(PersistError::Behavior(error)) => return Err(boxed(error)),
},
MainEffect::None => {
stop = self.apply_chained(effect.chained, state)?;
}
MainEffect::Unhandled => {
tracing::debug!(
persistence_id = %self.behavior.persistence_id,
"persistent behavior left a command unhandled"
);
stop = self.apply_chained(effect.chained, state)?;
}
MainEffect::Stash(command) => {
if state.manual_stash.len() < self.behavior.stash_capacity {
state.manual_stash.push_back(command);
stop = self.apply_chained(effect.chained, state)?;
} else {
tracing::warn!(
persistence_id = %self.behavior.persistence_id,
stash_capacity = self.behavior.stash_capacity,
"manual persistence stash is full; dropping newest command"
);
}
}
MainEffect::Async(_) => unreachable!("async effects are resolved before dispatch"),
}
if stop {
return Ok(true);
}
if state.phase == RuntimePhase::BackingOff {
return Ok(false);
}
if state.unstash_remaining > 0 {
state.unstash_remaining -= 1;
if let Some(stashed) = state.manual_stash.pop_front() {
command = stashed;
continue;
} else {
state.unstash_remaining = 0;
}
}
return Ok(false);
}
}
async fn resolve_async(mut effect: Effect<C, E, S>) -> Effect<C, E, S> {
let mut after_async = Vec::new();
loop {
match effect.main {
MainEffect::Async(future) => {
after_async.splice(0..0, effect.chained);
effect = future.await;
}
_ => {
effect.chained.extend(after_async);
return effect;
}
}
}
}
fn apply_chained(
&self,
chained: Vec<ChainedEffect<S>>,
state: &mut RuntimeState<C, S>,
) -> PersistenceResult<bool> {
let mut stop = false;
for effect in chained {
match effect {
ChainedEffect::Run(callback) => {
catch_unwind(AssertUnwindSafe(|| callback(&state.state)))
.map_err(|panic| handler_panic("side effect", panic))?;
}
ChainedEffect::Stop => stop = true,
ChainedEffect::UnstashAll => {
state.unstash_remaining = state.manual_stash.len();
}
}
}
Ok(stop)
}
async fn persist(
&self,
events: Vec<EventWithMetadata<E>>,
myself: &ActorRef<EventSourcedMessage<C, S>>,
state: &mut RuntimeState<C, S>,
) -> Result<(), PersistError> {
let first_sequence_nr = state
.sequence_nr
.as_u64()
.checked_add(1)
.map(SequenceNr::new)
.ok_or_else(|| PersistError::Rejected {
sequence_nr: state.sequence_nr,
reason: "event sequence number is exhausted".into(),
})?;
let codec = self
.behavior
.event_codec
.as_ref()
.expect("spawn validates event codec");
let mut publications = self
.topic
.as_ref()
.map(|_| Vec::with_capacity(events.len()));
let mut staged_state = None;
let mut stored_events = Vec::with_capacity(events.len());
let mut snapshot_reason = None;
let mut last_sequence_nr = first_sequence_nr;
for (index, event) in events.into_iter().enumerate() {
let offset = u64::try_from(index).map_err(|error| PersistError::Rejected {
sequence_nr: first_sequence_nr,
reason: format!("event batch is too large: {error}"),
})?;
let sequence_nr = first_sequence_nr
.as_u64()
.checked_add(offset)
.map(SequenceNr::new)
.ok_or_else(|| PersistError::Rejected {
sequence_nr: first_sequence_nr,
reason: "event sequence number is exhausted".into(),
})?;
let current_state = staged_state.as_ref().unwrap_or(&state.state);
let next_state = self
.apply_event(current_state, &event.event)
.map_err(PersistError::Behavior)?;
let retention_match = matches!(
self.behavior.retention,
RetentionCriteria::SnapshotEvery { every, .. }
if sequence_nr.as_u64() % every == 0
);
if retention_match {
snapshot_reason = Some(SnapshotReason::Retention);
} else if snapshot_reason.is_none()
&& (self.behavior.snapshot_when)(&next_state, &event.event, sequence_nr)
{
snapshot_reason = Some(SnapshotReason::Predicate);
}
let (adapter_manifest, journal_event) = codec
.adapter
.to_journal(&event.event)
.map_err(|error| PersistError::Rejected {
sequence_nr,
reason: error.to_string(),
})?;
let payload =
codec
.catalog
.encode(&journal_event)
.map_err(|error| PersistError::Rejected {
sequence_nr,
reason: error.to_string(),
})?;
let timestamp_ms = now_ms();
let tags = (self.behavior.tagger)(&next_state, &event.event);
if let Some(publications) = &mut publications {
publications.push(PendingPublication {
event: event.event,
sequence_nr,
timestamp_ms,
tags: tags.clone(),
});
}
stored_events.push(StoredEvent {
persistence_id: self.behavior.persistence_id.clone(),
sequence_nr,
adapter_manifest,
writer_uuid: self
.runtime
.writer_uuid
.clone()
.expect("spawn assigns a writer uuid"),
timestamp_ms,
metadata: event.metadata,
payload,
tags,
});
staged_state = Some(next_state);
last_sequence_nr = sequence_nr;
}
let write = AtomicWrite::new(stored_events).map_err(|error| PersistError::Rejected {
sequence_nr: first_sequence_nr,
reason: error.to_string(),
})?;
let outcome = self
.runtime
.journal
.append_one(write)
.await
.map_err(|error| PersistError::Failed {
sequence_nr: first_sequence_nr,
error,
})?;
if let AppendOutcome::Rejected { reason } = outcome {
return Err(PersistError::Rejected {
sequence_nr: first_sequence_nr,
reason,
});
}
state.state = staged_state.expect("non-empty event batch was validated");
state.sequence_nr = last_sequence_nr;
if let Some(topic) = self
.topic
.as_ref()
.filter(|topic| topic.subscriber_count() > 0)
{
for item in publications.unwrap_or_default() {
let _ = topic
.publish(PublishedEvent {
persistence_id: self.behavior.persistence_id.clone(),
sequence_nr: item.sequence_nr,
event: item.event,
timestamp_ms: item.timestamp_ms,
tags: item.tags,
})
.await;
}
}
if let Some(reason) = snapshot_reason {
let skip_retention =
matches!(reason, SnapshotReason::Retention) && state.retention_in_flight;
if skip_retention {
tracing::debug!(
persistence_id = %self.behavior.persistence_id,
sequence_nr = state.sequence_nr.as_u64(),
"retention snapshot boundary skipped while cleanup is in flight; the next boundary covers it"
);
} else {
self.save_snapshot(reason, myself, state)
.await
.map_err(PersistError::Behavior)?;
}
}
Ok(())
}
async fn save_snapshot(
&self,
reason: SnapshotReason,
myself: &ActorRef<EventSourcedMessage<C, S>>,
state: &mut RuntimeState<C, S>,
) -> PersistenceResult<()> {
let Some(snapshot_store) = &self.runtime.snapshot_store else {
return Ok(());
};
let metadata = SnapshotMetadata {
persistence_id: self.behavior.persistence_id.clone(),
sequence_nr: state.sequence_nr,
timestamp_ms: now_ms(),
};
let save_result = match &self.behavior.state_codec {
Some(codec) => match codec.encode(&state.state) {
Ok((adapter_manifest, frame)) => {
snapshot_store
.save(metadata.clone(), adapter_manifest, frame)
.await
}
Err(error) => Err(error),
},
None => Err(PersistenceError::Serialization(
"a state adapter and serializer catalog are required to save snapshots".into(),
)),
};
match save_result {
Ok(()) => {
self.signal(
&state.state,
&EventSourcedSignal::SnapshotCompleted(metadata.clone()),
)?;
if matches!(reason, SnapshotReason::Retention) {
self.start_retention_cleanup(
metadata.sequence_nr,
Arc::clone(snapshot_store),
myself,
state,
);
}
}
Err(error) => {
self.signal(
&state.state,
&EventSourcedSignal::SnapshotFailed { metadata, error },
)?;
}
}
Ok(())
}
fn start_retention_cleanup(
&self,
snapshot_sequence_nr: SequenceNr,
snapshot_store: Arc<dyn crate::SnapshotStore>,
myself: &ActorRef<EventSourcedMessage<C, S>>,
state: &mut RuntimeState<C, S>,
) {
let RetentionCriteria::SnapshotEvery {
every,
keep,
delete_events,
} = self.behavior.retention
else {
return;
};
state.retention_in_flight = true;
let retained_window = every.saturating_mul(keep);
let delete_to = SequenceNr::new(
snapshot_sequence_nr
.as_u64()
.saturating_sub(retained_window),
);
let persistence_id = self.behavior.persistence_id.clone();
let journal = Arc::clone(&self.runtime.journal);
let actor = myself.clone();
tokio::spawn(async move {
let _completion = RetentionTaskGuard {
actor: actor.clone(),
};
if delete_events {
match journal.delete_to(&persistence_id, delete_to).await {
Ok(()) => {
if actor
.cast(EventSourcedMessage(RuntimeMessage::RetentionSignal(
EventSourcedSignal::DeleteEventsCompleted(delete_to),
)))
.is_err()
{
return;
}
}
Err(error) => {
let _ = actor.cast(EventSourcedMessage(RuntimeMessage::RetentionSignal(
EventSourcedSignal::DeleteEventsFailed {
to: delete_to,
error,
},
)));
return;
}
}
}
let max_snapshot = if delete_events {
delete_to.as_u64().saturating_sub(1)
} else {
delete_to.as_u64()
};
let criteria = SnapshotCriteria {
min_sequence_nr: SequenceNr::new(0),
max_sequence_nr: SequenceNr::new(max_snapshot),
min_timestamp_ms: i64::MIN,
max_timestamp_ms: i64::MAX,
};
let signal = match snapshot_store
.delete_matching(&persistence_id, &criteria)
.await
{
Ok(()) => EventSourcedSignal::DeleteSnapshotsCompleted(criteria),
Err(error) => EventSourcedSignal::DeleteSnapshotsFailed { criteria, error },
};
let _ = actor.cast(EventSourcedMessage(RuntimeMessage::RetentionSignal(signal)));
});
}
fn close_topic(&self) {
if let Some(topic) = &self.topic {
let _ = topic.close();
}
}
fn apply_event(&self, state: &S, event: &E) -> PersistenceResult<S> {
catch_unwind(AssertUnwindSafe(|| {
(self.behavior.event_handler)(state, event)
}))
.map_err(|panic| handler_panic("event handler", panic))?
}
fn signal(&self, state: &S, signal: &EventSourcedSignal) -> PersistenceResult<()> {
catch_unwind(AssertUnwindSafe(|| {
(self.behavior.signal_handler)(state, signal)
}))
.map_err(|panic| handler_panic("signal handler", panic))
}
}
fn now_ms() -> i64 {
let millis = SystemTime::now()
.duration_since(UNIX_EPOCH)
.unwrap_or(Duration::ZERO)
.as_millis();
i64::try_from(millis).unwrap_or(i64::MAX)
}
fn next_random_fraction() -> f64 {
let mut current = BACKOFF_RANDOM_SEED.load(Ordering::Relaxed);
loop {
let mut next = current;
next ^= next << 13;
next ^= next >> 7;
next ^= next << 17;
match BACKOFF_RANDOM_SEED.compare_exchange_weak(
current,
next,
Ordering::Relaxed,
Ordering::Relaxed,
) {
Ok(_) => return ((next >> 11) as f64) / ((1_u64 << 53) as f64),
Err(observed) => current = observed,
}
}
}
fn handler_panic(
handler: &str,
panic: Box<dyn std::any::Any + Send + 'static>,
) -> PersistenceError {
let message = if let Some(message) = panic.downcast_ref::<&str>() {
(*message).to_owned()
} else if let Some(message) = panic.downcast_ref::<String>() {
message.clone()
} else {
"non-string panic".to_owned()
};
PersistenceError::Failure(format!("{handler} panicked: {message}"))
}
#[cfg(test)]
mod tests {
use super::next_writer_uuid;
#[test]
fn generated_writer_ids_include_process_start_entropy_and_a_sequence() {
let first = next_writer_uuid();
let second = next_writer_uuid();
let parse = |value: &str| {
value
.strip_prefix("datum-persistence-")
.expect("writer id prefix")
.split('-')
.map(str::to_owned)
.collect::<Vec<_>>()
};
let first_parts = parse(&first);
let second_parts = parse(&second);
assert_eq!(first_parts.len(), 3);
assert_eq!(second_parts.len(), 3);
assert_eq!(first_parts[0], second_parts[0]);
assert_eq!(first_parts[1], second_parts[1]);
assert_ne!(first_parts[2], second_parts[2]);
assert!(first_parts[1].parse::<u128>().unwrap() > 0);
}
}