public override void TestFixtureSetUp() { base.TestFixtureSetUp(); WriterCheckpoint = new InMemoryCheckpoint(0); var chaserchk = new InMemoryCheckpoint(Checkpoint.Chaser, 0); Db = new TFChunkDb(new TFChunkDbConfig(PathName, new VersionedPatternFileNamingStrategy(PathName, "chunk-"), 10000, 0, WriterCheckpoint, new[] {chaserchk})); Db.OpenVerifyAndClean(); // create db Writer = new TFChunkWriter(Db); Writer.Open(); WriteTestScenario(); Writer.Close(); Writer = null; WriterCheckpoint.Flush(); chaserchk.Write(WriterCheckpoint.Read()); chaserchk.Flush(); TableIndex = new TableIndex(Path.Combine(PathName, "index"), () => new HashListMemTable(), _maxEntriesInMemTable); TableIndex.Initialize(); var reader = new TFChunkReader(Db, Db.Config.WriterCheckpoint); ReadIndex = new ReadIndex(new NoopPublisher(), 2, () => new TFChunkSequentialReader(Db, Db.Config.WriterCheckpoint, 0), () => reader, TableIndex, new ByLengthHasher()); ReadIndex.Build(); }
public void try_read_does_not_cache_anything_and_returns_record_once_it_is_written_later() { var writerchk = new InMemoryCheckpoint(0); var config = new TransactionFileDatabaseConfig(PathName, "prefix.tf", 10000, writerchk, new ICheckpoint[0]); // create db var writer = new MultifileTransactionFileWriter(config); writer.Open(); var reader = new MultifileTransactionFileChaser(config); reader.Open(); LogRecord record; Assert.IsFalse(reader.TryReadNext(out record)); var rec = LogRecord.SingleWrite(0, Guid.NewGuid(), Guid.NewGuid(), "ES", -1, "ET", new byte[] { 7 }, null); long tmp; Assert.IsTrue(writer.Write(rec, out tmp)); writer.Flush(); writer.Close(); Assert.IsTrue(reader.TryReadNext(out record)); Assert.AreEqual(rec, record); reader.Close(); }
public void Setup() { _consumer = new TestHandler<Message>(); _bus = new InMemoryBus("temp"); _bus.Subscribe(_consumer); ICheckpoint writerCheckpoint = new InMemoryCheckpoint(1000); var ioDispatcher = new IODispatcher(_bus, new PublishEnvelope(_bus)); _readerService = new EventReaderCoreService(_bus, ioDispatcher, 10, writerCheckpoint, runHeadingReader: true); _subscriptionDispatcher = new ReaderSubscriptionDispatcher(_bus); _spoolProcessingResponseDispatcher = new SpooledStreamReadingDispatcher(_bus); _timeoutScheduler = new TimeoutScheduler(); _workerId = Guid.NewGuid(); _service = new ProjectionCoreService( _workerId, _bus, _bus, _subscriptionDispatcher, new RealTimeProvider(), ioDispatcher, _spoolProcessingResponseDispatcher, _timeoutScheduler); _bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.CheckpointSuggested>()); _bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.CommittedEventReceived>()); _bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.EofReached>()); _bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.PartitionEofReached>()); _bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.PartitionMeasured>()); _bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.PartitionDeleted>()); _bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.ProgressChanged>()); _bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.SubscriptionStarted>()); _bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.NotAuthorized>()); _bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.ReaderAssignedReader>()); _bus.Subscribe(_spoolProcessingResponseDispatcher.CreateSubscriber<PartitionProcessingResult>()); _readerService.Handle(new Messages.ReaderCoreServiceMessage.StartReader()); _service.Handle(new ProjectionCoreServiceMessage.StartCore()); }
public void a_record_can_be_written() { _checkpoint = new InMemoryCheckpoint(0); var tf = new MultifileTransactionFileWriter( new TransactionFileDatabaseConfig(PathName, "prefix.tf", 10000, _checkpoint, new List<ICheckpoint>())); tf.Open(); var record = new PrepareLogRecord(logPosition: 0, correlationId: _correlationId, eventId: _eventId, transactionPosition: 0, transactionOffset: 0, eventStreamId: "WorldEnding", expectedVersion: 1234, timeStamp: new DateTime(2012, 12, 21), flags: PrepareFlags.None, eventType: "type", data: new byte[] { 1, 2, 3, 4, 5 }, metadata: new byte[] {7, 17}); long tmp; tf.Write(record, out tmp); tf.Close(); Assert.AreEqual(record.GetSizeWithLengthPrefixAndSuffix(), _checkpoint.Read()); using (var filestream = File.Open(Path.Combine(PathName, "prefix.tf0"), FileMode.Open, FileAccess.Read)) { var reader = new BinaryReader(filestream); reader.ReadInt32(); var read = LogRecord.ReadFrom(reader); Assert.AreEqual(record, read); } }
public void a_record_can_be_written() { var filename = Path.Combine(PathName, "prefix.tf0"); File.WriteAllBytes(filename, new byte[10000]); _checkpoint = new InMemoryCheckpoint(137); var tf = new MultifileTransactionFileWriter(new TransactionFileDatabaseConfig(PathName, "prefix.tf", 10000, _checkpoint, new List<ICheckpoint>())); tf.Open(); var record = new PrepareLogRecord(logPosition: 0, correlationId: _correlationId, eventId: _eventId, expectedVersion: 1234, transactionPosition: 0, transactionOffset: 0, eventStreamId: "WorldEnding", timeStamp: new DateTime(2012, 12, 21), flags: PrepareFlags.None, eventType: "type", data: new byte[] { 1, 2, 3, 4, 5 }, metadata: new byte[] {7, 17}); long tmp; tf.Write(record, out tmp); tf.Flush(); tf.Close(); Assert.AreEqual(record.GetSizeWithLengthPrefixAndSuffix() + 137, _checkpoint.Read()); //137 is fluff assigned to beginning of checkpoint //TODO actually read the event using (var filestream = File.Open(filename, FileMode.Open, FileAccess.Read)) { filestream.Seek(137 + sizeof(int), SeekOrigin.Begin); var reader = new BinaryReader(filestream); var read = LogRecord.ReadFrom(reader); Assert.AreEqual(record, read); } }
public void SetUp() { _writerCheckpoint = new InMemoryCheckpoint(); _db = new TFChunkDb(new TFChunkDbConfig(PathName, new VersionedPatternFileNamingStrategy(PathName, "chunk-"), 1024, 0, _writerCheckpoint, new InMemoryCheckpoint(), new InMemoryCheckpoint(-1), new InMemoryCheckpoint(-1))); _db.Open(); _writer = new TFChunkWriter(_db); _writer.Open(); _record = new PrepareLogRecord(logPosition: 0, eventId: _eventId, correlationId: _correlationId, transactionPosition: 0xDEAD, transactionOffset: 0xBEEF, eventStreamId: "WorldEnding", expectedVersion: 1234, timeStamp: new DateTime(2012, 12, 21), flags: PrepareFlags.SingleWrite, eventType: "type", data: new byte[] { 1, 2, 3, 4, 5 }, metadata: new byte[] {7, 17}); long newPos; _writer.Write(_record, out newPos); _writer.Flush(); }
public void try_read_does_not_cache_anything_and_returns_record_once_it_is_written_later() { var writerchk = new InMemoryCheckpoint(0); var db = new TFChunkDb(new TFChunkDbConfig(PathName, new VersionedPatternFileNamingStrategy(PathName, "chunk-"), 10000, 0, writerchk, new InMemoryCheckpoint())); db.OpenVerifyAndClean(); var writer = new TFChunkWriter(db); writer.Open(); var reader = new TFChunkSequentialReader(db, writerchk, 0); LogRecord record; Assert.IsFalse(reader.TryReadNext(out record)); var rec = LogRecord.SingleWrite(0, Guid.NewGuid(), Guid.NewGuid(), "ES", -1, "ET", new byte[] { 7 }, null); long tmp; Assert.IsTrue(writer.Write(rec, out tmp)); writer.Flush(); writer.Close(); Assert.IsTrue(reader.TryReadNext(out record)); Assert.AreEqual(rec, record); reader.Close(); db.Close(); }
public void try_read_returns_false_when_writer_checksum_is_equal_to_reader_checksum() { var writerchk = new InMemoryCheckpoint(); var chaserchk = new InMemoryCheckpoint(Checkpoint.Chaser, 0); var db = new TFChunkDb(new TFChunkDbConfig(PathName, new PrefixFileNamingStrategy(PathName, "prefix.tf"), 10000, 0, writerchk, chaserchk, new[] {writerchk, chaserchk})); db.OpenVerifyAndClean(); writerchk.Write(12); writerchk.Flush(); chaserchk.Write(12); chaserchk.Flush(); var chaser = new TFChunkChaser(db, writerchk, chaserchk); chaser.Open(); LogRecord record; Assert.IsFalse(chaser.TryReadNext(out record)); Assert.AreEqual(12, chaserchk.Read()); chaser.Close(); db.Dispose(); }
public void try_read_returns_record_when_writerchecksum_ahead() { var writerchk = new InMemoryCheckpoint(128); var readerchk = new InMemoryCheckpoint("reader", 0); var config = new TransactionFileDatabaseConfig(PathName, "prefix.tf", 10000, writerchk, new[] {readerchk}); var recordToWrite = new PrepareLogRecord(logPosition: 0, correlationId: _correlationId, eventId: _eventId, transactionPosition: 0, eventStreamId: "WorldEnding", expectedVersion: 1234, timeStamp: new DateTime(2012, 12, 21), flags: PrepareFlags.None, eventType: "type", data: new byte[] {1, 2, 3, 4, 5}, metadata: new byte[] {7, 17}); using (var fs = new FileStream(Path.Combine(PathName, "prefix.tf0"), FileMode.CreateNew, FileAccess.Write)) { var writer = new BinaryWriter(fs); recordToWrite.WriteWithLengthPrefixTo(writer); fs.Close(); } var reader = new MultifileTransactionFileChaser(config, "reader"); reader.Open(); LogRecord record = null; var recordRead = reader.TryReadNext(out record); reader.Close(); Assert.AreEqual(record.GetSizeWithLengthPrefix(), readerchk.Read()); Assert.IsTrue(recordRead); Assert.AreEqual(recordToWrite, record); }
public void try_read_returns_false_when_writer_checksum_is_zero() { var writerchk = new InMemoryCheckpoint(0); var config = new TransactionFileDatabaseConfig(PathName, "prefix.tf", 10000, writerchk, new List<ICheckpoint>()); File.WriteAllBytes(Path.Combine(PathName, "prefix.tf0"), new byte[10000]); var reader = new MultifileTransactionFileChaser(config); reader.Open(); LogRecord record; Assert.IsFalse(reader.TryReadNext(out record)); reader.Close(); }
public void a_record_can_be_written() { var filename = Path.Combine(PathName, "prefix.tf0"); var chunkHeader = new ChunkHeader(TFChunk.CurrentChunkVersion, 10000, 0, 0, 0); var chunkBytes = chunkHeader.AsByteArray(); var buf = new byte[ChunkHeader.Size + ChunkFooter.Size + chunkHeader.ChunkSize]; Buffer.BlockCopy(chunkBytes, 0, buf, 0, chunkBytes.Length); File.WriteAllBytes(filename, buf); _checkpoint = new InMemoryCheckpoint(137); var db = new TFChunkDb(new TFChunkDbConfig(PathName, new PrefixFileNamingStrategy(PathName, "prefix.tf"), chunkHeader.ChunkSize, 0, _checkpoint, new ICheckpoint[0])); db.OpenVerifyAndClean(); var writer = new TFChunkWriter(db); var record = new PrepareLogRecord(logPosition: 0, correlationId: _correlationId, eventId: _eventId, transactionPosition: 0, transactionOffset: 0, eventStreamId: "WorldEnding", expectedVersion: 1234, timeStamp: new DateTime(2012, 12, 21), flags: PrepareFlags.None, eventType: "type", data: new byte[8000], metadata: new byte[] { 7, 17 }); Console.WriteLine(record.GetSizeWithLengthPrefixAndSuffix()); Console.WriteLine(record.GetSizeWithLengthPrefixAndSuffix() + 137); long pos; Assert.IsTrue(writer.Write(record, out pos)); writer.Close(); db.Dispose(); Assert.AreEqual(record.GetSizeWithLengthPrefixAndSuffix() + 137, _checkpoint.Read()); using (var filestream = File.Open(filename, FileMode.Open, FileAccess.Read)) { filestream.Seek(ChunkHeader.Size + 137 + sizeof(int), SeekOrigin.Begin); var reader = new BinaryReader(filestream); var read = LogRecord.ReadFrom(reader); Console.WriteLine(string.Join("\n", Directory.EnumerateFiles(PathName))); Assert.AreEqual(record, read); } }
public void a_record_can_be_written() { var filename = Path.Combine(PathName, "prefix.tf0"); var secondfilename = Path.Combine(PathName, "prefix.tf1"); var thirdfilename = Path.Combine(PathName, "prefix.tf2"); File.WriteAllBytes(filename, new byte[50]); _checkpoint = new InMemoryCheckpoint(40); var tf = new MultifileTransactionFileWriter( new TransactionFileDatabaseConfig(PathName, "prefix.tf", 50, _checkpoint, new ICheckpoint[0])); tf.Open(); var record = new PrepareLogRecord(logPosition: 0, correlationId: _correlationId, eventId: _eventId, transactionPosition: 0, transactionOffset: 0, eventStreamId: "WorldEnding", expectedVersion: 1234, timeStamp: new DateTime(2012, 12, 21), flags: PrepareFlags.None, eventType: "type", data: new byte[] { 1, 2, 3, 4, 5 }, metadata: new byte[] {7, 17}); long tmp; tf.Write(record, out tmp); tf.Close(); Assert.AreEqual(record.GetSizeWithLengthPrefixAndSuffix() + 40, _checkpoint.Read()); //+orginal checkpoint position Assert.IsTrue(File.Exists(secondfilename)); var stream = new MemoryStream(); var buffer = new byte[256]; using (var filestream = File.Open(filename, FileMode.Open, FileAccess.Read)) { filestream.Seek(40, SeekOrigin.Begin); filestream.Read(buffer, 0, 10); stream.Write(buffer, 0, 10); } using (var filestream = File.Open(secondfilename, FileMode.Open, FileAccess.Read)) { filestream.Seek(0, SeekOrigin.Begin); filestream.Read(buffer, 0, 50); stream.Write(buffer, 0, 50); } using (var filestream = File.Open(thirdfilename, FileMode.Open, FileAccess.Read)) { filestream.Seek(0, SeekOrigin.Begin); filestream.Read(buffer, 0, 50); stream.Write(buffer, 0, 50); } stream.Seek(0 + sizeof(int), SeekOrigin.Begin); var reader = new BinaryReader(stream); var read = LogRecord.ReadFrom(reader); Assert.AreEqual(record, read); }
public void try_read_returns_false_when_writer_checksum_is_equal_to_reader_checksum() { var writerchk = new InMemoryCheckpoint(12); var readerchk = new InMemoryCheckpoint("reader", 12); var config = new TransactionFileDatabaseConfig(PathName, "prefix.tf", 10000, writerchk, new[] {readerchk}); File.WriteAllBytes(Path.Combine(PathName, "prefix.tf0"), new byte[10000]); var reader = new MultifileTransactionFileChaser(config, "reader"); reader.Open(); LogRecord record; Assert.IsFalse(reader.TryReadNext(out record)); Assert.AreEqual(12, readerchk.Read()); reader.Close(); }
public void a_record_can_be_written() { var filename = GetFilePathFor("chunk-000000.000000"); var chunkHeader = new ChunkHeader(TFChunk.CurrentChunkVersion, 10000, 0, 0, false, Guid.NewGuid()); var chunkBytes = chunkHeader.AsByteArray(); var buf = new byte[ChunkHeader.Size + ChunkFooter.Size + chunkHeader.ChunkSize]; Buffer.BlockCopy(chunkBytes, 0, buf, 0, chunkBytes.Length); File.WriteAllBytes(filename, buf); _checkpoint = new InMemoryCheckpoint(137); var db = new TFChunkDb(new TFChunkDbConfig(PathName, new VersionedPatternFileNamingStrategy(PathName, "chunk-"), chunkHeader.ChunkSize, 0, _checkpoint, new InMemoryCheckpoint(), new InMemoryCheckpoint(-1), new InMemoryCheckpoint(-1))); db.Open(); var bytes = new byte[3994]; // this gives exactly 4097 size of record, with 3993 (rec size 4096) everything works fine! new Random().NextBytes(bytes); var writer = new TFChunkWriter(db); var record = new PrepareLogRecord(logPosition: 137, correlationId: _correlationId, eventId: _eventId, transactionPosition: 789, transactionOffset: 543, eventStreamId: "WorldEnding", expectedVersion: 1234, timeStamp: new DateTime(2012, 12, 21), flags: PrepareFlags.SingleWrite, eventType: "type", data: bytes, metadata: new byte[] { 0x07, 0x17 }); long pos; Assert.IsTrue(writer.Write(record, out pos)); writer.Close(); db.Dispose(); Assert.AreEqual(record.GetSizeWithLengthPrefixAndSuffix() + 137, _checkpoint.Read()); using (var filestream = File.Open(filename, FileMode.Open, FileAccess.Read)) { filestream.Seek(ChunkHeader.Size + 137 + sizeof(int), SeekOrigin.Begin); var reader = new BinaryReader(filestream); var read = LogRecord.ReadFrom(reader); Assert.AreEqual(record, read); } }
public void Setup() { _bus.Subscribe(_consumer); ICheckpoint writerCheckpoint = new InMemoryCheckpoint(1000); _readerService = new EventReaderCoreService( GetInputQueue(), _ioDispatcher, 10, writerCheckpoint, runHeadingReader: GivenHeadingReaderRunning()); _subscriptionDispatcher = new ReaderSubscriptionDispatcher(GetInputQueue()); _bus.Subscribe( _subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.CheckpointSuggested>()); _bus.Subscribe( _subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.CommittedEventReceived>()); _bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.EofReached>()); _bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.PartitionEofReached>()); _bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.PartitionMeasured>()); _bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.ProgressChanged>()); _bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.SubscriptionStarted>()); _bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.NotAuthorized>()); _bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.ReaderAssignedReader>()); _bus.Subscribe<ReaderCoreServiceMessage.StartReader>(_readerService); _bus.Subscribe<ReaderCoreServiceMessage.StopReader>(_readerService); _bus.Subscribe<ReaderCoreServiceMessage.ReaderTick>(_readerService); _bus.Subscribe<ReaderSubscriptionMessage.CommittedEventDistributed>(_readerService); _bus.Subscribe<ReaderSubscriptionMessage.EventReaderEof>(_readerService); _bus.Subscribe<ReaderSubscriptionMessage.EventReaderPartitionEof>(_readerService); _bus.Subscribe<ReaderSubscriptionMessage.EventReaderPartitionDeleted>(_readerService); _bus.Subscribe<ReaderSubscriptionMessage.EventReaderNotAuthorized>(_readerService); _bus.Subscribe<ReaderSubscriptionMessage.EventReaderIdle>(_readerService); _bus.Subscribe<ReaderSubscriptionMessage.EventReaderStarting>(_readerService); _bus.Subscribe<ReaderSubscriptionManagement.Pause>(_readerService); _bus.Subscribe<ReaderSubscriptionManagement.Resume>(_readerService); _bus.Subscribe<ReaderSubscriptionManagement.Subscribe>(_readerService); _bus.Subscribe<ReaderSubscriptionManagement.Unsubscribe>(_readerService); _bus.Subscribe<ReaderSubscriptionManagement.SpoolStreamReadingCore>(_readerService); _bus.Subscribe<ReaderSubscriptionManagement.CompleteSpooledStreamReading>(_readerService); GivenAdditionalServices(); _bus.Publish(new ReaderCoreServiceMessage.StartReader()); WhenLoop(); }
public void try_read_returns_false_when_writer_checksum_is_zero() { var writerchk = new InMemoryCheckpoint(0); var config = new TransactionFileDatabaseConfig(PathName, "prefix.tf", 10000, writerchk, new ICheckpoint[0]); // create db var writer = new MultifileTransactionFileWriter(config); writer.Open(); writer.Close(); var reader = new MultifileTransactionFileChaser(config); reader.Open(); LogRecord record; Assert.IsFalse(reader.TryReadNext(out record)); reader.Close(); }
public void a_record_can_be_written() { var filename = Path.Combine(PathName, "prefix.tf0"); var chunkHeader = new ChunkHeader(TFChunk.CurrentChunkVersion, 10000, 0, 0, 0); var chunkBytes = chunkHeader.AsByteArray(); var bytes = new byte[ChunkHeader.Size + 10000 + ChunkFooter.Size]; Buffer.BlockCopy(chunkBytes, 0, bytes, 0, chunkBytes.Length); File.WriteAllBytes(filename, bytes); _checkpoint = new InMemoryCheckpoint(137); var db = new TFChunkDb(new TFChunkDbConfig(PathName, new PrefixFileNamingStrategy(PathName, "prefix.tf"), 10000, 0, _checkpoint, new InMemoryCheckpoint(), new ICheckpoint[0])); db.OpenVerifyAndClean(); var tf = new TFChunkWriter(db); var record = new PrepareLogRecord(logPosition: 0, correlationId: _correlationId, eventId: _eventId, expectedVersion: 1234, transactionPosition: 0, transactionOffset: 0, eventStreamId: "WorldEnding", timeStamp: new DateTime(2012, 12, 21), flags: PrepareFlags.None, eventType: "type", data: new byte[] { 1, 2, 3, 4, 5 }, metadata: new byte[] { 7, 17 }); long tmp; tf.Write(record, out tmp); //tf.Flush(); tf.Close(); db.Dispose(); Assert.AreEqual(record.GetSizeWithLengthPrefixAndSuffix() + 137, _checkpoint.Read()); //137 is fluff assigned to beginning of checkpoint //TODO actually read the event using (var filestream = File.Open(filename, FileMode.Open, FileAccess.Read)) { filestream.Seek(ChunkHeader.Size + 137 + sizeof(int), SeekOrigin.Begin); var reader = new BinaryReader(filestream); var read = LogRecord.ReadFrom(reader); Assert.AreEqual(record, read); } }
public void try_read_returns_false_when_writer_checksum_is_zero() { var writerchk = new InMemoryCheckpoint(0); var db = new TFChunkDb(new TFChunkDbConfig(PathName, new VersionedPatternFileNamingStrategy(PathName, "chunk-"), 10000, 0, writerchk, new InMemoryCheckpoint())); db.OpenVerifyAndClean(); var reader = new TFChunkSequentialReader(db, writerchk, 0); LogRecord record; Assert.IsFalse(reader.TryReadNext(out record)); db.Close(); }
public void try_read_returns_false_when_writer_checksum_is_zero() { var writerchk = new InMemoryCheckpoint(0); var db = new TFChunkDb(new TFChunkDbConfig(PathName, new VersionedPatternFileNamingStrategy(PathName, "chunk-"), 10000, 0, writerchk, new InMemoryCheckpoint(), new InMemoryCheckpoint(-1), new InMemoryCheckpoint(-1))); db.Open(); var reader = new TFChunkReader(db, writerchk, 0); Assert.IsFalse(reader.TryReadNext().Success); db.Close(); }
public void can_read_a_record_straddling_multiple_files() { var writerchk = new InMemoryCheckpoint(20020); var readerchk = new InMemoryCheckpoint("reader", 9990); var config = new TransactionFileDatabaseConfig(PathName, "prefix.tf", 10000, writerchk, new[] {readerchk}); var recordToWrite = new PrepareLogRecord(logPosition: 0, correlationId: _correlationId, eventId: _eventId, transactionPosition: 0, transactionOffset: 0, eventStreamId: "WorldEnding", expectedVersion: 1234, timeStamp: new DateTime(2012, 12, 21), flags: PrepareFlags.None, eventType: "type", data: new byte[] { 1, 2, 3, 4, 5 }, metadata: new byte[] {7, 17}); var memstream = new MemoryStream(); var writer = new BinaryWriter(memstream); recordToWrite.WriteWithLengthPrefixAndSuffixTo(writer); var buf = memstream.GetBuffer(); using (var fs = new FileStream(config.FileNamingStrategy.GetFilenameFor(0), FileMode.CreateNew, FileAccess.Write)) { fs.Seek(9990, SeekOrigin.Begin); fs.Write(buf, 0, 10); fs.Close(); } using (var fs = new FileStream(config.FileNamingStrategy.GetFilenameFor(1), FileMode.CreateNew, FileAccess.Write)) { fs.Seek(0, SeekOrigin.Begin); fs.Write(buf, 10, recordToWrite.GetSizeWithLengthPrefixAndSuffix() - 10); fs.Close(); } var reader = new MultifileTransactionFileChaser(config, readerchk); reader.Open(); LogRecord record; var readRecord = reader.TryReadNext(out record); reader.Close(); Assert.IsTrue(readRecord); Assert.That(recordToWrite, Is.EqualTo(record)); Assert.AreEqual(9990 + recordToWrite.GetSizeWithLengthPrefixAndSuffix(), readerchk.Read()); }
public void Setup() { SetUpManualQueue(); _bus.Subscribe(_consumer); ICheckpoint writerCheckpoint = new InMemoryCheckpoint(1000); _readerService = new EventReaderCoreService( GetInputQueue(), 10, writerCheckpoint, runHeadingReader: GivenHeadingReaderRunning()); _subscriptionDispatcher = new PublishSubscribeDispatcher <ReaderSubscriptionManagement.Subscribe, ReaderSubscriptionManagement.ReaderSubscriptionManagementMessage, EventReaderSubscriptionMessage >(GetInputQueue(), v => v.SubscriptionId, v => v.SubscriptionId); _bus.Subscribe( _subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.CheckpointSuggested>()); _bus.Subscribe( _subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.CommittedEventReceived>()); _bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.EofReached>()); _bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.ProgressChanged>()); _bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.NotAuthorized>()); _bus.Subscribe<ReaderCoreServiceMessage.StartReader>(_readerService); _bus.Subscribe<ReaderCoreServiceMessage.StopReader>(_readerService); _bus.Subscribe<ReaderCoreServiceMessage.ReaderTick>(_readerService); _bus.Subscribe<ReaderSubscriptionMessage.CommittedEventDistributed>(_readerService); _bus.Subscribe<ReaderSubscriptionMessage.EventReaderEof>(_readerService); _bus.Subscribe<ReaderSubscriptionMessage.EventReaderNotAuthorized>(_readerService); _bus.Subscribe<ReaderSubscriptionMessage.EventReaderIdle>(_readerService); _bus.Subscribe<ReaderSubscriptionManagement.Pause>(_readerService); _bus.Subscribe<ReaderSubscriptionManagement.Resume>(_readerService); _bus.Subscribe<ReaderSubscriptionManagement.Subscribe>(_readerService); _bus.Subscribe<ReaderSubscriptionManagement.Unsubscribe>(_readerService); GivenAdditionalServices(); _bus.Publish(new ReaderCoreServiceMessage.StartReader()); WhenLoop(); }
public void should_not_read_buffered_data() { var writerchk = new InMemoryCheckpoint(0); var readerchk = new InMemoryCheckpoint("reader", 0); var config = new TransactionFileDatabaseConfig(PathName, "prefix.tf", 10000, writerchk, new List<ICheckpoint> {readerchk}); var fileName = Path.Combine(PathName, "prefix.tf0"); File.Create(fileName).Close(); var reader = new MultifileTransactionFileBulkRetriever(config); reader.Open(0); Assert.IsTrue(reader.ReadNextBulk().Length == 0); var bytes = new byte[100]; new Random().NextBytes(bytes); using (var f = new FileStream(fileName, FileMode.Append, FileAccess.Write, FileShare.ReadWrite)) { f.Write(bytes, 0, bytes.Length); f.Flush(flushToDisk: true); } writerchk.Write(bytes.Length); var readBytes = reader.ReadNextBulk(); Assert.AreEqual(bytes, readBytes); bytes = new byte[100]; new Random().NextBytes(bytes); using (var f = new FileStream(fileName, FileMode.Append, FileAccess.Write, FileShare.ReadWrite)) { f.Write(bytes, 0, bytes.Length); f.Flush(flushToDisk: true); } writerchk.Write(writerchk.Read() + bytes.Length); readBytes = reader.ReadNextBulk(); Assert.AreEqual(bytes, readBytes); reader.Close(); }
public void a_record_can_be_written() { _checkpoint = new InMemoryCheckpoint(0); var db = new TFChunkDb(new TFChunkDbConfig(PathName, new VersionedPatternFileNamingStrategy(PathName, "chunk-"), 1000, 0, _checkpoint, new InMemoryCheckpoint(), new InMemoryCheckpoint(-1), new InMemoryCheckpoint(-1))); db.Open(); var tf = new TFChunkWriter(db); tf.Open(); var record = new PrepareLogRecord(logPosition: 0, correlationId: _correlationId, eventId: _eventId, transactionPosition: 0, transactionOffset: 0, eventStreamId: "WorldEnding", expectedVersion: 1234, timeStamp: new DateTime(2012, 12, 21), flags: PrepareFlags.None, eventType: "type", data: new byte[] { 1, 2, 3, 4, 5 }, metadata: new byte[] { 7, 17 }); long tmp; tf.Write(record, out tmp); tf.Close(); db.Dispose(); Assert.AreEqual(record.GetSizeWithLengthPrefixAndSuffix(), _checkpoint.Read()); using (var filestream = File.Open(GetFilePathFor("chunk-000000.000000"), FileMode.Open, FileAccess.Read)) { filestream.Position = ChunkHeader.Size; var reader = new BinaryReader(filestream); reader.ReadInt32(); var read = LogRecord.ReadFrom(reader); Assert.AreEqual(record, read); } }
public void try_read_returns_false_when_writer_checkpoint_is_zero() { var writerchk = new InMemoryCheckpoint(0); var db = new TFChunkDb(new TFChunkDbConfig(PathName, new PrefixFileNamingStrategy(PathName, "prefix.tf"), 10000, 0, writerchk, new ICheckpoint[0])); db.OpenVerifyAndClean(); var chaser = new TFChunkChaser(db, writerchk, new InMemoryCheckpoint()); chaser.Open(); LogRecord record; Assert.IsFalse(chaser.TryReadNext(out record)); chaser.Close(); db.Dispose(); }
public void try_read_returns_false_when_writer_checkpoint_is_zero() { var writerchk = new InMemoryCheckpoint(0); var db = new TFChunkDb(new TFChunkDbConfig(PathName, new VersionedPatternFileNamingStrategy(PathName, "chunk-"), 10000, 0, writerchk, new InMemoryCheckpoint(), new InMemoryCheckpoint(-1), new InMemoryCheckpoint(-1))); db.Open(); var chaser = new TFChunkChaser(db, writerchk, new InMemoryCheckpoint()); chaser.Open(); LogRecord record; Assert.IsFalse(chaser.TryReadNext(out record)); chaser.Close(); db.Dispose(); }
public void SetUp() { _writerCheckpoint = new InMemoryCheckpoint(); _db = new TFChunkDb(new TFChunkDbConfig(PathName, new VersionedPatternFileNamingStrategy(PathName, "chunk-"), 1024, 0, _writerCheckpoint, new InMemoryCheckpoint(), new ICheckpoint[0])); _db.OpenVerifyAndClean(); _writer = new TFChunkWriter(_db); _writer.Open(); _record = new CommitLogRecord(logPosition: 0xFEED, correlationId: _eventId, transactionPosition: 4321, timeStamp: new DateTime(2012, 12, 21), firstEventNumber: 10); long newPos; _writer.Write(_record, out newPos); _writer.Flush(); }
public void a_record_is_not_written_at_first_but_written_on_second_try() { var filename1 = Path.Combine(PathName, "prefix.tf0"); var filename2 = Path.Combine(PathName, "prefix.tf1"); var chunkHeader = new ChunkHeader(TFChunk.CurrentChunkVersion, 10000, 0, 0, 0); var chunkBytes = chunkHeader.AsByteArray(); var bytes = new byte[ChunkHeader.Size + 10000 + ChunkFooter.Size]; Buffer.BlockCopy(chunkBytes, 0, bytes, 0, chunkBytes.Length); File.WriteAllBytes(filename1, bytes); _checkpoint = new InMemoryCheckpoint(0); var db = new TFChunkDb(new TFChunkDbConfig(PathName, new PrefixFileNamingStrategy(PathName, "prefix.tf"), 10000, 0, _checkpoint, new ICheckpoint[0])); db.OpenVerifyAndClean(); var tf = new TFChunkWriter(db); long pos; var record1 = new PrepareLogRecord(logPosition: 0, correlationId: _correlationId, eventId: _eventId, expectedVersion: 1234, transactionPosition: 0, transactionOffset: 0, eventStreamId: "WorldEnding", timeStamp: new DateTime(2012, 12, 21), flags: PrepareFlags.None, eventType: "type", data: new byte[] { 1, 2, 3, 4, 5 }, metadata: new byte[8000]); Assert.IsTrue(tf.Write(record1, out pos)); // almost fill up first chunk var record2 = new PrepareLogRecord(logPosition: pos, correlationId: _correlationId, eventId: _eventId, expectedVersion: 1234, transactionPosition: pos, transactionOffset: 0, eventStreamId: "WorldEnding", timeStamp: new DateTime(2012, 12, 21), flags: PrepareFlags.None, eventType: "type", data: new byte[] { 1, 2, 3, 4, 5 }, metadata: new byte[8000]); Assert.IsFalse(tf.Write(record2, out pos)); // chunk has too small space var record3 = new PrepareLogRecord(logPosition: pos, correlationId: _correlationId, eventId: _eventId, expectedVersion: 1234, transactionPosition: pos, transactionOffset: 0, eventStreamId: "WorldEnding", timeStamp: new DateTime(2012, 12, 21), flags: PrepareFlags.None, eventType: "type", data: new byte[] { 1, 2, 3, 4, 5 }, metadata: new byte[2000]); Assert.IsTrue(tf.Write(record3, out pos)); tf.Close(); db.Dispose(); Assert.AreEqual(record3.GetSizeWithLengthPrefixAndSuffix() + 10000, _checkpoint.Read()); using (var filestream = File.Open(filename2, FileMode.Open, FileAccess.Read)) { filestream.Seek(ChunkHeader.Size + sizeof(int), SeekOrigin.Begin); var reader = new BinaryReader(filestream); var read = LogRecord.ReadFrom(reader); Assert.AreEqual(record3, read); } }
private void SetUpCoreServices( Guid workerId, IBus bus, IPublisher inputQueue, InMemoryBus output_, ISingletonTimeoutScheduler timeoutScheduler) { var output = (output_ ?? inputQueue); ICheckpoint writerCheckpoint = new InMemoryCheckpoint(1000); var readerService = new EventReaderCoreService( output, _ioDispatcher, 10, writerCheckpoint, runHeadingReader: true); _subscriptionDispatcher = new ReaderSubscriptionDispatcher(inputQueue); var spoolProcessingResponseDispatcher = new SpooledStreamReadingDispatcher(GetInputQueue()); bus.Subscribe( _subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.CheckpointSuggested>()); bus.Subscribe( _subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.CommittedEventReceived>()); bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.EofReached>()); bus.Subscribe( _subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.PartitionEofReached>()); bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.PartitionMeasured>()); bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.PartitionDeleted>()); bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.ProgressChanged>()); bus.Subscribe( _subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.SubscriptionStarted>()); bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.NotAuthorized>()); bus.Subscribe( _subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.ReaderAssignedReader>()); bus.Subscribe(spoolProcessingResponseDispatcher.CreateSubscriber<PartitionProcessingResult>()); var ioDispatcher = new IODispatcher(output, new PublishEnvelope(inputQueue)); // var coreServiceCommandReader = new ProjectionCoreServiceCommandReader( // output, // ioDispatcher, // workerId.ToString("N")); var coreService = new ProjectionCoreService( workerId, inputQueue, output, _subscriptionDispatcher, _timeProvider, ioDispatcher, spoolProcessingResponseDispatcher, timeoutScheduler); bus.Subscribe<CoreProjectionManagementMessage.CreateAndPrepare>(coreService); bus.Subscribe<CoreProjectionManagementMessage.CreatePrepared>(coreService); bus.Subscribe<CoreProjectionManagementMessage.CreateAndPrepareSlave>(coreService); bus.Subscribe<CoreProjectionManagementMessage.Dispose>(coreService); bus.Subscribe<CoreProjectionManagementMessage.Start>(coreService); bus.Subscribe<CoreProjectionManagementMessage.LoadStopped>(coreService); bus.Subscribe<CoreProjectionManagementMessage.Stop>(coreService); bus.Subscribe<CoreProjectionManagementMessage.Kill>(coreService); bus.Subscribe<CoreProjectionManagementMessage.GetState>(coreService); bus.Subscribe<CoreProjectionManagementMessage.GetResult>(coreService); bus.Subscribe<CoreProjectionProcessingMessage.CheckpointCompleted>(coreService); bus.Subscribe<CoreProjectionProcessingMessage.CheckpointLoaded>(coreService); bus.Subscribe<CoreProjectionProcessingMessage.PrerecordedEventsLoaded>(coreService); bus.Subscribe<CoreProjectionProcessingMessage.RestartRequested>(coreService); bus.Subscribe<CoreProjectionProcessingMessage.Failed>(coreService); bus.Subscribe<ClientMessage.ReadStreamEventsForwardCompleted>(ioDispatcher.ForwardReader); bus.Subscribe<ClientMessage.ReadStreamEventsBackwardCompleted>(ioDispatcher.BackwardReader); bus.Subscribe<ClientMessage.WriteEventsCompleted>(ioDispatcher.Writer); bus.Subscribe<ClientMessage.DeleteStreamCompleted>(ioDispatcher.StreamDeleter); bus.Subscribe<IODispatcherDelayedMessage>(ioDispatcher.Awaker); bus.Subscribe<IODispatcherDelayedMessage>(ioDispatcher); bus.Subscribe<ProjectionCoreServiceMessage.StartCore>(coreService); bus.Subscribe<ProjectionCoreServiceMessage.StopCore>(coreService); bus.Subscribe<ReaderCoreServiceMessage.StartReader>(readerService); bus.Subscribe<ReaderCoreServiceMessage.StopReader>(readerService); bus.Subscribe<ProjectionCoreServiceMessage.CoreTick>(coreService); bus.Subscribe<ProjectionManagementMessage.SlaveProjectionsStarted>(coreService); bus.Subscribe<ReaderCoreServiceMessage.ReaderTick>(readerService); bus.Subscribe<ReaderSubscriptionMessage.CommittedEventDistributed>(readerService); bus.Subscribe<ReaderSubscriptionMessage.EventReaderEof>(readerService); bus.Subscribe<ReaderSubscriptionMessage.EventReaderPartitionEof>(readerService); bus.Subscribe<ReaderSubscriptionMessage.EventReaderPartitionDeleted>(readerService); bus.Subscribe<ReaderSubscriptionMessage.EventReaderPartitionMeasured>(readerService); bus.Subscribe<ReaderSubscriptionMessage.EventReaderNotAuthorized>(readerService); bus.Subscribe<ReaderSubscriptionMessage.EventReaderIdle>(readerService); bus.Subscribe<ReaderSubscriptionMessage.EventReaderStarting>(readerService); bus.Subscribe<ReaderSubscriptionManagement.Pause>(readerService); bus.Subscribe<ReaderSubscriptionManagement.Resume>(readerService); bus.Subscribe<ReaderSubscriptionManagement.Subscribe>(readerService); bus.Subscribe<ReaderSubscriptionManagement.Unsubscribe>(readerService); bus.Subscribe<ReaderSubscriptionManagement.SpoolStreamReadingCore>(readerService); bus.Subscribe<ReaderSubscriptionManagement.CompleteSpooledStreamReading>(readerService); if (output_ != null) { bus.Subscribe(new UnwrapEnvelopeHandler()); output_.Subscribe(Forwarder.Create<CoreProjectionStatusMessage.StateReport>(GetInputQueue())); output_.Subscribe(Forwarder.Create<CoreProjectionStatusMessage.ResultReport>(GetInputQueue())); output_.Subscribe(Forwarder.Create<CoreProjectionStatusMessage.StatisticsReport>(GetInputQueue())); output_.Subscribe(Forwarder.Create<CoreProjectionStatusMessage.Started>(GetInputQueue())); output_.Subscribe(Forwarder.Create<CoreProjectionStatusMessage.Stopped>(GetInputQueue())); output_.Subscribe(Forwarder.Create<CoreProjectionStatusMessage.Faulted>(GetInputQueue())); output_.Subscribe(Forwarder.Create<CoreProjectionStatusMessage.Prepared>(GetInputQueue())); output_.Subscribe( Forwarder.Create<CoreProjectionManagementMessage.SlaveProjectionReaderAssigned>(GetInputQueue())); output_.Subscribe(Forwarder.Create<CoreProjectionStatusMessage.ProjectionWorkerStarted>(GetInputQueue())); output_.Subscribe(Forwarder.Create<ProjectionManagementMessage.Command.ControlMessage>(GetInputQueue())); output_.Subscribe(Forwarder.Create<AwakeServiceMessage.SubscribeAwake>(GetInputQueue())); output_.Subscribe(Forwarder.Create<AwakeServiceMessage.UnsubscribeAwake>(GetInputQueue())); output_.Subscribe(Forwarder.Create<PartitionProcessingResultBase>(GetInputQueue())); output_.Subscribe(Forwarder.Create<ReaderSubscriptionManagement.SpoolStreamReading>(GetInputQueue())); output_.Subscribe(Forwarder.Create<PartitionProcessingResultOutputBase>(GetInputQueue())); output_.Subscribe(Forwarder.Create<Message>(inputQueue)); // forward all var forwarder = new RequestResponseQueueForwarder( inputQueue: inputQueue, externalRequestQueue: GetInputQueue()); // forwarded messages output_.Subscribe<ClientMessage.ReadEvent>(forwarder); output_.Subscribe<ClientMessage.ReadStreamEventsBackward>(forwarder); output_.Subscribe<ClientMessage.ReadStreamEventsForward>(forwarder); output_.Subscribe<ClientMessage.ReadAllEventsForward>(forwarder); output_.Subscribe<ClientMessage.WriteEvents>(forwarder); } }
private static TFChunkDbConfig CreateDbConfig(int chunkSize, string dbPath, long chunksCacheSize, bool inMemDb) { ICheckpoint writerChk; ICheckpoint chaserChk; ICheckpoint epochChk; ICheckpoint truncateChk; if (inMemDb) { writerChk = new InMemoryCheckpoint(Checkpoint.Writer); chaserChk = new InMemoryCheckpoint(Checkpoint.Chaser); epochChk = new InMemoryCheckpoint(Checkpoint.Epoch, initValue: -1); truncateChk = new InMemoryCheckpoint(Checkpoint.Truncate, initValue: -1); } else { var writerCheckFilename = Path.Combine(dbPath, Checkpoint.Writer + ".chk"); var chaserCheckFilename = Path.Combine(dbPath, Checkpoint.Chaser + ".chk"); var epochCheckFilename = Path.Combine(dbPath, Checkpoint.Epoch + ".chk"); var truncateCheckFilename = Path.Combine(dbPath, Checkpoint.Truncate + ".chk"); if (Runtime.IsMono) { writerChk = new FileCheckpoint(writerCheckFilename, Checkpoint.Writer, cached: true); chaserChk = new FileCheckpoint(chaserCheckFilename, Checkpoint.Chaser, cached: true); epochChk = new FileCheckpoint(epochCheckFilename, Checkpoint.Epoch, cached: true, initValue: -1); truncateChk = new FileCheckpoint(truncateCheckFilename, Checkpoint.Truncate, cached: true, initValue: -1); } else { writerChk = new MemoryMappedFileCheckpoint(writerCheckFilename, Checkpoint.Writer, cached: true); chaserChk = new MemoryMappedFileCheckpoint(chaserCheckFilename, Checkpoint.Chaser, cached: true); epochChk = new MemoryMappedFileCheckpoint(epochCheckFilename, Checkpoint.Epoch, cached: true, initValue: -1); truncateChk = new MemoryMappedFileCheckpoint(truncateCheckFilename, Checkpoint.Truncate, cached: true, initValue: -1); } } var nodeConfig = new TFChunkDbConfig(dbPath, new VersionedPatternFileNamingStrategy(dbPath, "chunk-"), chunkSize, chunksCacheSize, writerChk, chaserChk, epochChk, truncateChk, inMemDb); return nodeConfig; }
public void try_read_returns_properly_when_writer_is_written_to_while_chasing() { var writerchk = new InMemoryCheckpoint(0); var readerchk = new InMemoryCheckpoint("reader", 0); var config = new TransactionFileDatabaseConfig(PathName, "prefix.tf", 10000, writerchk, new[] {readerchk}); var fileName = Path.Combine(PathName, "prefix.tf0"); File.Create(fileName).Close(); var reader = new MultifileTransactionFileChaser(config, "reader"); reader.Open(); LogRecord record; Assert.IsFalse(reader.TryReadNext(out record)); var recordToWrite = new PrepareLogRecord(logPosition: 0, correlationId: _correlationId, eventId: _eventId, transactionPosition: 0, eventStreamId: "WorldEnding", expectedVersion: 1234, timeStamp: new DateTime(2012, 12, 21), flags: PrepareFlags.None, eventType: "type", data: new byte[] { 1, 2, 3, 4, 5 }, metadata: new byte[] {7, 17}); var memstream = new MemoryStream(); var writer = new BinaryWriter(memstream); recordToWrite.WriteWithLengthPrefixTo(writer); using (var fs = new FileStream(fileName, FileMode.Append, FileAccess.Write, FileShare.ReadWrite)) { fs.Write(memstream.ToArray(), 0, (int)memstream.Length); fs.Flush(flushToDisk: true); } writerchk.Write(memstream.Length); Assert.IsTrue(reader.TryReadNext(out record)); Assert.AreEqual(record, recordToWrite); var recordToWrite2 = new PrepareLogRecord(logPosition: 0, correlationId: _correlationId, eventId: _eventId, transactionPosition: 0, eventStreamId: "WorldEnding", expectedVersion: 4321, timeStamp: new DateTime(2012, 12, 21), flags: PrepareFlags.None, eventType: "type", data: new byte[] { 3, 2, 1 }, metadata: new byte[] {9}); memstream.SetLength(0); recordToWrite2.WriteWithLengthPrefixTo(writer); using (var fs = new FileStream(fileName, FileMode.Append, FileAccess.Write, FileShare.ReadWrite)) { fs.Write(memstream.ToArray(), 0, (int) memstream.Length); fs.Flush(flushToDisk: true); } writerchk.Write(writerchk.Read() + memstream.Length); Assert.IsTrue(reader.TryReadNext(out record)); Assert.AreEqual(record, recordToWrite2); reader.Close(); }