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;
        }
Exemple #3
0
 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);
         }
     }
 }
Exemple #4
0
        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);
        }
Exemple #5
0
        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;
            }
        }
Exemple #6
0
        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 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;

            /*
             * 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);
        }
Exemple #9
0
        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;
        }
Exemple #11
0
        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));
            }
        }