public void every_prepare_can_be_commited()
{
var res = ReadIndex.CheckCommitStartingAt(_prepare0.LogPosition, WriterCheckpoint.ReadNonFlushed());
Assert.AreEqual(CommitDecision.Ok, res.Decision);
Assert.AreEqual("ES", res.EventStreamId);
Assert.AreEqual(-1, res.CurrentVersion);
Assert.AreEqual(-1, res.StartEventNumber);
Assert.AreEqual(-1, res.EndEventNumber);
res = ReadIndex.CheckCommitStartingAt(_prepare1.LogPosition, WriterCheckpoint.ReadNonFlushed());
Assert.AreEqual(CommitDecision.Ok, res.Decision);
Assert.AreEqual("ES", res.EventStreamId);
Assert.AreEqual(-1, res.CurrentVersion);
Assert.AreEqual(-1, res.StartEventNumber);
Assert.AreEqual(-1, res.EndEventNumber);
res = ReadIndex.CheckCommitStartingAt(_prepare2.LogPosition, WriterCheckpoint.ReadNonFlushed());
Assert.AreEqual(CommitDecision.Ok, res.Decision);
Assert.AreEqual("ES", res.EventStreamId);
Assert.AreEqual(-1, res.CurrentVersion);
Assert.AreEqual(-1, res.StartEventNumber);
Assert.AreEqual(-1, res.EndEventNumber);
}
protected override void WriteTestScenario()
{
// Stream that will be kept
_event1 = WriteSingleEventWithLogVersion0(Guid.NewGuid(), _eventStreamId, WriterCheckpoint.ReadNonFlushed(),
0);
_event2 = WriteSingleEventWithLogVersion0(Guid.NewGuid(), _eventStreamId, WriterCheckpoint.ReadNonFlushed(),
1);
// Stream that will be deleted
WriteSingleEventWithLogVersion0(Guid.NewGuid(), _deletedEventStreamId, WriterCheckpoint.ReadNonFlushed(),
0);
WriteSingleEventWithLogVersion0(Guid.NewGuid(), _deletedEventStreamId, WriterCheckpoint.ReadNonFlushed(),
1);
_deleted = WriteSingleEventWithLogVersion0(Guid.NewGuid(), _deletedEventStreamId,
WriterCheckpoint.ReadNonFlushed(), int.MaxValue - 1,
PrepareFlags.StreamDelete | PrepareFlags.TransactionBegin | PrepareFlags.TransactionEnd);
// Stream that will be kept
_event3 = WriteSingleEventWithLogVersion0(Guid.NewGuid(), _eventStreamId, WriterCheckpoint.ReadNonFlushed(),
2);
_event4 = WriteSingleEventWithLogVersion0(Guid.NewGuid(), _eventStreamId, WriterCheckpoint.ReadNonFlushed(),
3);
Writer.CompleteChunk();
Scavenge(completeLast: false, mergeChunks: true);
}
protected override void WriteTestScenario()
{
long pos;
string stream = "ES";
_streamNameIndex.GetOrAddId(stream, out var streamId, out _, out _);
var prepare1 = LogRecord.SingleWrite(_recordFactory, WriterCheckpoint.ReadNonFlushed(), // prepare1
Guid.NewGuid(),
Guid.NewGuid(),
streamId,
-1,
"some-type",
LogRecord.NoData,
null,
DateTime.UtcNow);
Assert.IsTrue(Writer.Write(prepare1, out pos));
var prepare2 = LogRecord.SingleWrite(_recordFactory, WriterCheckpoint.ReadNonFlushed(), // prepare2
Guid.NewGuid(),
Guid.NewGuid(),
streamId,
-1,
"some-type",
LogRecord.NoData,
null,
DateTime.UtcNow);
Assert.IsTrue(Writer.Write(prepare2, out pos));
var deletePrepare = LogRecord.DeleteTombstone(_recordFactory, WriterCheckpoint.ReadNonFlushed(), // delete prepare
Guid.NewGuid(), Guid.NewGuid(), streamId, -1);
_deleteTombstone = new EventRecord(EventNumber.DeletedStream, deletePrepare, stream);
Assert.IsTrue(Writer.Write(deletePrepare, out pos));
var prepare3 = LogRecord.SingleWrite(_recordFactory, WriterCheckpoint.ReadNonFlushed(), // prepare3
Guid.NewGuid(),
Guid.NewGuid(),
streamId,
-1,
"some-type",
LogRecord.NoData,
null,
DateTime.UtcNow);
Assert.IsTrue(Writer.Write(prepare3, out pos));
var commit = LogRecord.Commit(WriterCheckpoint.ReadNonFlushed(), // committing delete
deletePrepare.CorrelationId,
deletePrepare.LogPosition,
EventNumber.DeletedStream);
Assert.IsTrue(Writer.Write(commit, out pos));
}
public void check_commmit_on_not_expected_prepare_should_return_wrong_expected_version()
{
var res = ReadIndex.CheckCommitStartingAt(_prepare4.LogPosition, WriterCheckpoint.ReadNonFlushed());
Assert.AreEqual(CommitDecision.WrongExpectedVersion, res.Decision);
Assert.AreEqual("ES", res.EventStreamId);
Assert.AreEqual(2, res.CurrentVersion);
Assert.AreEqual(-1, res.StartEventNumber);
Assert.AreEqual(-1, res.EndEventNumber);
}
public void check_commmit_on_2nd_prepare_should_return_ok_decision()
{
var res = ReadIndex.CheckCommitStartingAt(_prepare1.LogPosition, WriterCheckpoint.ReadNonFlushed());
Assert.AreEqual(CommitDecision.Ok, res.Decision);
Assert.AreEqual("ES", res.EventStreamId);
Assert.AreEqual(0, res.CurrentVersion);
Assert.AreEqual(-1, res.StartEventNumber);
Assert.AreEqual(-1, res.EndEventNumber);
}
protected override void WriteTestScenario()
{
_event0 = WriteSingleEvent("ES", 0, "bla1");
var prepare = LogRecord.DeleteTombstone(WriterCheckpoint.ReadNonFlushed(), Guid.NewGuid(), Guid.NewGuid(), "ES", 1);
long pos;
Assert.IsTrue(Writer.Write(prepare, out pos));
_event1 = WriteSingleEvent("ES", 1, "bla1");
}
protected override void WriteTestScenario()
{
_event0 = WriteSingleEvent("ES", 0, "bla1");
_streamNameIndex.GetOrAddId("ES", out var esStreamId, out _, out _);
var prepare = LogRecord.DeleteTombstone(_recordFactory, WriterCheckpoint.ReadNonFlushed(), Guid.NewGuid(), Guid.NewGuid(),
esStreamId, 1);
long pos;
Assert.IsTrue(Writer.Write(prepare, out pos));
_event1 = WriteSingleEvent("ES", 1, "bla1");
}
public void check_commmit_should_return_ok_decision()
{
var res = ReadIndex.IndexWriter.CheckCommitStartingAt(_prepare.LogPosition,
WriterCheckpoint.ReadNonFlushed());
_streamNameIndex.GetOrAddId("ES", out var streamId, out _, out _);
Assert.AreEqual(CommitDecision.Ok, res.Decision);
Assert.AreEqual(streamId, res.EventStreamId);
Assert.AreEqual(-1, res.CurrentVersion);
Assert.AreEqual(-1, res.StartEventNumber);
Assert.AreEqual(-1, res.EndEventNumber);
}
protected override void WriteTestScenario()
{
_event0 = WriteSingleEvent("ES", 0, "bla1");
var prepare = LogRecord.DeleteTombstone(_recordFactory, WriterCheckpoint.ReadNonFlushed(), Guid.NewGuid(), Guid.NewGuid(),
"ES", 2);
long pos;
Assert.IsTrue(Writer.Write(prepare, out pos));
_event1 = WriteSingleEvent("ES", 1, "bla1");
Scavenge(completeLast: false, mergeChunks: false);
}
public void check_commmit_should_return_ok_decision()
{
var res = ReadIndex.IndexWriter.CheckCommitStartingAt(_prepare.LogPosition,
WriterCheckpoint.ReadNonFlushed());
var streamId = _logFormat.StreamIds.LookupValue("ES");
Assert.AreEqual(CommitDecision.Ok, res.Decision);
Assert.AreEqual(streamId, res.EventStreamId);
Assert.AreEqual(-1, res.CurrentVersion);
Assert.AreEqual(-1, res.StartEventNumber);
Assert.AreEqual(-1, res.EndEventNumber);
}
protected override void WriteTestScenario()
{
var firstEvent = WriteSingleEvent(_allowedStream1, 1, new string('.', 3000), eventId: Guid.NewGuid(),
eventType: "event-type-1", retryOnFail: true);
WriteSingleEvent(_disallowedStream, 1, new string('.', 3000), eventId: Guid.NewGuid(), eventType: "event-type-2",
retryOnFail: true); //disallowed
WriteSingleEvent(_allowedStream2, 1, new string('.', 3000), eventId: Guid.NewGuid(), eventType: "event-type-3",
retryOnFail: true); //allowed
_forwardReadPos = new TFPos(firstEvent.LogPosition, firstEvent.LogPosition);
_backwardReadPos = new TFPos(WriterCheckpoint.ReadNonFlushed(), WriterCheckpoint.ReadNonFlushed());
}
protected override void WriteTestScenario()
{
_survivors = new List <ILogRecord>();
_scavenged = new List <ILogRecord>();
GetOrReserve("s1", out var s1StreamId, out _);
GetOrReserveEventType("event-type", out var eventTypeId, out _);
var transPos = WriterCheckpoint.ReadNonFlushed();
for (int i = 0; i < 10; ++i)
{
long tmp;
var r = LogRecord.Prepare(_recordFactory, WriterCheckpoint.ReadNonFlushed(),
Guid.NewGuid(),
Guid.NewGuid(),
transPos,
i,
s1StreamId,
i == 0 ? -1 : -2,
PrepareFlags.Data | (i == 9 ? PrepareFlags.TransactionEnd : PrepareFlags.None),
eventTypeId,
new byte[3],
new byte[3]);
Assert.IsTrue(Writer.Write(r, out tmp));
Writer.CompleteChunk();
_scavenged.Add(r);
}
var r2 = WriteCommit(transPos, "s1", 0);
_survivors.Add(r2);
Writer.CompleteChunk();
var r3 = WriteDeletePrepare("s1");
_survivors.Add(r3);
Writer.CompleteChunk();
var r4 = WriteDeleteCommit(r3);
_survivors.Add(r4);
Writer.CompleteChunk();
Scavenge(completeLast: false, mergeChunks: true);
Assert.AreEqual(13, _survivors.Count + _scavenged.Count);
}
protected override void WriteTestScenario()
{
var eventTypeId = LogFormatHelper <TLogFormat, TStreamId> .EventTypeId;
_event0 = WriteSingleEvent("ES", 0, "bla1");
Assert.True(_logFormat.StreamNameIndex.GetOrReserve("ES", out var esStreamId, out _, out _));
var prepare = LogRecord.DeleteTombstone(_recordFactory, WriterCheckpoint.ReadNonFlushed(), Guid.NewGuid(), Guid.NewGuid(),
esStreamId, eventTypeId, 1);
long pos;
Assert.IsTrue(Writer.Write(prepare, out pos));
_event1 = WriteSingleEvent("ES", 1, "bla1");
}
protected override void WriteTestScenario()
{
var firstEvent = WriteSingleEvent("ES1", 1, new string('.', 3000), eventId: Guid.NewGuid(),
eventType: "event-type-1", retryOnFail: true);
WriteSingleEvent("ES2", 1, new string('.', 3000), eventId: Guid.NewGuid(), eventType: "other-event-type-2",
retryOnFail: true);
WriteSingleEvent("ES3", 1, new string('.', 3000), eventId: Guid.NewGuid(), eventType: "event-type-3",
retryOnFail: true);
WriteSingleEvent("ES4", 1, new string('.', 3000), eventId: Guid.NewGuid(), eventType: "other-event-type-4",
retryOnFail: true);
_forwardReadPos = new TFPos(firstEvent.LogPosition, firstEvent.LogPosition);
_backwardReadPos = new TFPos(WriterCheckpoint.ReadNonFlushed(), WriterCheckpoint.ReadNonFlushed());
}
private void WriteV0HardDelete(string eventStreamId)
{
long pos;
var logPosition = WriterCheckpoint.ReadNonFlushed();
var prepare = new PrepareLogRecord(logPosition, Guid.NewGuid(), Guid.NewGuid(), logPosition, 0, eventStreamId,
int.MaxValue - 1, DateTime.UtcNow,
PrepareFlags.StreamDelete | PrepareFlags.TransactionBegin | PrepareFlags.TransactionEnd,
SystemEventTypes.StreamDeleted, new byte[0], new byte[0], prepareRecordVersion: LogRecordVersion.LogRecordV0);
Writer.Write(prepare, out pos);
var commit = new CommitLogRecord(WriterCheckpoint.ReadNonFlushed(), prepare.CorrelationId, prepare.LogPosition, DateTime.UtcNow, int.MaxValue,
commitRecordVersion: LogRecordVersion.LogRecordV0);
Writer.Write(commit, out pos);
}
public void other_prepares_cannot_be_committed()
{
var res = ReadIndex.IndexWriter.CheckCommitStartingAt(_prepare0.LogPosition, WriterCheckpoint.ReadNonFlushed());
Assert.AreEqual(CommitDecision.WrongExpectedVersion, res.Decision);
Assert.AreEqual("ES", res.EventStreamId);
Assert.AreEqual(0, res.CurrentVersion);
Assert.AreEqual(-1, res.StartEventNumber);
Assert.AreEqual(-1, res.EndEventNumber);
res = ReadIndex.IndexWriter.CheckCommitStartingAt(_prepare2.LogPosition, WriterCheckpoint.ReadNonFlushed());
Assert.AreEqual(CommitDecision.WrongExpectedVersion, res.Decision);
Assert.AreEqual("ES", res.EventStreamId);
Assert.AreEqual(0, res.CurrentVersion);
Assert.AreEqual(-1, res.StartEventNumber);
Assert.AreEqual(-1, res.EndEventNumber);
}
protected override void WriteTestScenario()
{
var t1 = WriteTransactionBeginV0(Guid.NewGuid(), WriterCheckpoint.ReadNonFlushed(), _streamIdOne,
ExpectedVersion.NoStream);
var t2 = WriteTransactionBeginV0(Guid.NewGuid(), WriterCheckpoint.ReadNonFlushed(), _streamIdTwo,
ExpectedVersion.NoStream);
_p1 = WriteTransactionEventV0(t1.CorrelationId, WriterCheckpoint.ReadNonFlushed(), t1.LogPosition, 0,
t1.EventStreamId, 0, "es1", PrepareFlags.Data);
_p2 = WriteTransactionEventV0(t2.CorrelationId, WriterCheckpoint.ReadNonFlushed(), t2.LogPosition, 0,
t2.EventStreamId, 0, "abc1", PrepareFlags.Data);
_p3 = WriteTransactionEventV0(t1.CorrelationId, WriterCheckpoint.ReadNonFlushed(), t1.LogPosition, 1,
t1.EventStreamId, 1, "es1", PrepareFlags.Data);
_p4 = WriteTransactionEventV0(t2.CorrelationId, WriterCheckpoint.ReadNonFlushed(), t2.LogPosition, 1,
t2.EventStreamId, 1, "abc1", PrepareFlags.Data);
_p5 = WriteTransactionEventV0(t1.CorrelationId, WriterCheckpoint.ReadNonFlushed(), t1.LogPosition, 2,
t1.EventStreamId, 2, "es1", PrepareFlags.Data);
WriteTransactionEndV0(t2.CorrelationId, WriterCheckpoint.ReadNonFlushed(), t2.TransactionPosition,
t2.EventStreamId);
WriteTransactionEndV0(t1.CorrelationId, WriterCheckpoint.ReadNonFlushed(), t1.TransactionPosition,
t1.EventStreamId);
_t2CommitPos = WriteCommitV0(t2.CorrelationId, WriterCheckpoint.ReadNonFlushed(), t2.TransactionPosition,
t2.EventStreamId, 0, out _postCommitPos);
_t1CommitPos = WriteCommitV0(t1.CorrelationId, WriterCheckpoint.ReadNonFlushed(), t1.TransactionPosition,
t1.EventStreamId, 0, out _postCommitPos);
Writer.CompleteChunk();
// Need to have a second chunk as otherwise the checkpoints will be off
_random1 = WriteSingleEventWithLogVersion0(Guid.NewGuid(), "random-stream",
WriterCheckpoint.ReadNonFlushed(), 0);
Scavenge(completeLast: false, mergeChunks: true);
}
protected override void WriteTestScenario()
{
long tmp;
var r2 = LogRecord.Prepare(WriterCheckpoint.ReadNonFlushed(),
Guid.NewGuid(),
Guid.NewGuid(),
WriterCheckpoint.ReadNonFlushed(),
0,
"s1",
-1,
PrepareFlags.Data | PrepareFlags.TransactionBegin,
"event-type",
new byte[3],
new byte[3]);
Assert.IsTrue(Writer.Write(r2, out tmp));
var r4 = WritePrepare("s2", -1);
var r5 = WriteCommit(r4.LogPosition, "s2", 0);
var r6 = WriteDelete("s2");
Writer.CompleteChunk();
var r7 = LogRecord.Prepare(WriterCheckpoint.ReadNonFlushed(),
Guid.NewGuid(),
Guid.NewGuid(),
r2.LogPosition,
1,
"s1",
-1,
PrepareFlags.Data | PrepareFlags.TransactionEnd,
"event-type",
new byte[3],
new byte[3]);
Assert.IsTrue(Writer.Write(r7, out tmp));
var r9 = WritePrepare("s3", -1);
var r10 = WriteCommit(r9.LogPosition, "s3", 0);
var r11 = WriteDelete("s3");
var r12 = WriteCommit(r2.LogPosition, "s1", 0);
var r13 = WriteDelete("s1");
Writer.CompleteChunk();
_survivors = new[]
{
r6.LogPosition,
r11.LogPosition,
r13.LogPosition
};
_scavenged = new[]
{
r2.LogPosition,
r4.LogPosition,
r5.LogPosition,
r7.LogPosition,
r9.LogPosition,
r10.LogPosition,
r12.LogPosition
};
Scavenge(completeLast: false, mergeChunks: true);
}
