private void WriteEvents() { var probe = CreateTestProbe(); var message = new WriteMessages(Events.Select(p => new AtomicWrite(p)), probe.Ref, ActorInstanceId); JournalRef.Tell(message); probe.ExpectMsg <WriteMessagesSuccessful>(); foreach (var persistent in Events) { probe.ExpectMsg(new WriteMessageSuccess(persistent, ActorInstanceId)); } }
private void HandleWriteMessages(WriteMessages message) { var counter = _resequencerCounter; Action <Func <IPersistentRepresentation, object> > resequence = (mapper) => { var i = 0; foreach (var resequencable in message.Messages) { if (resequencable is IPersistentRepresentation) { var p = resequencable as IPersistentRepresentation; _resequencer.Tell(new Desequenced(mapper(p), counter + i + 1, message.PersistentActor, p.Sender)); } else { var loopMsg = new LoopMessageSuccess(resequencable.Payload, message.ActorInstanceId); _resequencer.Tell(new Desequenced(loopMsg, counter + i + 1, message.PersistentActor, resequencable.Sender)); } i++; } }; /* * Self MUST BE CLOSED OVER here, or the code below will be subject to race conditions which may result * in failure, as the `IActorContext` needed for resolving Context.Self will be done outside the current * execution context. */ var self = Self; WriteMessagesAsync(CreatePersistentBatch(message.Messages)).ContinueWith(t => { if (!t.IsFaulted) { _resequencer.Tell(new Desequenced(WriteMessagesSuccessful.Instance, counter, message.PersistentActor, self)); resequence(x => new WriteMessageSuccess(x, message.ActorInstanceId)); } else { _resequencer.Tell(new Desequenced(new WriteMessagesFailed(t.Exception), counter, message.PersistentActor, self)); resequence(x => new WriteMessageFailure(x, t.Exception, message.ActorInstanceId)); } }, _continuationOptions); var resequencablesLength = message.Messages.Count(); _resequencerCounter += resequencablesLength + 1; }
private void Confirm(WriteMessages w) { _journal.Send(w.PersistentActor, WriteMessagesSuccessful.Instance); foreach (var message in w.Messages) { if (message is AtomicWrite) { var msgs = (IEnumerable <IPersistentRepresentation>)((AtomicWrite)message).Payload; foreach (var msg in msgs) { w.PersistentActor.Tell(new WriteMessageSuccess(msg, w.ActorInstanceId), msg.Sender); } } else { w.PersistentActor.Tell(message.Payload, message.Sender); } } }
protected void SaveToJournal(params object[] messages) { 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); int seqNumber = 0; var envelop = messages.Select(e => new Akka.Persistence.AtomicWrite( new Persistent(e, seqNumber++, "testId", e.GetType() .AssemblyQualifiedShortName()))) .Cast <IPersistentEnvelope>() .ToArray(); var writeMsg = new WriteMessages(envelop, TestActor, 1); journal.Tell(writeMsg); FishForMessage <WriteMessagesSuccessful>(m => true); }
private void HandleWriteMessages(WriteMessages msg) { try { var batch = CreatePersistentBatch(msg.Messages); WriteMessages(batch); msg.PersistentActor.Tell(WriteMessagesSuccessull.Instance); foreach (var message in msg.Messages) { if (message is IPersistentRepresentation) { var p = message as IPersistentRepresentation; msg.PersistentActor.Tell(new WriteMessageSuccess(p, msg.ActorInstanceId), p.Sender); } else { msg.PersistentActor.Tell(new LoopMessageSuccess(message.Payload, msg.ActorInstanceId), message.Sender); } } } catch (Exception e) { msg.PersistentActor.Tell(new WriteMessagesFailed(e)); foreach (var message in msg.Messages) { if (message is IPersistentRepresentation) { var p = message as IPersistentRepresentation; msg.PersistentActor.Tell(new WriteMessageFailure(p, e, msg.ActorInstanceId), p.Sender); } else { msg.PersistentActor.Tell(new LoopMessageSuccess(message.Payload, msg.ActorInstanceId), message.Sender); } } throw; } }
private void HandleWriteMessages(WriteMessages message) { var counter = _resequencerCounter; Action <Func <IPersistentRepresentation, object> > resequence = (mapper) => { var i = 0; foreach (var resequencable in message.Messages) { if (resequencable is IPersistentRepresentation) { var p = resequencable as IPersistentRepresentation; _resequencer.Tell(new Desequenced(mapper(p), counter + i + 1, message.PersistentActor, p.Sender)); } else { var loopMsg = new LoopMessageSuccess(resequencable.Payload, message.ActorInstanceId); _resequencer.Tell(new Desequenced(loopMsg, counter + i + 1, message.PersistentActor, resequencable.Sender)); } i++; } }; WriteMessagesAsync(CreatePersistentBatch(message.Messages)).ContinueWith(t => { if (!t.IsFaulted) { _resequencer.Tell(new Desequenced(WriteMessagesSuccessull.Instance, counter, message.PersistentActor, Self)); resequence(x => new WriteMessageSuccess(x, message.ActorInstanceId)); } else { _resequencer.Tell(new Desequenced(new WriteMessagesFailed(t.Exception), counter, message.PersistentActor, Self)); resequence(x => new WriteMessageFailure(x, t.Exception, message.ActorInstanceId)); } }, _continuationOptions); var resequencablesLength = message.Messages.Count(); _resequencerCounter += resequencablesLength + 1; }
private void HandleWriteMessages(WriteMessages message) { var counter = _resequencerCounter; /* * Self MUST BE CLOSED OVER here, or the code below will be subject to race conditions which may result * in failure, as the `IActorContext` needed for resolving Context.Self will be done outside the current * execution context. */ var self = Self; _resequencerCounter += message.Messages.Aggregate(1, (acc, m) => acc + m.Size); var atomicWriteCount = message.Messages.OfType<AtomicWrite>().Count(); AtomicWrite[] prepared; Task<IImmutableList<Exception>> writeResult; Exception writeMessagesAsyncException = null; try { prepared = PreparePersistentBatch(message.Messages).ToArray(); // try in case AsyncWriteMessages throws try { writeResult = _breaker.WithCircuitBreaker(() => WriteMessagesAsync(prepared)); } catch (Exception e) { writeResult = Task.FromResult((IImmutableList<Exception>) null); writeMessagesAsyncException = e; } } catch (Exception e) { // exception from PreparePersistentBatch => rejected writeResult = Task.FromResult((IImmutableList<Exception>)Enumerable.Repeat(e, atomicWriteCount).ToImmutableList()); } Action<Func<IPersistentRepresentation, Exception, object>, IImmutableList<Exception>> resequence = (mapper, results) => { var i = 0; var enumerator = results != null ? results.GetEnumerator() : null; foreach (var resequencable in message.Messages) { if (resequencable is AtomicWrite) { var aw = resequencable as AtomicWrite; Exception exception = null; if (enumerator != null) { enumerator.MoveNext(); exception = enumerator.Current; } foreach (var p in (IEnumerable<IPersistentRepresentation>)aw.Payload) { _resequencer.Tell(new Desequenced(mapper(p, exception), counter + i + 1, message.PersistentActor, p.Sender)); i++; } } else { var loopMsg = new LoopMessageSuccess(resequencable.Payload, message.ActorInstanceId); _resequencer.Tell(new Desequenced(loopMsg, counter + i + 1, message.PersistentActor, resequencable.Sender)); i++; } } }; writeResult .ContinueWith(t => { if (!t.IsFaulted && !t.IsCanceled && writeMessagesAsyncException == null) { if (t.Result != null && t.Result.Count != atomicWriteCount) throw new IllegalStateException(string.Format("AsyncWriteMessages return invalid number or results. " + "Expected [{0}], but got [{1}].", atomicWriteCount, t.Result.Count)); _resequencer.Tell(new Desequenced(WriteMessagesSuccessful.Instance, counter, message.PersistentActor, self)); resequence((x, exception) => exception == null ? (object)new WriteMessageSuccess(x, message.ActorInstanceId) : new WriteMessageRejected(x, exception, message.ActorInstanceId), t.Result); } else { var exception = writeMessagesAsyncException != null ? writeMessagesAsyncException : (t.IsFaulted ? TryUnwrapException(t.Exception) : new OperationCanceledException( "WriteMessagesAsync canceled, possibly due to timing out.")); _resequencer.Tell(new Desequenced(new WriteMessagesFailed(exception), counter, message.PersistentActor, self)); resequence((x, _) => new WriteMessageFailure(x, exception, message.ActorInstanceId), null); } }, _continuationOptions); }
private void HandleWriteMessages(WriteMessages message) { var counter = _resequencerCounter; /* * Self MUST BE CLOSED OVER here, or the code below will be subject to race conditions which may result * in failure, as the `IActorContext` needed for resolving Context.Self will be done outside the current * execution context. */ var self = Self; _resequencerCounter += message.Messages.Aggregate(1, (acc, m) => acc + m.Size); var atomicWriteCount = message.Messages.OfType <AtomicWrite>().Count(); AtomicWrite[] prepared; Task <IImmutableList <Exception> > writeResult; Exception writeMessagesAsyncException = null; try { prepared = PreparePersistentBatch(message.Messages).ToArray(); // try in case AsyncWriteMessages throws try { writeResult = _breaker.WithCircuitBreaker(() => WriteMessagesAsync(prepared)); } catch (Exception e) { writeResult = Task.FromResult((IImmutableList <Exception>)null); writeMessagesAsyncException = e; } } catch (Exception e) { // exception from PreparePersistentBatch => rejected writeResult = Task.FromResult((IImmutableList <Exception>)Enumerable.Repeat(e, atomicWriteCount).ToImmutableList()); } Action <Func <IPersistentRepresentation, Exception, object>, IImmutableList <Exception> > resequence = (mapper, results) => { var i = 0; var enumerator = results != null?results.GetEnumerator() : null; foreach (var resequencable in message.Messages) { if (resequencable is AtomicWrite) { var aw = resequencable as AtomicWrite; Exception exception = null; if (enumerator != null) { enumerator.MoveNext(); exception = enumerator.Current; } foreach (var p in (IEnumerable <IPersistentRepresentation>)aw.Payload) { _resequencer.Tell(new Desequenced(mapper(p, exception), counter + i + 1, message.PersistentActor, p.Sender)); i++; } } else { var loopMsg = new LoopMessageSuccess(resequencable.Payload, message.ActorInstanceId); _resequencer.Tell(new Desequenced(loopMsg, counter + i + 1, message.PersistentActor, resequencable.Sender)); i++; } } }; writeResult .ContinueWith(t => { if (!t.IsFaulted && !t.IsCanceled && writeMessagesAsyncException == null) { if (t.Result != null && t.Result.Count != atomicWriteCount) { throw new IllegalStateException(string.Format("AsyncWriteMessages return invalid number or results. " + "Expected [{0}], but got [{1}].", atomicWriteCount, t.Result.Count)); } _resequencer.Tell(new Desequenced(WriteMessagesSuccessful.Instance, counter, message.PersistentActor, self)); resequence((x, exception) => exception == null ? (object)new WriteMessageSuccess(x, message.ActorInstanceId) : new WriteMessageRejected(x, exception, message.ActorInstanceId), t.Result); } else { var exception = writeMessagesAsyncException != null ? writeMessagesAsyncException : (t.IsFaulted ? TryUnwrapException(t.Exception) : new OperationCanceledException( "WriteMessagesAsync canceled, possibly due to timing out.")); _resequencer.Tell(new Desequenced(new WriteMessagesFailed(exception), counter, message.PersistentActor, self)); resequence((x, _) => new WriteMessageFailure(x, exception, message.ActorInstanceId), null); } }, _continuationOptions); }
private void HandleWriteMessages(WriteMessages message) { var counter = _resequencerCounter; Action<Func<IPersistentRepresentation, object>> resequence = (mapper) => { var i = 0; foreach (var resequencable in message.Messages) { if (resequencable is IPersistentRepresentation) { var p = resequencable as IPersistentRepresentation; _resequencer.Tell(new Desequenced(mapper(p), counter + i + 1, message.PersistentActor, p.Sender)); } else { var loopMsg = new LoopMessageSuccess(resequencable.Payload, message.ActorInstanceId); _resequencer.Tell(new Desequenced(loopMsg, counter + i + 1, message.PersistentActor, resequencable.Sender)); } i++; } }; WriteMessagesAsync(CreatePersistentBatch(message.Messages)).ContinueWith(t => { if (!t.IsFaulted) { _resequencer.Tell(new Desequenced(WriteMessagesSuccessull.Instance, counter, message.PersistentActor, Self)); resequence(x => new WriteMessageSuccess(x, message.ActorInstanceId)); } else { _resequencer.Tell(new Desequenced(new WriteMessagesFailed(t.Exception), counter, message.PersistentActor, Self)); resequence(x => new WriteMessageFailure(x, t.Exception, message.ActorInstanceId)); } }, _continuationOptions); var resequencablesLength = message.Messages.Count(); _resequencerCounter += resequencablesLength + 1; }
private void HandleWriteMessages(WriteMessages message) { var counter = _resequencerCounter; Action<Func<IPersistentRepresentation, object>> resequence = (mapper) => { var i = 0; foreach (var resequencable in message.Messages) { if (resequencable is IPersistentRepresentation) { var p = resequencable as IPersistentRepresentation; _resequencer.Tell(new Desequenced(mapper(p), counter + i + 1, message.PersistentActor, p.Sender)); } else { var loopMsg = new LoopMessageSuccess(resequencable.Payload, message.ActorInstanceId); _resequencer.Tell(new Desequenced(loopMsg, counter + i + 1, message.PersistentActor, resequencable.Sender)); } i++; } }; /* * Self MUST BE CLOSED OVER here, or the code below will be subject to race conditions which may result * in failure, as the `IActorContext` needed for resolving Context.Self will be done outside the current * execution context. */ var self = Self; var resequencablesLength = message.Messages.Count(); _resequencerCounter += resequencablesLength + 1; WriteMessagesAsync(CreatePersistentBatch(message.Messages).ToArray()) .ContinueWith(t => { if (!t.IsFaulted) { _resequencer.Tell(new Desequenced(WriteMessagesSuccessful.Instance, counter, message.PersistentActor, self)); resequence(x => new WriteMessageSuccess(x, message.ActorInstanceId)); } else { _resequencer.Tell(new Desequenced(new WriteMessagesFailed(t.Exception), counter, message.PersistentActor, self)); resequence(x => new WriteMessageFailure(x, t.Exception, message.ActorInstanceId)); } }, _continuationOptions); }
private void WriteEvents() { var probe = CreateTestProbe(); var message = new WriteMessages(Events.Select(p => new AtomicWrite(p)), probe.Ref, ActorInstanceId); JournalRef.Tell(message); probe.ExpectMsg<WriteMessagesSuccessful>(); foreach (var persistent in Events) { probe.ExpectMsg(new WriteMessageSuccess(persistent, ActorInstanceId)); } }