public void SurvivesListVsIList() { var manager = new EventStoreManager(); manager.SetNewTypeNameMapper(new OverloadableTypeMapper(typeof(SomethingWithoutList), "Some")); var file = new MemoryEventFileStorage(); var file2 = new MemoryEventFileStorage(); var appender = manager.AppendToStore(file); var ev = new SomethingWithList(); appender.Store(null, new object[] { ev }); var ev2 = new SomethingWithNestedIList { B = new Dictionary <ulong, IList <string> > { { 1, new List <string> { "a1" } } } }; appender.Store(null, new object[] { ev2 }); var appender2 = manager.AppendToStore(file); appender2.Store(null, new object[] { ev2 }); manager = new EventStoreManager(); manager.SetNewTypeNameMapper(new OverloadableTypeMapper(typeof(SomethingWithList), "Some")); var reader = manager.OpenReadOnlyStore(file); var eventObserver = new StoringEventObserver(); reader.ReadFromStartToEnd(eventObserver); reader = manager.OpenReadOnlyStore(file2); reader.ReadFromStartToEnd(eventObserver); }
public void CustomEventIsReadFromSecondSplit() { var manager = new EventStoreManager(); manager.CompressionStrategy = new NoCompressionStrategy(); manager.SetNewTypeNameMapper(new SimplePersonTypeMapper()); var appender = manager.AppendToStore(new MemoryEventFileStorage(4096, 4096)); var first = appender.CurrentFileStorage; var user = new User { Name = "A", Age = 1 }; while (appender.CurrentFileStorage == first) { appender.Store(null, new object[] { user }); } var second = appender.CurrentFileStorage; manager = new EventStoreManager(); manager.CompressionStrategy = new NoCompressionStrategy(); manager.SetNewTypeNameMapper(new SimplePersonTypeMapper()); var reader = manager.OpenReadOnlyStore(second); var eventObserver = new StoringEventObserver(); reader.ReadFromStartToEnd(eventObserver); Assert.Equal(new object[] { null }, eventObserver.Metadata); Assert.Equal(new[] { new object[] { user } }, eventObserver.Events); }
static object PassThroughEventStorage(object @event, ITypeNameMapper mapper) { var options = TypeSerializersOptions.Default; options.SymmetricCipher = new AesGcmSymmetricCipher(new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31 }); var manager = new EventStoreManager(options); var storage = new MemoryEventFileStorage(); var appender = manager.AppendToStore(storage); var events = new[] { @event }; appender.Store(null, events); manager = new EventStoreManager(options); manager.SetNewTypeNameMapper(mapper); var eventObserver = new EventStoreTest.StoringEventObserver(); manager.OpenReadOnlyStore(storage).ReadFromStartToEnd(eventObserver); return(eventObserver.Events[0][0]); }
public void SkipListOnUpgrade() { var manager = new EventStoreManager(); manager.SetNewTypeNameMapper(new OverloadableTypeMapper(typeof(UserEventList), "UserEvent")); var file = new MemoryEventFileStorage(); var appender = manager.AppendToStore(file); var userA = new User { Name = "A", Age = 1 }; var userB = new User { Name = "B", Age = 2 }; var userEvent = new UserEventList { Id = 10, List = new List <User> { userA, userB, userA } }; appender.Store(null, new object[] { userEvent }); manager = new EventStoreManager(); manager.SetNewTypeNameMapper(new OverloadableTypeMapper(typeof(UserEvent), "UserEvent")); var reader = manager.OpenReadOnlyStore(file); var eventObserver = new StoringEventObserver(); reader.ReadFromStartToEnd(eventObserver); var readUserEvent = (UserEvent)eventObserver.Events[0][0]; Assert.Equal(10, readUserEvent.Id); Assert.Null(readUserEvent.User1); }
public void UpgradeToLessObjectProperties() { var manager = new EventStoreManager(); manager.SetNewTypeNameMapper(new OverloadableTypeMapper(typeof(UserEvent), "UserEvent")); var file = new MemoryEventFileStorage(); var appender = manager.AppendToStore(file); var user = new User { Name = "A", Age = 1 }; var userEvent = new UserEvent { Id = 10, User1 = user, User2 = user }; appender.Store(null, new object[] { userEvent, new User { Name = "B" } }); manager = new EventStoreManager(); manager.SetNewTypeNameMapper(new OverloadableTypeMapper(typeof(UserEventLess), "UserEvent")); var reader = manager.OpenReadOnlyStore(file); var eventObserver = new StoringEventObserver(); reader.ReadFromStartToEnd(eventObserver); var readUserEvent = (UserEventLess)eventObserver.Events[0][0]; Assert.Equal("A", readUserEvent.User2.Name); Assert.Equal(10, readUserEvent.Id); Assert.Equal("B", ((User)eventObserver.Events[0][1]).Name); }
public void CanReadLongerEventsFromIncompleteFile() { var manager = new EventStoreManager(); manager.CompressionStrategy = new NoCompressionStrategy(); var file1 = new MemoryEventFileStorage(); var appender = manager.AppendToStore(file1); appender.Store(null, new object[] { new byte[8000] }); var file2 = new MemoryEventFileStorage(); var buf = ByteBuffer.NewSync(new byte[4096]); file1.Read(buf, 0); file2.Write(buf, 0); var reader = manager.OpenReadOnlyStore(file2); reader.ReadFromStartToEnd(new SkippingEventObserver()); Assert.False(reader.IsKnownAsCorrupted()); Assert.False(reader.IsKnownAsAppendable()); Assert.False(reader.IsKnownAsFinished()); buf = ByteBuffer.NewSync(new byte[4096]); file1.Read(buf, 4096); file2.Write(buf, 4096); reader.ReadToEnd(new SkippingEventObserver()); Assert.False(reader.IsKnownAsCorrupted()); Assert.True(reader.IsKnownAsAppendable()); Assert.False(reader.IsKnownAsFinished()); }
public void Run() { var manager = new EventStoreManager(); //manager.CompressionStrategy = new NoCompressionStrategy(); using (var stream = new FileStream("0.event", FileMode.Create, FileAccess.ReadWrite, FileShare.None, 1)) { var file = new StreamEventFileStorage(stream); _writeStore = manager.AppendToStore(file); var consumerTask = Task.Factory.StartNew(EventConsumer, TaskCreationOptions.LongRunning | TaskCreationOptions.HideScheduler); _sw.Start(); var tasks = new Task[ParallelTasks]; Parallel.For(0, tasks.Length, i => { tasks[i] = PublishSampleEvents(RepetitionCount); }); Task.WaitAll(tasks); _bc.CompleteAdding(); consumerTask.Wait(); _sw.Stop(); Console.WriteLine("Write {0}ms events per second:{1:f0} total len:{2}", _sw.ElapsedMilliseconds, tasks.Length * RepetitionCount / _sw.Elapsed.TotalSeconds, stream.Length); _sw.Restart(); var allObserverCounter = new AllObserverCounter(); manager.OpenReadOnlyStore(file).ReadFromStartToEnd(allObserverCounter); _sw.Stop(); Console.WriteLine("Read {0}ms events per second:{1:f0} events:{2}", _sw.ElapsedMilliseconds, allObserverCounter.Count / _sw.Elapsed.TotalSeconds, allObserverCounter.Count); } }
public void SupportsDictionary() { var manager = new EventStoreManager(); var file = new MemoryEventFileStorage(); var appender = manager.AppendToStore(file); var userA = new User { Name = "A", Age = 1 }; var userB = new User { Name = "B", Age = 2 }; var userEvent = new UserEventDictionary { Id = 10, Dict = new Dictionary <string, User> { { "A", userA }, { "B", userB } } }; appender.Store(null, new object[] { userEvent }); manager = new EventStoreManager(); var reader = manager.OpenReadOnlyStore(file); var eventObserver = new StoringEventObserver(); reader.ReadFromStartToEnd(eventObserver); var readUserEvent = (UserEventDictionary)eventObserver.Events[0][0]; Assert.Equal(readUserEvent, userEvent); }
public void CanStoreNullable() { var testEvent = new EventWithNullable { EventId = 1, NullableInt = 42, ListWithNullables = new List <int?> { 4, new int?() }, DictionaryWithNullables = new Dictionary <int?, bool?> { { 1, true }, { 2, new bool?() } } }; var manager = new EventStoreManager(); var appender = manager.AppendToStore(new MemoryEventFileStorage()); appender.Store(null, new object[] { testEvent }); var eventObserver = new StoringEventObserver(); appender.ReadFromStartToEnd(eventObserver); Assert.Equal(new object[] { null }, eventObserver.Metadata); var ev = eventObserver.Events[0][0] as EventWithNullable; Assert.Equal(42, ev.NullableInt.Value); Assert.False(ev.NullableEmpty.HasValue); Assert.Equal(2, ev.ListWithNullables.Count); Assert.Equal(4, ev.ListWithNullables[0].Value); Assert.False(ev.ListWithNullables[1].HasValue); Assert.Equal(2, ev.DictionaryWithNullables.Count); Assert.True(ev.DictionaryWithNullables[1]); Assert.False(ev.DictionaryWithNullables[2].HasValue); }
public void TypeMapperCanForceSkipEvents() { var manager = new EventStoreManager(); manager.SetNewTypeNameMapper(new FullNameTypeMapper()); var file = new MemoryEventFileStorage(); var appender = manager.AppendToStore(file); var user = new User { Name = "ABC", Age = 88 }; var userEvent = new UserEvent { Id = 10, User1 = user, User2 = user }; var userEventMore = new UserEventMore { Id = 11, User1 = user, User2 = user }; appender.Store(null, new object[] { userEvent, userEventMore }); manager = new EventStoreManager(); manager.SetNewTypeNameMapper(new SelectiveTypeMapper("BTDBTest.EventStoreTest+UserEvent")); var reader = manager.OpenReadOnlyStore(file); var eventObserver = new SimpleEventObserver(); reader.ReadFromStartToEnd(eventObserver); Assert.Single(eventObserver.Events[0]); var readUserEvent = (UserEventMore)eventObserver.Events[0][0]; Assert.Same(readUserEvent.User1, readUserEvent.User2); }
public void CanStopReadBatchesAfterFirst() { var manager = new EventStoreManager(); var file = new MemoryEventFileStorage(); var appender = manager.AppendToStore(file); var metadata = new User { Name = "A", Age = 1 }; var events = new object[] { new User { Name = "B", Age = 2 }, new User { Name = "C", Age = 3 } }; appender.Store(metadata, events); appender.Store(metadata, events); var reader = manager.OpenReadOnlyStore(file); var eventObserver = new StoringEventObserverWithStop(); reader.ReadFromStartToEnd(eventObserver); Assert.False(reader.IsKnownAsCorrupted()); Assert.False(reader.IsKnownAsFinished()); Assert.False(reader.IsKnownAsAppendable()); Assert.Equal(new List <object> { metadata }, eventObserver.Metadata); Assert.Equal(new[] { events }, eventObserver.Events); }
public void SupportsList() { var manager = new EventStoreManager(); var file = new MemoryEventFileStorage(); var appender = manager.AppendToStore(file); var userA = new User { Name = "A", Age = 1 }; var userB = new User { Name = "B", Age = 2 }; var userEvent = new UserEventList { Id = 10, List = new List <User> { userA, userB, userA } }; appender.Store(null, new object[] { userEvent }); manager = new EventStoreManager(); var reader = manager.OpenReadOnlyStore(file); var eventObserver = new StoringEventObserver(); reader.ReadFromStartToEnd(eventObserver); var readUserEvent = (UserEventList)eventObserver.Events[0][0]; Assert.Equal(readUserEvent, userEvent); }
public void CanFinalizeEventStore() { var manager = new EventStoreManager(); var appender = manager.AppendToStore(new MemoryEventFileStorage()); appender.FinalizeStore(); Assert.False(appender.IsKnownAsAppendable()); Assert.False(appender.IsKnownAsCorrupted()); Assert.True(appender.IsKnownAsFinished()); }
public void CreatesNewFileWhenOldOneIsFull() { var manager = new EventStoreManager(); var appender = manager.AppendToStore(new MemoryEventFileStorage()); appender.Store(null, new object[] { 1 }); appender.ReadFromStartToEnd(new SkippingEventObserver()); appender.FinalizeStore(); Assert.False(appender.IsKnownAsAppendable()); Assert.False(appender.IsKnownAsCorrupted()); Assert.True(appender.IsKnownAsFinished()); }
public void CanFinalizeEventStoreOnEverySectorPosition() { for (int i = 4000; i < 4600; i++) { var manager = new EventStoreManager(); manager.CompressionStrategy = new NoCompressionStrategy(); var file1 = new MemoryEventFileStorage(4096, 8192); var appender = manager.AppendToStore(file1); appender.Store(null, new object[] { new byte[i] }); appender.Store(null, new object[] { new byte[7000] }); } }
public void WhenReadOnlyStoreIsCreatedFromNewEventStoreManagerThenItShouldNotLeakMemory() { var storage = new MemoryEventFileStorage(); var manager = new EventStoreManager(); var appender = manager.AppendToStore(storage); var metadata = new User { Name = "A", Age = 1 }; var events = new object[] { new User { Name = "B", Age = 2 }, new User { Name = "C", Age = 3 } }; appender.Store(metadata, events); appender.FinalizeStore(); manager = new EventStoreManager(); var eventObserver = new StoringEventObserver(); long baselineMemory = 0; for (int i = 0; i <= 10000; i++) { var reader = manager.OpenReadOnlyStore(storage); reader.ReadToEnd(eventObserver); Assert.Single(eventObserver.Events); eventObserver.Events.Clear(); eventObserver.Metadata.Clear(); if (i == 10) { GC.Collect(2); GC.WaitForPendingFinalizers(); GC.Collect(2); baselineMemory = GC.GetTotalMemory(false); } } GC.Collect(2); GC.WaitForPendingFinalizers(); GC.Collect(2); Assert.InRange(GC.GetTotalMemory(false), 0, baselineMemory * 3F); }
public void UseArrayForStoreIList() { var manager = new EventStoreManager(); var file = new MemoryEventFileStorage(); var appender = manager.AppendToStore(file); var e = new UsersIList { Users = new[] { new User { Name = "A" }, new User { Name = "B" } } }; appender.Store(null, new object[] { e }); }
public void CannotStoreStruct() { var testEvent = new EventWithStruct { EventId = 1, Structure = new Structure() }; var manager = new EventStoreManager(); var appender = manager.AppendToStore(new MemoryEventFileStorage()); var e = Assert.Throws <BTDBException>(() => appender.Store(null, new object[] { testEvent })); Assert.Contains("Unsupported", e.Message); }
public void MoreComplexRepeatedAppendingAndReading() { var manager = new EventStoreManager(); for (var i = 490; i < 520; i += 2) { var file = new MemoryEventFileStorage(); var appender = manager.AppendToStore(file); appender.Store(null, new object[] { new byte[i] }); var eventObserver = new StoringEventObserver(); appender.ReadFromStartToEnd(eventObserver); appender.Store(null, new object[] { new byte[i] }); appender.ReadFromStartToEnd(eventObserver); } }
public void CanWriteEventWithIndexer() { var manager = new EventStoreManager(); var appender = manager.AppendToStore(new MemoryEventFileStorage()); appender.Store(null, new object[] { new SimpleWithIndexer { EvenName = "e", OddName = "o" } }); var eventObserver = new StoringEventObserver(); appender.ReadFromStartToEnd(eventObserver); Assert.Equal(new object[] { null }, eventObserver.Metadata); var ev = eventObserver.Events[0][0] as SimpleWithIndexer; Assert.Equal("o", ev[11]); }
public void CanWriteSimpleEvent() { var manager = new EventStoreManager(); var appender = manager.AppendToStore(new MemoryEventFileStorage()); appender.Store(null, new object[] { 1 }); var eventObserver = new StoringEventObserver(); appender.ReadFromStartToEnd(eventObserver); Assert.Equal(new object[] { null }, eventObserver.Metadata); Assert.Equal(new[] { new object[] { 1 } }, eventObserver.Events); Assert.True(appender.IsKnownAsAppendable()); Assert.False(appender.IsKnownAsCorrupted()); Assert.False(appender.IsKnownAsFinished()); Assert.Equal(10ul, appender.KnownAppendablePosition()); }
public void SupportPureArray() { var manager = new EventStoreManager(); var appender = manager.AppendToStore(new MemoryEventFileStorage()); appender.Store(null, new object[] { new PureArray { A = new[] { "A", "B" }, B = new[] { 42, 7 } } }); var eventObserver = new StoringEventObserver(); appender.ReadFromStartToEnd(eventObserver); Assert.Equal(new object[] { null }, eventObserver.Metadata); var ev = eventObserver.Events[0][0] as PureArray; Assert.Equal(ev.A, new[] { "A", "B" }); Assert.Equal(ev.B, new[] { 42, 7 }); }
static object PassThroughEventStorage(object @event, ITypeNameMapper mapper) { var manager = new EventStoreManager(); var storage = new MemoryEventFileStorage(); var appender = manager.AppendToStore(storage); var events = new[] { @event }; appender.Store(null, events); manager = new EventStoreManager(); manager.SetNewTypeNameMapper(mapper); var eventObserver = new EventStoreTest.StoringEventObserver(); manager.OpenReadOnlyStore(storage).ReadFromStartToEnd(eventObserver); return(eventObserver.Events[0][0]); }
public void SupportStrangeVisibilities() { var manager = new EventStoreManager(); var appender = manager.AppendToStore(new MemoryEventFileStorage()); appender.Store(null, new object[] { new StrangeVisibilities { A = "a", C = "c", D = "d" } }); var eventObserver = new StoringEventObserver(); appender.ReadFromStartToEnd(eventObserver); Assert.Equal(new object[] { null }, eventObserver.Metadata); var ev = eventObserver.Events[0][0] as StrangeVisibilities; Assert.Equal("a", ev.A); Assert.Null(ev.B); Assert.Equal("c", ev.C); }
public void CompressionShortensData() { var manager = new EventStoreManager(); var file = new MemoryEventFileStorage(); var appender = manager.AppendToStore(file); var compressibleData = new byte[20000]; appender.Store(null, new object[] { compressibleData }); Assert.True(2000 > appender.KnownAppendablePosition()); manager = new EventStoreManager(); var reader = manager.OpenReadOnlyStore(file); var eventObserver = new StoringEventObserver(); reader.ReadFromStartToEnd(eventObserver); Assert.Equal(new object[] { null }, eventObserver.Metadata); Assert.Equal(new[] { new object[] { compressibleData } }, eventObserver.Events); }
public void SupportsDataOverMaxBlockSize() { var manager = new EventStoreManager(); var file = new MemoryEventFileStorage(); var appender = manager.AppendToStore(file); var randomData = new byte[20000]; new Random().NextBytes(randomData); appender.Store(null, new object[] { randomData }); Assert.True(10000 < appender.KnownAppendablePosition()); manager = new EventStoreManager(); var reader = manager.OpenReadOnlyStore(file); var eventObserver = new StoringEventObserver(); reader.ReadFromStartToEnd(eventObserver); Assert.Equal(new object[] { null }, eventObserver.Metadata); Assert.Equal(new[] { new object[] { randomData } }, eventObserver.Events); }
public void Read() { var manager = new EventStoreManager(); manager.SetNewTypeNameMapper(new OverloadableTypeMapper(typeof(ClassWithChangedUINTtoULONG), "BTDBTest.EventStoreTest+Credit")); using (var file = new StreamEventFileStorage(new MemoryStream(Convert.FromBase64String(base64EventFile)))) { var appender = manager.AppendToStore(file); var observer = new StoringEventObserver(); appender.ReadFromStartToEnd(observer); Assert.Equal(observer.Events.Count, 1); Assert.Equal(observer.Events[0].Length, 1); var e = observer.Events[0][0] as Ev1; Assert.Equal(e.Credit.A, 1u); Assert.Equal(e.Credit.B, 2u); } }
public void SkipsIIndirect() { var manager = new EventStoreManager(); var file = new MemoryEventFileStorage(); var appender = manager.AppendToStore(file); var ev = new EventWithIIndirect { Name = "A", Ind1 = new DBIndirect <User>(), Ind2 = new List <IIndirect <User> >() }; appender.Store(null, new object[] { ev }); manager = new EventStoreManager(); var reader = manager.OpenReadOnlyStore(file); var eventObserver = new StoringEventObserver(); reader.ReadFromStartToEnd(eventObserver); }
public void NestedObjectsTest() { var manager = new EventStoreManager(); var file = new MemoryEventFileStorage(); var appender = manager.AppendToStore(file); var userEvent = new UserEvent { Id = 10, User1 = new User { Name = "A", Age = 1 } }; appender.Store(null, new object[] { userEvent }); manager = new EventStoreManager(); var reader = manager.OpenReadOnlyStore(file); var eventObserver = new StoringEventObserver(); reader.ReadFromStartToEnd(eventObserver); Assert.Equal(new object[] { null }, eventObserver.Metadata); Assert.Equal(new[] { new object[] { userEvent } }, eventObserver.Events); }
public void CanFinalizeEventStoreAfterReadFromStart() { var manager = new EventStoreManager(); manager.CompressionStrategy = new NoCompressionStrategy(); var file1 = new MemoryEventFileStorage(4096, 4096); var appender = manager.AppendToStore(file1); appender.Store(null, new object[] { new byte[4000] }); appender.Store(null, new object[] { new byte[4000] }); Assert.NotSame(file1, appender.CurrentFileStorage); var reader = manager.OpenReadOnlyStore(file1); reader.ReadFromStartToEnd(new SkippingEventObserver()); Assert.False(reader.IsKnownAsAppendable()); Assert.False(reader.IsKnownAsCorrupted()); Assert.True(reader.IsKnownAsFinished()); Assert.True(appender.IsKnownAsAppendable()); Assert.False(appender.IsKnownAsCorrupted()); Assert.False(appender.IsKnownAsFinished()); }