コード例 #1
0
        private void HandleDeleteMessagesTo(DeleteMessagesTo message)
        {
            var eventStream = Context.System.EventStream;

            DeleteMessagesToAsync(message.PersistenceId, message.ToSequenceNr)
            .ContinueWith(t =>
            {
                return((!t.IsFaulted && !t.IsCanceled)
                        ? (object)new DeleteMessagesSuccess(message.ToSequenceNr)
                        : new DeleteMessagesFailure(
                           t.IsFaulted
                                ? TryUnwrapException(t.Exception)
                                : new OperationCanceledException(
                               "DeleteMessagesToAsync canceled, possibly due to timing out."),
                           message.ToSequenceNr));
            }, _continuationOptions)
            .PipeTo(message.PersistentActor)
            .ContinueWith(resultTask =>
            {
                if (!resultTask.IsFaulted && !resultTask.IsCanceled && CanPublish)
                {
                    eventStream.Publish(message);
                }
            }, _continuationOptions);
        }
コード例 #2
0
 private void HandleDeleteMessagesTo(DeleteMessagesTo message)
 {
     DeleteMessagesToAsync(message.PersistenceId, message.ToSequenceNr, message.IsPermanent)
         .ContinueWith(t =>
         {
             if (!t.IsFaulted && CanPublish) Context.System.EventStream.Publish(message);
         }, _continuationOptions);
 }
コード例 #3
0
        private void HandleDeleteMessagesTo(DeleteMessagesTo msg)
        {
            try
            {
                DeleteMessagesTo(msg.PersistenceId, msg.ToSequenceNr, msg.IsPermanent);

                if (CanPublish) Context.System.EventStream.Publish(msg);
            }
            catch (Exception e) { /* do nothing */ }
        }
コード例 #4
0
 private void HandleDeleteMessagesTo(DeleteMessagesTo message)
 {
     DeleteMessagesToAsync(message.PersistenceId, message.ToSequenceNr, message.IsPermanent)
     .ContinueWith(t =>
     {
         if (!t.IsFaulted && CanPublish)
         {
             Context.System.EventStream.Publish(message);
         }
     }, _continuationOptions);
 }
コード例 #5
0
        private void HandleDeleteMessagesTo(DeleteMessagesTo msg)
        {
            try
            {
                DeleteMessagesTo(msg.PersistenceId, msg.ToSequenceNr, msg.IsPermanent);

                if (CanPublish)
                {
                    Context.System.EventStream.Publish(msg);
                }
            }
            catch (Exception e) { /* do nothing */ }
        }
コード例 #6
0
ファイル: JournalSpec.cs プロジェクト: vonwenm/akka.net
        public void Journal_should_not_replay_permanently_deleted_messages_on_range_deletion()
        {
            var command    = new DeleteMessagesTo(Pid, 3, true);
            var subscriber = CreateTestProbe();

            Subscribe <DeleteMessagesTo>(subscriber.Ref);
            Journal.Tell(command);
            subscriber.ExpectMsg <DeleteMessagesTo>(cmd => cmd.PersistenceId == Pid && cmd.ToSequenceNr == 3 && cmd.IsPermanent);

            Journal.Tell(new ReplayMessages(1, long.MaxValue, long.MaxValue, Pid, _receiverProbe.Ref));
            _receiverProbe.ExpectMsg <ReplayedMessage>(m => IsReplayedMessage(m, 4));
            _receiverProbe.ExpectMsg <ReplayedMessage>(m => IsReplayedMessage(m, 5));
        }
コード例 #7
0
ファイル: JournalSpec.cs プロジェクト: zhanjian/akka.net
        public void Journal_should_not_replay_permanently_deleted_messages_on_range_deletion()
        {
            var receiverProbe2 = CreateTestProbe();
            var command        = new DeleteMessagesTo(Pid, 3, receiverProbe2.Ref);
            var subscriber     = CreateTestProbe();

            Subscribe <DeleteMessagesTo>(subscriber.Ref);
            Journal.Tell(command);
            subscriber.ExpectMsg <DeleteMessagesTo>(cmd => cmd.PersistenceId == Pid && cmd.ToSequenceNr == 3);
            receiverProbe2.ExpectMsg <DeleteMessagesSuccess>(m => m.ToSequenceNr == command.ToSequenceNr);

            Journal.Tell(new ReplayMessages(1, long.MaxValue, long.MaxValue, Pid, _receiverProbe.Ref));
            _receiverProbe.ExpectMsg <ReplayedMessage>(m => IsReplayedMessage(m, 4));
            _receiverProbe.ExpectMsg <ReplayedMessage>(m => IsReplayedMessage(m, 5));

            receiverProbe2.ExpectNoMsg(TimeSpan.FromMilliseconds(200));
        }
コード例 #8
0
        protected override async Task HandleDeleteMessagesTo(DeleteMessagesTo req, OracleCommand command)
        {
            var toSequenceNr  = req.ToSequenceNr;
            var persistenceId = req.PersistenceId;

            NotifyNewPersistenceIdAdded(persistenceId);

            try
            {
                var highestSequenceNr = await ReadHighestSequenceNr(persistenceId, command);

                command.CommandText = DeleteBatchSql;
                command.Parameters.Clear();
                AddParameter(command, ":PersistenceId", OracleDbType.NVarchar2, persistenceId);
                AddParameter(command, ":ToSequenceNr", OracleDbType.Int64, toSequenceNr);

                await command.ExecuteNonQueryAsync();

                if (highestSequenceNr <= toSequenceNr)
                {
                    command.CommandText = UpdateSequenceNrSql;
                    command.Parameters.Clear();

                    AddParameter(command, ":PersistenceId", OracleDbType.NVarchar2, persistenceId);
                    AddParameter(command, ":SequenceNr", OracleDbType.Int64, highestSequenceNr);

                    await command.ExecuteNonQueryAsync();
                }

                var response = new DeleteMessagesSuccess(toSequenceNr);
                req.PersistentActor.Tell(response);
            }
            catch (Exception cause)
            {
                var response = new DeleteMessagesFailure(cause, toSequenceNr);
                req.PersistentActor.Tell(response, ActorRefs.NoSender);
            }
        }
コード例 #9
0
        private void HandleDeleteMessagesTo(DeleteMessagesTo message)
        {
            var eventStream = Context.System.EventStream;

            _breaker.WithCircuitBreaker(() => DeleteMessagesToAsync(message.PersistenceId, message.ToSequenceNr))
            .ContinueWith(t => !t.IsFaulted && !t.IsCanceled
                        ? new DeleteMessagesSuccess(message.ToSequenceNr) as object
                        : new DeleteMessagesFailure(
                              t.IsFaulted
                                ? TryUnwrapException(t.Exception)
                                : new OperationCanceledException(
                                  "DeleteMessagesToAsync canceled, possibly due to timing out."),
                              message.ToSequenceNr),
                          _continuationOptions)
            .PipeTo(message.PersistentActor)
            .ContinueWith(t =>
            {
                if (!t.IsFaulted && !t.IsCanceled && CanPublish)
                {
                    eventStream.Publish(message);
                }
            }, _continuationOptions);
        }
コード例 #10
0
 private void HandleDeleteMessagesTo(DeleteMessagesTo message)
 {
     var eventStream = Context.System.EventStream;
     DeleteMessagesToAsync(message.PersistenceId, message.ToSequenceNr)
         .ContinueWith(t =>
         {
             return (!t.IsFaulted && !t.IsCanceled)
                 ? (object) new DeleteMessagesSuccess(message.ToSequenceNr)
                 : new DeleteMessagesFailure(
                     t.IsFaulted
                         ? TryUnwrapException(t.Exception)
                         : new OperationCanceledException(
                             "DeleteMessagesToAsync canceled, possibly due to timing out."),
                     message.ToSequenceNr);
         }, _continuationOptions)
         .PipeTo(message.PersistentActor)
         .ContinueWith(resultTask =>
         {
             if (!resultTask.IsFaulted && !resultTask.IsCanceled && CanPublish)
                 eventStream.Publish(message);
         }, _continuationOptions);
 }
コード例 #11
0
        public void Journal_should_replay_logically_deleted_messages_with_deleted_flag_set_on_range_deletion()
        {
            var command = new DeleteMessagesTo(Pid, 3, false);
            var subscriber = CreateTestProbe();

            Subscribe<DeleteMessagesTo>(subscriber.Ref);
            Journal.Tell(command);
            subscriber.ExpectMsg<DeleteMessagesTo>(cmd => cmd.PersistenceId == Pid && cmd.ToSequenceNr == 3 && !cmd.IsPermanent);

            Journal.Tell(new ReplayMessages(1, long.MaxValue, long.MaxValue, Pid, _receiverProbe.Ref, replayDeleted: true));

            _receiverProbe.ExpectMsg<ReplayedMessage>(m => IsReplayedMessage(m, 1, true));
            _receiverProbe.ExpectMsg<ReplayedMessage>(m => IsReplayedMessage(m, 2, true));
            _receiverProbe.ExpectMsg<ReplayedMessage>(m => IsReplayedMessage(m, 3, true));
            _receiverProbe.ExpectMsg<ReplayedMessage>(m => IsReplayedMessage(m, 4));
            _receiverProbe.ExpectMsg<ReplayedMessage>(m => IsReplayedMessage(m, 5));
        }
コード例 #12
0
        public void Journal_should_not_replay_permanently_deleted_messages_on_range_deletion()
        {
            var receiverProbe2 = CreateTestProbe();
            var command = new DeleteMessagesTo(Pid, 3, receiverProbe2.Ref);
            var subscriber = CreateTestProbe();

            Subscribe<DeleteMessagesTo>(subscriber.Ref);
            Journal.Tell(command);
            subscriber.ExpectMsg<DeleteMessagesTo>(cmd => cmd.PersistenceId == Pid && cmd.ToSequenceNr == 3);
            receiverProbe2.ExpectMsg<DeleteMessagesSuccess>(m => m.ToSequenceNr == command.ToSequenceNr);

            Journal.Tell(new ReplayMessages(1, long.MaxValue, long.MaxValue, Pid, _receiverProbe.Ref));
            _receiverProbe.ExpectMsg<ReplayedMessage>(m => IsReplayedMessage(m, 4));
            _receiverProbe.ExpectMsg<ReplayedMessage>(m => IsReplayedMessage(m, 5));

            receiverProbe2.ExpectNoMsg(TimeSpan.FromMilliseconds(200));
        }