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();
}
}
