Exemplo n.º 1
0
        void IHandle <ReplicationMessage.WriteDelete> .Handle(ReplicationMessage.WriteDelete message)
        {
            Interlocked.Decrement(ref _flushMessagesInQueue);
            try
            {
                if (message.LiveUntil < DateTime.UtcNow)
                {
                    return;
                }

                if (ShouldCreateStreamFor(message))
                {
                    var transactionPos = _writer.Checkpoint.ReadNonFlushed();
                    var res            = WritePrepareWithRetry(LogRecord.StreamCreated(transactionPos,
                                                                                       message.CorrelationId,
                                                                                       transactionPos,
                                                                                       message.EventStreamId,
                                                                                       LogRecord.NoData));
                    transactionPos = res.WrittenPos;

                    WritePrepareWithRetry(LogRecord.Prepare(res.NewPos,
                                                            message.CorrelationId,
                                                            Guid.NewGuid(),
                                                            transactionPos,
                                                            0,
                                                            message.EventStreamId,
                                                            message.ExpectedVersion,
                                                            PrepareFlags.StreamDelete | PrepareFlags.TransactionEnd,
                                                            SystemEventTypes.StreamDeleted,
                                                            LogRecord.NoData,
                                                            LogRecord.NoData));
                }
                else
                {
                    var record = LogRecord.DeleteTombstone(_writer.Checkpoint.ReadNonFlushed(),
                                                           message.CorrelationId,
                                                           message.EventStreamId,
                                                           message.ExpectedVersion);
                    WritePrepareWithRetry(record);
                }
            }
            finally
            {
                Flush();
            }
        }
Exemplo n.º 2
0
        void IHandle <ReplicationMessage.WriteDelete> .Handle(ReplicationMessage.WriteDelete message)
        {
            if (_state != VNodeState.Master)
            {
                throw new InvalidOperationException("Write request not in working state.");
            }

            CheckExpectedVersionAndWrite(message, (msg, toCreateStream) =>
            {
                if (toCreateStream)
                {
                    var transactionPos = _writer.Checkpoint.ReadNonFlushed();
                    var res            = WritePrepareWithRetry(LogRecord.StreamCreated(transactionPos,
                                                                                       msg.CorrelationId,
                                                                                       transactionPos,
                                                                                       msg.EventStreamId,
                                                                                       LogRecord.NoData));
                    transactionPos = res.WrittenPos;

                    WritePrepareWithRetry(LogRecord.Prepare(res.NewPos,
                                                            msg.CorrelationId,
                                                            Guid.NewGuid(),
                                                            transactionPos,
                                                            msg.EventStreamId,
                                                            msg.ExpectedVersion,
                                                            PrepareFlags.StreamDelete | PrepareFlags.TransactionEnd,
                                                            "$stream-deleted",
                                                            LogRecord.NoData,
                                                            LogRecord.NoData));
                }
                else
                {
                    var record = LogRecord.DeleteTombstone(_writer.Checkpoint.ReadNonFlushed(),
                                                           msg.CorrelationId,
                                                           msg.EventStreamId,
                                                           msg.ExpectedVersion);
                    WritePrepareWithRetry(record);
                }
            });
        }