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); }
public override void When() { _followers = new [] { Guid.NewGuid(), Guid.NewGuid(), Guid.NewGuid(), Guid.NewGuid() }; BecomeLeader(); // All of the nodes have acked the first write WriterCheckpoint.Write(_firstLogPosition); WriterCheckpoint.Flush(); Service.Handle(new ReplicationTrackingMessage.WriterCheckpointFlushed()); foreach (var follower in _followers) { Service.Handle(new ReplicationTrackingMessage.ReplicaWriteAck(follower, _firstLogPosition)); } AssertEx.IsOrBecomesTrue(() => Service.IsCurrent()); ReplicatedTos.Clear(); // Followers 3 and 4 are lagging behind, they ack the previous positions WriterCheckpoint.Write(_secondLogPosition); WriterCheckpoint.Flush(); Service.Handle(new ReplicationTrackingMessage.WriterCheckpointFlushed()); Service.Handle(new ReplicationTrackingMessage.ReplicaWriteAck(_followers[0], _secondLogPosition)); Service.Handle(new ReplicationTrackingMessage.ReplicaWriteAck(_followers[1], _secondLogPosition)); Service.Handle(new ReplicationTrackingMessage.ReplicaWriteAck(_followers[2], _firstLogPosition)); Service.Handle(new ReplicationTrackingMessage.ReplicaWriteAck(_followers[3], _firstLogPosition)); AssertEx.IsOrBecomesTrue(() => Service.IsCurrent()); }
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); }
private void ReOpenDb() { Db = new TFChunkDb(new TFChunkDbConfig(PathName, new VersionedPatternFileNamingStrategy(PathName, "chunk-"), 10000, 0, WriterCheckpoint, ChaserCheckpoint, new InMemoryCheckpoint(-1), new InMemoryCheckpoint(-1))); Db.Open(); TableIndex = new TableIndex(Path.Combine(PathName, "index"), () => new HashListMemTable(MaxEntriesInMemTable * 2), MaxEntriesInMemTable); ReadIndex = new ReadIndex(new NoopPublisher(), 2, 5, () => new TFChunkReader(Db, Db.Config.WriterCheckpoint), TableIndex, new ByLengthHasher(), new NoLRUCache <string, StreamCacheInfo>(), additionalCommitChecks: true, metastreamMaxCount: MetastreamMaxCount); ReadIndex.Init(WriterCheckpoint.Read(), ChaserCheckpoint.Read()); }
public void should_be_able_to_read_all_backwards() { var checkpoint = WriterCheckpoint.Read(); var pos = new TFPos(checkpoint, checkpoint); var result = ReadIndex.ReadAllEventsBackward(pos, 10); Assert.AreEqual(3, result.Records.Count); }
public void should_be_able_to_read_all_backwards_and_get_events_before_replication_checkpoint() { var checkpoint = WriterCheckpoint.Read(); var pos = new TFPos(checkpoint, checkpoint); var result = ReadIndex.ReadAllEventsBackward(pos, 10); Assert.AreEqual(2, result.Records.Count); }
public override void When() { BecomeLeader(); WriterCheckpoint.Write(_logPosition); WriterCheckpoint.Flush(); Service.Handle(new ReplicationTrackingMessage.WriterCheckpointFlushed()); AssertEx.IsOrBecomesTrue(() => Service.IsCurrent()); }
public override void When() { BecomeMaster(); WriterCheckpoint.Write(_logPosition); WriterCheckpoint.Flush(); Service.Handle(new ReplicationTrackingMessage.WriterCheckpointFlushed()); Service.Handle(new ReplicationTrackingMessage.ReplicaWriteAck(Guid.NewGuid(), _logPosition)); AssertEx.IsOrBecomesTrue(() => Service.IsIdle()); }
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"); }
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()); _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); }
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); }
public override void When() { BecomeMaster(); // All of the nodes have acked the first write WriterCheckpoint.Write(_firstLogPosition); WriterCheckpoint.Flush(); Service.Handle(new ReplicationTrackingMessage.WriterCheckpointFlushed()); Service.Handle(new ReplicationTrackingMessage.ReplicaWriteAck(_replica1, _firstLogPosition)); Service.Handle(new ReplicationTrackingMessage.ReplicaWriteAck(_replica2, _firstLogPosition - 100)); Service.Handle(new ReplicationTrackingMessage.ReplicaWriteAck(Guid.NewGuid(), _firstLogPosition - 100)); Service.Handle(new ReplicationTrackingMessage.ReplicaWriteAck(Guid.NewGuid(), _firstLogPosition - 100)); AssertEx.IsOrBecomesTrue(() => Service.IsCurrent()); }
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); }
public override void When() { BecomeMaster(); WriterCheckpoint.Write(_logPosition); WriterCheckpoint.Flush(); Service.Handle(new ReplicationTrackingMessage.WriterCheckpointFlushed()); Service.Handle(new ReplicationTrackingMessage.ReplicaWriteAck(_replicaId1, _logPosition)); Service.Handle(new SystemMessage.VNodeConnectionLost( PortsHelper.GetLoopback(), Guid.NewGuid(), _replicaId1)); Service.Handle(new ReplicationTrackingMessage.ReplicaWriteAck(_replicaId2, _logPosition)); AssertEx.IsOrBecomesTrue(() => Service.IsCurrent()); }
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); }
public override void When() { BecomeMaster(); WriterCheckpoint.Write(_logPosition); WriterCheckpoint.Flush(); Service.Handle(new ReplicationTrackingMessage.WriterCheckpointFlushed()); Service.Handle(new ReplicationTrackingMessage.ReplicaWriteAck(_replicaId1, _logPosition)); Service.Handle(new SystemMessage.VNodeConnectionLost( PortsHelper.GetLoopback(), Guid.NewGuid(), _replicaId1)); AssertEx.IsOrBecomesTrue(() => Service.IsCurrent()); //n.b. we still don't have quorum here //moving directly to log position 2 after rejoin WriterCheckpoint.Write(_logPosition2); WriterCheckpoint.Flush(); Service.Handle(new ReplicationTrackingMessage.ReplicaWriteAck(_replicaId1, _logPosition2)); Service.Handle(new ReplicationTrackingMessage.ReplicaWriteAck(_replicaId2, _logPosition2)); AssertEx.IsOrBecomesTrue(() => Service.IsCurrent()); }
public override void When() { BecomeLeader(); // All of the nodes have acked the first write WriterCheckpoint.Write(_firstLogPosition); WriterCheckpoint.Flush(); Service.Handle(new ReplicationTrackingMessage.WriterCheckpointFlushed()); Service.Handle(new ReplicationTrackingMessage.ReplicaWriteAck(_follower1, _firstLogPosition)); Service.Handle(new ReplicationTrackingMessage.ReplicaWriteAck(_follower2, _firstLogPosition)); AssertEx.IsOrBecomesTrue(() => Service.IsCurrent()); ReplicatedTos.Clear(); // Follower 2 has lost connection and does not ack the write WriterCheckpoint.Write(_secondLogPosition); WriterCheckpoint.Flush(); Service.Handle(new ReplicationTrackingMessage.WriterCheckpointFlushed()); Service.Handle(new ReplicationTrackingMessage.ReplicaWriteAck(_follower1, _secondLogPosition)); AssertEx.IsOrBecomesTrue(() => Service.IsCurrent()); }
public override void TestFixtureSetUp() { base.TestFixtureSetUp(); ReadIndex.Close(); ReadIndex.Dispose(); TableIndex.Close(removeFiles: false); TableIndex = new TableIndex(GetFilePathFor("index"), () => new HashListMemTable(maxSize: MaxEntriesInMemTable * 2), maxSizeForMemory: MaxEntriesInMemTable); ReadIndex = new ReadIndex(new NoopPublisher(), 2, 2, () => new TFChunkReader(Db, WriterCheckpoint, 0), TableIndex, new ByLengthHasher(), new NoLRUCache <string, StreamCacheInfo>(), additionalCommitChecks: true, metastreamMaxCount: 1); ReadIndex.Init(WriterCheckpoint.Read(), ChaserCheckpoint.Read()); }
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); }
public void checksums_should_be_equal_to_ack_checksum() { Assert.AreEqual(TruncateCheckpoint, WriterCheckpoint.Read()); Assert.AreEqual(TruncateCheckpoint, ChaserCheckpoint.Read()); }
public void checksums_should_be_equal_to_beginning_of_intersected_scavenged_chunk() { Assert.AreEqual(chunkEdge.TransactionPosition, WriterCheckpoint.Read()); Assert.AreEqual(chunkEdge.TransactionPosition, ChaserCheckpoint.Read()); }