private void Handle(StorageMessage.WritePrepares msg) { if (msg.EventStreamId == _subscriptionParkedStream) { _writeCorrelationId = msg.CorrelationId; } }
public void Handle(StorageMessage.WritePrepares message) { var transactionPosition = LogPosition; foreach (var _ in message.Events) { Dispatcher.Publish(new StorageMessage.PrepareAck( message.CorrelationId, LogPosition, PrepareFlags)); LogPosition += 100; } Dispatcher.Publish(new StorageMessage.CommitAck( message.CorrelationId, LogPosition, transactionPosition, 0, message.Events.Length)); }
void IHandle <StorageMessage.WritePrepares> .Handle(StorageMessage.WritePrepares msg) { Interlocked.Decrement(ref FlushMessagesInQueue); try { if (msg.LiveUntil < DateTime.UtcNow) { return; } string streamId = msg.EventStreamId; var commitCheck = _indexWriter.CheckCommit(streamId, msg.ExpectedVersion, msg.Events.Select(x => x.EventId)); if (commitCheck.Decision != CommitDecision.Ok) { ActOnCommitCheckFailure(msg.Envelope, msg.CorrelationId, commitCheck); return; } var prepares = new List <PrepareLogRecord>(); var logPosition = Writer.Checkpoint.ReadNonFlushed(); if (msg.Events.Length > 0) { var transactionPosition = logPosition; for (int i = 0; i < msg.Events.Length; ++i) { var evnt = msg.Events[i]; var flags = PrepareFlags.Data | PrepareFlags.IsCommitted; if (i == 0) { flags |= PrepareFlags.TransactionBegin; } if (i == msg.Events.Length - 1) { flags |= PrepareFlags.TransactionEnd; } if (evnt.IsJson) { flags |= PrepareFlags.IsJson; } // when IsCommitted ExpectedVersion is always explicit var expectedVersion = commitCheck.CurrentVersion + i; var res = WritePrepareWithRetry( LogRecord.Prepare(logPosition, msg.CorrelationId, evnt.EventId, transactionPosition, i, streamId, expectedVersion, flags, evnt.EventType, evnt.Data, evnt.Metadata)); logPosition = res.NewPos; if (i == 0) { transactionPosition = res.WrittenPos; } // transaction position could be changed due to switching to new chunk prepares.Add(res.Prepare); } } else { WritePrepareWithRetry( LogRecord.Prepare(logPosition, msg.CorrelationId, Guid.NewGuid(), logPosition, -1, streamId, commitCheck.CurrentVersion, PrepareFlags.TransactionBegin | PrepareFlags.TransactionEnd | PrepareFlags.IsCommitted, null, Empty.ByteArray, Empty.ByteArray)); } bool softUndeleteMetastream = SystemStreams.IsMetastream(streamId) && _indexWriter.IsSoftDeleted(SystemStreams.OriginalStreamOf(streamId)); _indexWriter.PreCommit(prepares); if (commitCheck.IsSoftDeleted) { SoftUndeleteStream(streamId, commitCheck.CurrentVersion + 1); } if (softUndeleteMetastream) { SoftUndeleteMetastream(streamId); } } catch (Exception exc) { Log.ErrorException(exc, "Exception in writer."); throw; } finally { Flush(); } }
void IHandle <StorageMessage.WritePrepares> .Handle(StorageMessage.WritePrepares message) { Interlocked.Decrement(ref FlushMessagesInQueue); try { if (message.LiveUntil < DateTime.UtcNow) { return; } var logPosition = Writer.Checkpoint.ReadNonFlushed(); if (message.Events.Length > 0) { var transactionPosition = logPosition; for (int i = 0; i < message.Events.Length; ++i) { var evnt = message.Events[i]; var flags = PrepareFlags.Data; if (i == 0) { flags |= PrepareFlags.TransactionBegin; } if (i == message.Events.Length - 1) { flags |= PrepareFlags.TransactionEnd; } if (evnt.IsJson) { flags |= PrepareFlags.IsJson; } var expectedVersion = i == 0 ? message.ExpectedVersion : ExpectedVersion.Any; var res = WritePrepareWithRetry(LogRecord.Prepare(logPosition, message.CorrelationId, evnt.EventId, transactionPosition, i, message.EventStreamId, expectedVersion, flags, evnt.EventType, evnt.Data, evnt.Metadata)); logPosition = res.NewPos; if (i == 0) { transactionPosition = res.WrittenPos; // transaction position could be changed due to switching to new chunk } } } else { WritePrepareWithRetry(LogRecord.Prepare(logPosition, message.CorrelationId, Guid.NewGuid(), logPosition, -1, message.EventStreamId, message.ExpectedVersion, PrepareFlags.TransactionBegin | PrepareFlags.TransactionEnd, null, Empty.ByteArray, Empty.ByteArray)); } } catch (Exception exc) { Log.ErrorException(exc, "Exception in writer."); throw; } finally { Flush(); } }
void IHandle <StorageMessage.WritePrepares> .Handle(StorageMessage.WritePrepares message) { Interlocked.Decrement(ref FlushMessagesInQueue); try { if (message.LiveUntil < DateTime.UtcNow) { return; } Debug.Assert(message.Events.Length > 0); var logPosition = Writer.Checkpoint.ReadNonFlushed(); var transactionPosition = logPosition; var shouldCreateStream = ShouldCreateStreamFor(message); if (shouldCreateStream) { var res = WritePrepareWithRetry(LogRecord.StreamCreated(logPosition, message.CorrelationId, transactionPosition, message.EventStreamId, LogRecord.NoData)); transactionPosition = res.WrittenPos; // transaction position could be changed due to switching to new chunk logPosition = res.NewPos; } for (int i = 0; i < message.Events.Length; ++i) { var evnt = message.Events[i]; var flags = PrepareFlags.Data; if (i == 0 && !shouldCreateStream) { flags |= PrepareFlags.TransactionBegin; } if (i == message.Events.Length - 1) { flags |= PrepareFlags.TransactionEnd; } if (evnt.IsJson) { flags |= PrepareFlags.IsJson; } var expectedVersion = shouldCreateStream ? ExpectedVersion.Any : (i == 0 ? message.ExpectedVersion : ExpectedVersion.Any); var res = WritePrepareWithRetry(LogRecord.Prepare(logPosition, message.CorrelationId, evnt.EventId, transactionPosition, shouldCreateStream ? i + 1 : i, message.EventStreamId, expectedVersion, flags, evnt.EventType, evnt.Data, evnt.Metadata)); logPosition = res.NewPos; if (i == 0 && !shouldCreateStream) { transactionPosition = res.WrittenPos; // transaction position could be changed due to switching to new chunk } } } finally { Flush(); } }