private void HandleReplayMessages(ReplayMessages message) { var context = Context; // Send replayed messages and replay result to persistentActor directly. No need // to resequence replayed messages relative to written and looped messages. ReplayMessagesAsync(message.PersistenceId, message.FromSequenceNr, message.ToSequenceNr, message.Max, p => { if (!p.IsDeleted || message.ReplayDeleted) { foreach (var adaptedRepresentation in AdaptFromJournal(p)) { message.PersistentActor.Tell(new ReplayedMessage(adaptedRepresentation), p.Sender); } } }) .NotifyAboutReplayCompletion(message.PersistentActor) .ContinueWith(t => { if (!t.IsFaulted && CanPublish) { context.System.EventStream.Publish(message); } }, _continuationOptions); }
private void HandleReplayMessages(ReplayMessages msg) { ReplayMessagesAsync(msg.PersistenceId, msg.FromSequenceNr, msg.ToSequenceNr, msg.Max, persistent => { if (!persistent.IsDeleted || msg.ReplayDeleted) msg.PersistentActor.Tell(new ReplayedMessage(persistent), persistent.Sender); }) .NotifyAboutReplayCompletion(msg.PersistentActor) .ContinueWith(t => { if (!t.IsFaulted && CanPublish) Context.System.EventStream.Publish(msg); }); }
private void HandleReplayMessages(ReplayMessages message) { // Send replayed messages and replay result to persistentActor directly. No need // to resequence replayed messages relative to written and looped messages. ReplayMessagesAsync(message.PersistenceId, message.FromSequenceNr, message.ToSequenceNr, message.Max, p => { if (!p.IsDeleted || message.ReplayDeleted) message.PersistentActor.Tell(new ReplayedMessage(p), p.Sender); }) .NotifyAboutReplayCompletion(message.PersistentActor) .ContinueWith(t => { if(!t.IsFaulted && CanPublish) Context.System.EventStream.Publish(message); }, _continuationOptions); }
protected override async Task HandleReplayMessages(ReplayMessages req, OracleCommand command, IActorContext context) { var replaySettings = Setup.ReplayFilterSettings; var replyTo = replaySettings.IsEnabled ? context.ActorOf(ReplayFilter.Props(req.PersistentActor, replaySettings.Mode, replaySettings.WindowSize, replaySettings.MaxOldWriters, replaySettings.IsDebug)) : req.PersistentActor; var persistenceId = req.PersistenceId; NotifyNewPersistenceIdAdded(persistenceId); try { var highestSequenceNr = await ReadHighestSequenceNr(persistenceId, command); var toSequenceNr = Math.Min(req.ToSequenceNr, highestSequenceNr); command.CommandText = ByPersistenceIdSql; command.Parameters.Clear(); AddParameter(command, ":PersistenceId", OracleDbType.NVarchar2, persistenceId); AddParameter(command, ":FromSequenceNr", OracleDbType.Int64, req.FromSequenceNr); AddParameter(command, ":ToSequenceNr", OracleDbType.Int64, toSequenceNr); using (var reader = await command.ExecuteReaderAsync()) { var i = 0L; while (i++ < req.Max && await reader.ReadAsync()) { var persistent = ReadEvent(reader); if (persistent.IsDeleted) { continue; } foreach (var adaptedRepresentation in AdaptFromJournal(persistent)) { replyTo.Tell(new ReplayedMessage(adaptedRepresentation), ActorRefs.NoSender); } } } var response = new RecoverySuccess(highestSequenceNr); replyTo.Tell(response, ActorRefs.NoSender); } catch (Exception cause) { var response = new ReplayMessagesFailure(cause); replyTo.Tell(response, ActorRefs.NoSender); } }
protected IEnumerable <object> LoadFromJournal(string persistenceId, int expectedCount) { var persistenceExtension = Akka.Persistence.Persistence.Instance.Get(GridNode.System) ?? Akka.Persistence.Persistence.Instance.Apply(GridNode.System); var settings = persistenceExtension.Settings; var journal = persistenceExtension.JournalFor(null); var loadMsg = new ReplayMessages(0, long.MaxValue, long.MaxValue, persistenceId, TestActor); journal.Tell(loadMsg); for (int i = 0; i < expectedCount; i++) { yield return(FishForMessage <ReplayedMessage>(m => m.Persistent.PersistenceId == persistenceId).Persistent.Payload); } }
private void HandleReplayMessages(ReplayMessages msg) { ReplayMessagesAsync(msg.PersistenceId, msg.FromSequenceNr, msg.ToSequenceNr, msg.Max, persistent => { if (!persistent.IsDeleted || msg.ReplayDeleted) { msg.PersistentActor.Tell(new ReplayedMessage(persistent), persistent.Sender); } }) .NotifyAboutReplayCompletion(msg.PersistentActor) .ContinueWith(t => { if (!t.IsFaulted && CanPublish) { Context.System.EventStream.Publish(msg); } }); }
private void HandleReplayMessages(ReplayMessages msg) { var context = Context; var sender = Sender; ReplayMessagesAsync(msg.PersistenceId, msg.FromSequenceNr, msg.ToSequenceNr, msg.Max, persistent => { if (!persistent.IsDeleted || msg.ReplayDeleted) { foreach (var adapterRepresentation in AdaptFromJournal(persistent)) { msg.PersistentActor.Tell(new ReplayedMessage(adapterRepresentation), sender); } } }) .NotifyAboutReplayCompletion(msg.PersistentActor) .ContinueWith(t => { if (!t.IsFaulted && CanPublish) context.System.EventStream.Publish(msg); }); }
private void HandleReplayMessages(ReplayMessages msg) { var context = Context; var sender = Sender; ReplayMessagesAsync(msg.PersistenceId, msg.FromSequenceNr, msg.ToSequenceNr, msg.Max, persistent => { if (!persistent.IsDeleted || msg.ReplayDeleted) { foreach (var adapterRepresentation in AdaptFromJournal(persistent)) { msg.PersistentActor.Tell(new ReplayedMessage(adapterRepresentation), sender); } } }) .NotifyAboutReplayCompletion(msg.PersistentActor) .ContinueWith(t => { if (!t.IsFaulted && CanPublish) { context.System.EventStream.Publish(msg); } }); }
private void HandleReplayMessages(ReplayMessages message) { var replyTo = _isReplayFilterEnabled ? Context.ActorOf(ReplayFilter.Props(message.PersistentActor, _replayFilterMode, _replayFilterWindowSize, _replayFilterMaxOldWriters, _replayDebugEnabled)) : message.PersistentActor; var context = Context; var readHighestSequenceNrFrom = Math.Max(0, message.FromSequenceNr - 1); var promise = new TaskCompletionSource<long>(); _breaker .WithCircuitBreaker(() => ReadHighestSequenceNrAsync(message.PersistenceId, readHighestSequenceNrFrom)) .ContinueWith(t => { if (!t.IsFaulted && !t.IsCanceled) { var highSequenceNr = t.Result; var toSequenceNr = Math.Min(message.ToSequenceNr, highSequenceNr); if (highSequenceNr == 0 || message.FromSequenceNr > toSequenceNr) { promise.SetResult(highSequenceNr); } else { // Send replayed messages and replay result to persistentActor directly. No need // to resequence replayed messages relative to written and looped messages. // not possible to use circuit breaker here ReplayMessagesAsync(context, message.PersistenceId, message.FromSequenceNr, toSequenceNr, message.Max, p => { if (!p.IsDeleted) // old records from pre 1.5 may still have the IsDeleted flag { foreach (var adaptedRepresentation in AdaptFromJournal(p)) { replyTo.Tell(new ReplayedMessage(adaptedRepresentation), ActorRefs.NoSender); } } }) .ContinueWith(replayTask => { if (!replayTask.IsFaulted && !replayTask.IsCanceled) promise.SetResult(highSequenceNr); else promise.SetException(replayTask.IsFaulted ? TryUnwrapException(replayTask.Exception) : new OperationCanceledException( "ReplayMessagesAsync canceled, possibly due to timing out.")); }, _continuationOptions); } } else { promise.SetException(t.IsFaulted ? TryUnwrapException(t.Exception) : new OperationCanceledException( "ReadHighestSequenceNrAsync canceled, possibly due to timing out.")); } }, _continuationOptions); promise.Task .ContinueWith(t => !t.IsFaulted ? (object) new RecoverySuccess(t.Result) : new ReplayMessagesFailure(TryUnwrapException(t.Exception)), _continuationOptions) .PipeTo(replyTo) .ContinueWith(t => { if (!t.IsFaulted && CanPublish) context.System.EventStream.Publish(message); }, _continuationOptions); }
private void HandleReplayMessages(ReplayMessages message) { var replyTo = _isReplayFilterEnabled ? Context.ActorOf(ReplayFilter.Props(message.PersistentActor, _replayFilterMode, _replayFilterWindowSize, _replayFilterMaxOldWriters, _replayDebugEnabled)) : message.PersistentActor; var context = Context; var readHighestSequenceNrFrom = Math.Max(0, message.FromSequenceNr - 1); var promise = new TaskCompletionSource <long>(); _breaker .WithCircuitBreaker(() => ReadHighestSequenceNrAsync(message.PersistenceId, readHighestSequenceNrFrom)) .ContinueWith(t => { if (!t.IsFaulted && !t.IsCanceled) { var highSequenceNr = t.Result; var toSequenceNr = Math.Min(message.ToSequenceNr, highSequenceNr); if (highSequenceNr == 0 || message.FromSequenceNr > toSequenceNr) { promise.SetResult(highSequenceNr); } else { // Send replayed messages and replay result to persistentActor directly. No need // to resequence replayed messages relative to written and looped messages. // not possible to use circuit breaker here ReplayMessagesAsync(context, message.PersistenceId, message.FromSequenceNr, toSequenceNr, message.Max, p => { if (!p.IsDeleted) // old records from pre 1.5 may still have the IsDeleted flag { foreach (var adaptedRepresentation in AdaptFromJournal(p)) { replyTo.Tell(new ReplayedMessage(adaptedRepresentation), ActorRefs.NoSender); } } }) .ContinueWith(replayTask => { if (!replayTask.IsFaulted && !replayTask.IsCanceled) { promise.SetResult(highSequenceNr); } else { promise.SetException(replayTask.IsFaulted ? TryUnwrapException(replayTask.Exception) : new OperationCanceledException( "ReplayMessagesAsync canceled, possibly due to timing out.")); } }, _continuationOptions); } } else { promise.SetException(t.IsFaulted ? TryUnwrapException(t.Exception) : new OperationCanceledException( "ReadHighestSequenceNrAsync canceled, possibly due to timing out.")); } }, _continuationOptions); promise.Task .ContinueWith(t => !t.IsFaulted ? (object)new RecoverySuccess(t.Result) : new ReplayMessagesFailure(TryUnwrapException(t.Exception)), _continuationOptions) .PipeTo(replyTo) .ContinueWith(t => { if (!t.IsFaulted && CanPublish) { context.System.EventStream.Publish(message); } }, _continuationOptions); }