protected Receive Replaying(int limit)
{
return(message => message.Match()
.With <ReplayedMessage>(replayed =>
{
var seqNr = replayed.Persistent.SequenceNr;
Buffer.Add(new EventEnvelope(
offset: new Sequence(seqNr),
persistenceId: PersistenceId,
sequenceNr: seqNr,
@event: replayed.Persistent.Payload,
timestamp: replayed.Persistent.Timestamp));
CurrentSequenceNr = seqNr + 1;
Buffer.DeliverBuffer(TotalDemand);
})
.With <RecoverySuccess>(success =>
{
Log.Debug("replay completed for persistenceId [{0}], currSeqNo [{1}]", PersistenceId, CurrentSequenceNr);
ReceiveRecoverySuccess(success.HighestSequenceNr);
})
.With <ReplayMessagesFailure>(failure =>
{
Log.Debug("replay failed for persistenceId [{0}], due to [{1}]", PersistenceId, failure.Cause.Message);
Buffer.DeliverBuffer(TotalDemand);
OnErrorThenStop(failure.Cause);
})
.With <Request>(_ => Buffer.DeliverBuffer(TotalDemand))
.With <EventsByPersistenceIdPublisher.Continue>(() => { }) // skip during replay
.With <EventAppended>(() => { }) // skip during replay
.With <Cancel>(_ => Context.Stop(Self))
.WasHandled);
}
private bool Active(object message) => message.Match()
.With <CurrentPersistenceIds>(current =>
{
_buffer.AddRange(current.AllPersistenceIds);
_buffer.DeliverBuffer(TotalDemand);
if (!_liveQuery && _buffer.IsEmpty)
{
OnCompleteThenStop();
}
})
.With <PersistenceIdAdded>(added =>
{
if (_liveQuery)
{
_buffer.Add(added.PersistenceId);
_buffer.DeliverBuffer(TotalDemand);
}
})
.With <Request>(_ =>
{
_buffer.DeliverBuffer(TotalDemand);
if (!_liveQuery && _buffer.IsEmpty)
{
OnCompleteThenStop();
}
})
.With <Cancel>(_ => Context.Stop(Self))
.WasHandled;
private bool Initializing(object message)
{
switch (message)
{
case CurrentPersistenceIds current:
_buffer.AddRange(current.AllPersistenceIds);
_buffer.DeliverBuffer(TotalDemand);
if (_buffer.IsEmpty)
{
OnCompleteThenStop();
return(true);
}
Become(Active);
Stash.UnstashAll();
return(true);
case Cancel _:
Context.Stop(Self);
return(true);
default:
Stash.Stash();
return(true);
}
}
private bool Initializing(object message)
{
switch (message)
{
case CurrentPersistenceIds current:
_lastOrderingOffset = current.HighestOrderingNumber;
_buffer.AddRange(current.AllPersistenceIds);
_buffer.DeliverBuffer(TotalDemand);
Become(Active);
Stash.UnstashAll();
return(true);
case Continue _:
return(true);
case Cancel _:
Context.Stop(Self);
return(true);
default:
Stash.Stash();
return(true);
}
}
protected Receive Replaying(int limit)
{
return(message => message.Match()
.With <ReplayedTaggedMessage>(replayed =>
{
Buffer.Add(new EventEnvelope(
offset: replayed.Offset,
persistenceId: replayed.Persistent.PersistenceId,
sequenceNr: replayed.Persistent.SequenceNr,
@event: replayed.Persistent.Payload));
CurrentOffset = replayed.Offset;
Buffer.DeliverBuffer(TotalDemand);
})
.With <RecoverySuccess>(success =>
{
Log.Debug("replay completed for tag [{0}], currOffset [{1}]", Tag, CurrentOffset);
ReceiveRecoverySuccess(success.HighestSequenceNr);
})
.With <ReplayMessagesFailure>(failure =>
{
Log.Debug("replay failed for tag [{0}], due to [{1}]", Tag, failure.Cause.Message);
Buffer.DeliverBuffer(TotalDemand);
OnErrorThenStop(failure.Cause);
})
.With <Request>(_ => Buffer.DeliverBuffer(TotalDemand))
.With <EventsByTagPublisher.Continue>(() => { })
.With <TaggedEventAppended>(() => { })
.With <Cancel>(() => Context.Stop(Self))
.WasHandled);
}
private bool Replaying(object message)
{
switch (message)
{
case ReplayedEvent replayed:
_buffer.Add(new EventEnvelope(
offset: new Sequence(replayed.Offset),
persistenceId: replayed.Persistent.PersistenceId,
sequenceNr: replayed.Persistent.SequenceNr,
@event: replayed.Persistent.Payload));
_currentOffset = replayed.Offset;
_buffer.DeliverBuffer(TotalDemand);
return(true);
case EventReplaySuccess success:
_log.Debug("event replay completed, currOffset [{0}]", _currentOffset);
ReceiveRecoverySuccess(success.HighestSequenceNr);
return(true);
case EventReplayFailure failure:
_log.Debug("event replay failed, due to [{0}]", failure.Cause.Message);
_buffer.DeliverBuffer(TotalDemand);
OnErrorThenStop(failure.Cause);
return(true);
case ReplayedAllEvents _:
_completed = true;
if (_buffer.IsEmpty)
{
OnCompleteThenStop();
}
_buffer.DeliverBuffer(TotalDemand);
return(true);
case Request _:
_buffer.DeliverBuffer(TotalDemand);
return(true);
case Continue _:
return(true);
case Cancel _:
Context.Stop(Self);
return(true);
default:
return(false);
}
}
