public void Get_database_settings(
string connectionString,
string w,
bool journal,
ReadConcernLevel?readConcernLevel,
ReadPreferenceMode readPreference,
GuidRepresentation guidRepresentation)
{
var settings = MongoDbEventStore <object> .GetDefaultDatabaseSettings(connectionString);
if (string.IsNullOrEmpty(w))
{
Assert.Null(settings.WriteConcern.W);
}
else
{
Assert.Equal(w, settings.WriteConcern.W.ToString());
}
Assert.Equal(journal, settings.WriteConcern.Journal);
if (readConcernLevel != null)
{
Assert.Equal(readConcernLevel, settings.ReadConcern.Level);
}
else
{
Assert.Null(settings.ReadConcern.Level);
}
Assert.Equal(readPreference, settings.ReadPreference.ReadPreferenceMode);
Assert.Equal(guidRepresentation, settings.GuidRepresentation);
}
CommandProcessor GetCommandProcessor(bool useCaching)
{
var eventStore = new MongoDbEventStore(_database, "events");
_timeTaker = new TimeTaker
{
InnerEventStore = eventStore,
};
var serializer = new JsonDomainEventSerializer();
IAggregateRootRepository aggregateRootRepository = new DefaultAggregateRootRepository(_timeTaker, serializer, _domainTypeNameMapper);
if (useCaching)
{
aggregateRootRepository = new CachingAggregateRootRepositoryDecorator(aggregateRootRepository, new InMemorySnapshotCache { ApproximateMaxNumberOfCacheEntries = 100 }, eventStore, serializer);
}
_timeTaker.InnerAggregateRootRepository = aggregateRootRepository;
var eventDispatcher = new ViewManagerEventDispatcher(_timeTaker, eventStore, serializer, _domainTypeNameMapper);
var commandProcessor = new CommandProcessor(_timeTaker, _timeTaker, eventDispatcher, serializer, _commandMapper, _domainTypeNameMapper, new Options());
RegisterForDisposal(commandProcessor);
return commandProcessor;
}
public static IServiceCollection LoadPersistenceConfigurations(this IServiceCollection services, IConfiguration configuration)
{
services.AddTransient <IEventStore>(sp =>
{
var mongoOptions = sp.GetService <IOptions <MongoDbConfig> >();
IEventStore eventStore;
if (bool.Parse(configuration["toggles:enableEventStream"]))
{
eventStore = new EventStreamEventStore(mongoOptions);
}
else
{
eventStore = new MongoDbEventStore(mongoOptions);
}
return(new LoggerEventStore(eventStore, sp.GetService <ICorrelationContextAccessor>()));
});
services.AddSingleton <IElasticClient>(sp =>
{
var connectionString = configuration["App:elasticSearch:ConnectionString"];
var port = configuration["App:elasticSearch:Port"];
var uri = new Uri($"http://{connectionString}:{port}");
return(new ElasticClient(uri));
});
services.AddTransient <UsersElasticSearchRepository>();
services.AddTransient <UsersSearchRepository>();
return(services);
}
void SaveEvents(int numberOfCommandsToProcess, string aggregateRootId)
{
var eventStore = new MongoDbEventStore(_database, "Events");
var serializer = new JsonDomainEventSerializer();
var typeNameMapper = new DefaultDomainTypeNameMapper();
Enumerable.Range(0, numberOfCommandsToProcess)
.ToList()
.ForEach(number =>
{
var domainEvents = new[]
{
new RootGotNewNumber(number)
{
Meta =
{
{ DomainEvent.MetadataKeys.AggregateRootId, aggregateRootId },
{ DomainEvent.MetadataKeys.SequenceNumber, number.ToString() },
{ DomainEvent.MetadataKeys.TimeUtc, Time.UtcNow().ToString("u") },
{ DomainEvent.MetadataKeys.Type, typeNameMapper.GetName(typeof(RootGotNewNumber)) },
{ DomainEvent.MetadataKeys.Owner, typeNameMapper.GetName(typeof(Root)) },
}
}
};
eventStore.Save(Guid.NewGuid(), domainEvents.Select(e => serializer.Serialize(e)));
});
}
public async Task GetAllEventsByAggregateType_Should_Returns_AllConcernedEvents()
{
try
{
DeleteAll();
var store = new MongoDbEventStore();
List <IDomainEvent> events = new List <IDomainEvent>();
for (int i = 0; i < 100; i++)
{
if (i % 2 == 0)
{
events.Add(new EventAggA(Guid.NewGuid()));
}
else
{
events.Add(new EventAggB(Guid.NewGuid()));
}
}
await store.StoreDomainEventRangeAsync(events);
var store2 = new MongoDbEventStore();
(await store2.GetAllEventsByAggregateType(typeof(AggA)).ToListAsync()).Should().HaveCount(50);
(await store2.GetAllEventsByAggregateType(typeof(AggB)).ToListAsync()).Should().HaveCount(50);
}
finally
{
DeleteAll();
}
}
public async Task StoreDomainEventRangeAsync_Should_Store_AllEvents_ToDb()
{
try
{
DeleteAll();
Guid aggId = Guid.NewGuid();
var store = new MongoDbEventStore();
List <IDomainEvent> events = new List <IDomainEvent>();
for (int i = 0; i < 100; i++)
{
events.Add(new SampleEvent(aggId, Guid.NewGuid(), DateTime.Today)
{
Data = "testData" + i
});
}
await store.StoreDomainEventRangeAsync(events);
(await GetEventCollection().CountDocumentsAsync(FilterDefinition <IDomainEvent> .Empty)).Should().Be(100);
}
finally
{
DeleteAll();
}
}
public async Task GetAllEventsByEventType_Generic_Should_Returns_OnlyConcernedEvents()
{
try
{
DeleteAll();
var store = new MongoDbEventStore();
List <IDomainEvent> events = new List <IDomainEvent>();
for (int i = 0; i < 100; i++)
{
if (i % 10 == 0)
{
events.Add(new EventAggA(Guid.NewGuid()));
}
else
{
events.Add(new EventAggB(Guid.NewGuid()));
}
}
await store.StoreDomainEventRangeAsync(events);
var store2 = new MongoDbEventStore();
(await store2.GetAllEventsByEventType <EventAggA>().ToListAsync()).Should().HaveCount(10);
(await store2.GetAllEventsByEventType <EventAggB>().ToListAsync()).Should().HaveCount(90);
}
finally
{
DeleteAll();
}
}
public void NoProblemoWithRealSetup()
{
// arrange
var eventStore = new MongoDbEventStore(MongoHelper.InitializeTestDatabase(), "events");
//Brett
var commandProcessor = CreateCommandProcessor(config => config
.EventStore(e => e.Register <IEventStore>(c => eventStore))
.EventDispatcher(e => e.Register <IEventDispatcher>(c => new ConsoleOutEventDispatcher(eventStore)))
);
//Orig
//var commandProcessor = CommandProcessor.With()
// .EventStore(e => e.Register<IEventStore>(c => eventStore))
// .EventDispatcher(e => e.Register<IEventDispatcher>(c =>
// new ConsoleOutEventDispatcher(eventStore)))
// .Create();
RegisterForDisposal(commandProcessor);
// make sure all roots exist
Console.WriteLine("Processing initial two commands");
commandProcessor.ProcessCommand(new DoSomethingToABunchOfRootsCommand("id1"));
commandProcessor.ProcessCommand(new DoSomethingToABunchOfRootsCommand("id2"));
// act
Console.WriteLine("\r\n\r\nActing...");
commandProcessor.ProcessCommand(new DoSomethingToABunchOfRootsCommand("id1", "id2"));
// assert
}
public async Task RehydrateAggregate_WithSnapshot()
{
var store = new MongoDbEventStore(new BasicSnapshotBehaviorProvider(new Dictionary <Type, ISnapshotBehavior>()
{
{ typeof(TestEvent), new NumericSnapshotBehavior(10) }
}));
var agg = await store.GetRehydratedAggregateAsync <TestAggregate>(AggregateId);
}
public void Ctor_should_set_MongoDatabase_field()
{
var bus = new Mock <IEventDispatcher>().Object;
var mock = new Mock <IMongoDatabase>().Object;
var sut = new MongoDbEventStore(mock, bus);
Assert.Equal(mock, MongoDbEventStore.MongoDatabase);
}
private async Task StoreTestEventAsync(Guid aggId, Guid id, DateTime date)
{
var store = new MongoDbEventStore();
await store.StoreDomainEventAsync(new SampleEvent(aggId, id, date)
{
Data = "testData"
}).ConfigureAwait(false);
}
CommandProcessingResult GetLastResult()
{
var eventStore = new MongoDbEventStore(_database, "Events");
var nextGlobalSequenceNumber = eventStore.GetNextGlobalSequenceNumber();
var lastGlobalSequenceNumber = nextGlobalSequenceNumber - 1;
return(CommandProcessingResult.WithNewPosition(lastGlobalSequenceNumber));
}
public async Task NonAggregateEvent_Shouldnt_Be_Persisted_If_User_Configure_It()
{
EventStoreManager.Options.ShouldPersistNonAggregateEvent = false;
DeleteAll();
var store = new MongoDbEventStore();
await store.StoreDomainEventAsync(new NonAggEvent());
(await GetEventCollection().CountDocumentsAsync(FilterDefinition <IDomainEvent> .Empty).ConfigureAwait(false)).Should().Be(0);
}
protected override void DoSetUp()
{
_eventStore = new MongoDbEventStore(MongoHelper.InitializeTestDatabase(), "Events");
_domainEventSerializer = new JsonDomainEventSerializer();
_domainTypeNameMapper = new DefaultDomainTypeNameMapper();
var snapshotCache = new InMemorySnapshotCache();
_realAggregateRootRepository = new DefaultAggregateRootRepository(_eventStore, _domainEventSerializer, _domainTypeNameMapper);
_cachingAggregateRootRepository = new CachingAggregateRootRepositoryDecorator(_realAggregateRootRepository, snapshotCache, _eventStore, _domainEventSerializer);
}
private void StoreNDomainEvents(ISnapshotBehaviorProvider provider = null)
{
EventStoreManager.Client = new MongoClient(GetMongoDbUrl());
var store = new MongoDbEventStore(provider);
for (int i = 0; i < N; i++)
{
store.StoreDomainEventAsync(new TestEvent(Guid.NewGuid(), AggregateId)
{
AggregateStringValue = "test", AggregateIntValue = N
}).GetAwaiter().GetResult();
}
}
public async Task MongoDbEventStoreStoreDomainEventAsync_NotPersisted()
{
try
{
var store = new MongoDbEventStore();
await store.StoreDomainEventAsync(new NotPersistedEvent()).ConfigureAwait(false);
(await GetEventCollection().CountDocumentsAsync(FilterDefinition <IDomainEvent> .Empty).ConfigureAwait(false)).Should().Be(0);
}
finally
{
DeleteAll();
}
}
protected override void DoSetUp()
{
_seqNos.Clear();
var database = MongoHelper.InitializeTestDatabase();
_source = new MongoDbEventStore(database, "EventSrc");
_destination = new MongoDbEventStore(database, "EventDst");
_replicator = new EventReplicator(_source, _destination);
RegisterForDisposal(_replicator);
_replicator.Start();
}
public void _Save_should_choose_appopriate_InsertOne_from_IMongoCollection()
{
var bus = new Mock <IEventDispatcher>().Object;
var dbMock = new Mock <IMongoDatabase>();
var collectionMock = new Mock <IMongoCollection <DomainEventForTest> >();
dbMock.Setup(db => db.GetCollection <DomainEventForTest>(typeof(DomainEventForTest).Name, null))
.Returns(collectionMock.Object);
var sut = new MongoDbEventStore(dbMock.Object, bus);
var method = sut.GetType().GetMethod("_Save", BindingFlags.NonPublic | BindingFlags.Instance);
var domainEventForTest = new DomainEventForTest();
method.Invoke(sut, new object[] { domainEventForTest });
collectionMock.Verify(c => c.InsertOne(domainEventForTest, null, default(CancellationToken)), Times.Once);
}
protected override void DoSetUp()
{
CirqusLoggerFactory.Current = new ConsoleLoggerFactory(Logger.Level.Warn);
var mongoDatabase = MongoHelper.InitializeTestDatabase();
var aalborgEventStore = new MongoDbEventStore(mongoDatabase, "AalborgEvents");
var hongKongEventStore = new MongoDbEventStore(mongoDatabase, "HongKongEvents");
CreateCommandProcessor(aalborgEventStore, aalborgEventStore);
_hongKongViewManager = new MongoDbViewManager <CountingRootView>(mongoDatabase);
_hongKongCommandProcessor = CreateCommandProcessor(aalborgEventStore, hongKongEventStore, _hongKongViewManager);
var replicationDelay = TimeSpan.FromSeconds(5);
CreateAndStartReplication(aalborgEventStore, hongKongEventStore, replicationDelay);
}
public async Task NonAggregateEvent_Should_Be_Persisted_If_User_Configure_It()
{
try
{
EventStoreManager.Options.ShouldPersistNonAggregateEvent = true;
DeleteAll();
var store = new MongoDbEventStore();
await store.StoreDomainEventAsync(new NonAggEvent());
(await GetEventCollection().CountDocumentsAsync(FilterDefinition <IDomainEvent> .Empty).ConfigureAwait(false)).Should().Be(1);
var evt = await(await GetEventCollection().FindAsync(FilterDefinition <IDomainEvent> .Empty)).FirstOrDefaultAsync();
evt.Should().NotBeNull();
evt.AggregateType.Should().BeNull();
evt.AggregateId.Should().BeNull();
}
finally
{
DeleteAll();
}
}
public void IndexSpeedTest(bool useIndexes, int numberOfQueries, int numberOfEvents)
{
var sequenceNumbers = new Dictionary <string, long>();
var serializer = new JsonDomainEventSerializer();
try
{
var database = MongoHelper.InitializeTestDatabase();
database.Drop();
var eventStore = new MongoDbEventStore(database, "events", automaticallyCreateIndexes: useIndexes);
var random = new Random(DateTime.Now.GetHashCode());
var aggregateRootIds = Enumerable.Range(0, 1000).Select(i => i.ToString()).ToArray();
Func <string, long> getNextSequenceNumber = id => !sequenceNumbers.ContainsKey(id) ? (sequenceNumbers[id] = 0) : ++sequenceNumbers[id];
Func <string> randomAggregateRootId = () => aggregateRootIds[random.Next(aggregateRootIds.Length)];
var events = Enumerable.Range(1, numberOfEvents)
.Select(i => Event(getNextSequenceNumber, randomAggregateRootId()))
.ToList();
TakeTime("Insert " + events.Count + " events", () =>
{
foreach (var e in events)
{
eventStore.Save(Guid.NewGuid(), new[] { serializer.Serialize(e) });
}
});
TakeTime("Execute " + numberOfQueries + " queries", () => numberOfQueries.Times(() => eventStore.Load(randomAggregateRootId()).ToList()));
}
finally
{
Console.WriteLine(@"This is how far we got:
{0}", string.Join(Environment.NewLine, sequenceNumbers.Select(kvp => string.Format(" {0}: {1}", kvp.Key, kvp.Value))));
}
}
protected override void DoSetUp()
{
_listLoggerFactory = new ListLoggerFactory();
CirqusLoggerFactory.Current = _listLoggerFactory;
_seqNos.Clear();
var database = MongoHelper.InitializeTestDatabase();
_source = new MongoDbEventStore(database, "EventSrc");
_destination = new MongoDbEventStore(database, "EventDst");
var source = new ThrowsAnErrorOnceInAWhile(_source, 0.5);
var destination = new ThrowsAnErrorOnceInAWhile(_destination, 0.5);
_replicator = new EventReplicator(source, destination)
{
TimeToPauseOnError = TimeSpan.Zero //< don't wait in this test
};
RegisterForDisposal(_replicator);
_replicator.Start();
}
protected override void DoSetUp()
{
_mongoDatabase = MongoHelper.InitializeTestDatabase();
_eventStore = new MongoDbEventStore(_mongoDatabase, "Events");
}
public void Save_ValidEvent_EventCanBeRetreived()
{
// Arrange
var correlationIdHelper = new CorrelationIdHelper(new ContextItemCollectionFactory());
correlationIdHelper.SetCorrelationId(Guid.NewGuid());
var logger = new ConsoleLogger(new LoggerSettings(), correlationIdHelper);
try
{
// Arrange
var connectionStringFactory = new TestMongoEventStoreConnectionStringFactory();
TestMongoEventStoreConnectionStringFactory.DatabaseName = string.Format("Test-{0}", new Random().Next(0, 9999));
var eventStore = new MongoDbEventStore <Guid>(new MongoDbEventBuilder <Guid>(), new MongoDbEventDeserialiser <Guid>(), logger, connectionStringFactory, new ConfigurationManager());
var event1 = new TestEvent
{
Rsn = Guid.NewGuid(),
Id = Guid.NewGuid(),
CorrelationId = correlationIdHelper.GetCorrelationId(),
Frameworks = new List <string> {
"Test 1"
},
TimeStamp = DateTimeOffset.UtcNow
};
var event2 = new TestEvent
{
Rsn = Guid.NewGuid(),
Id = Guid.NewGuid(),
CorrelationId = correlationIdHelper.GetCorrelationId(),
Frameworks = new List <string> {
"Test 2"
},
TimeStamp = DateTimeOffset.UtcNow
};
// Act
eventStore.Save <TestEvent>(event1);
eventStore.Save <TestEvent>(event2);
// Assert
var timer = new Stopwatch();
IList <IEvent <Guid> > events = eventStore.Get <TestEvent>(event1.Id).ToList();
timer.Stop();
Console.WriteLine("Load one operation took {0}", timer.Elapsed);
Assert.AreEqual(1, events.Count);
Assert.AreEqual(event1.Id, events.Single().Id);
Assert.AreEqual(event1.Frameworks.Single(), events.Single().Frameworks.Single());
timer.Restart();
events = eventStore.Get <TestEvent>(event2.Id).ToList();
timer.Stop();
Console.WriteLine("Load one operation took {0}", timer.Elapsed);
Assert.AreEqual(1, events.Count);
Assert.AreEqual(event2.Id, events.Single().Id);
Assert.AreEqual(event2.Frameworks.Single(), events.Single().Frameworks.Single());
timer.Restart();
IList <EventData> correlatedEvents = eventStore.Get(event1.CorrelationId).ToList();
timer.Stop();
Console.WriteLine("Load several correlated operation took {0}", timer.Elapsed);
Assert.AreEqual(2, correlatedEvents.Count);
}
finally
{
// Clean-up
TestMongoDataStoreConnectionStringFactory.DatabaseName = TestMongoEventStoreConnectionStringFactory.DatabaseName;
var factory = new TestMongoDbDataStoreFactory(logger, new TestMongoDataStoreConnectionStringFactory());
IMongoCollection <TestEvent> collection = factory.GetTestEventCollection();
collection.Database.Client.DropDatabase(TestMongoDataStoreConnectionStringFactory.DatabaseName);
}
}
public static async Task Main()
{
SetupSerialization();
var builder = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json");
var configuration = builder.Build();
var mongoDbConnectionString = configuration["mongoTest"];
_eventStore = new MongoDbEventStore <IEvent>(mongoDbConnectionString);
_eventStore.AutonIncrementStrategy = new IncrementCountersStrategy <IEvent>(_eventStore);
_eventStore.RegisterDispatchers(
_moviesProjection = new InMemoryMoviesProjection(),
_totalMoviesProjection = new InMemoryTotalMoviesProjection());
_store = new AggregateStore(_eventStore, "sample");
await RebuildAsync().ConfigureAwait(false);
Console.WriteLine("Movie catalog sample!");
while (true)
{
Console.WriteLine("");
Console.WriteLine("Actions:");
Console.WriteLine(" -i: Insert a movie");
Console.WriteLine(" -b: Bulk insert movies");
Console.WriteLine(" -a: Parallel bulk insert movies");
Console.WriteLine(" -u: Update movie");
Console.WriteLine(" -l: List events");
Console.WriteLine(" -p: Print movies");
Console.WriteLine(" -t: Total movies");
Console.WriteLine(" -m: Load movie aggregate");
Console.WriteLine(" -r: Rollback");
Console.WriteLine(" -s: Change auto-increment strategy");
Console.WriteLine(" -e: Exit");
Console.Write("Choose an action: ");
switch (Console.ReadLine())
{
case "i":
await InsertMovieAsync().ConfigureAwait(false);
break;
case "b":
await BulkInsertMoviesAsync().ConfigureAwait(false);
break;
case "a":
await ParallelBulkInsertMoviesAsync().ConfigureAwait(false);
break;
case "u":
await UpdateMovieAsync().ConfigureAwait(false);
break;
case "l":
await ListEventsAsync().ConfigureAwait(false);
break;
case "m":
await LoadMovieAsync().ConfigureAwait(false);
break;
case "r":
await RollbackAsync().ConfigureAwait(false);
break;
case "p":
PrintMovies();
break;
case "t":
TotalMovies();
break;
case "s":
await ChangeStrategyAsync().ConfigureAwait(false);
break;
case "e":
return;
}
}
}
public static void Main()
{
SetupSerialization();
var mongoDbConnectionString = ConfigurationManager.ConnectionStrings["mongoTest"].ConnectionString;
_eventStore = new MongoDbEventStore <IEvent>(mongoDbConnectionString);
_eventStore.AutonIncrementStrategy = new IncrementCountersStrategy <IEvent>(_eventStore);
_eventStore.RegisterDispatchers(
_moviesProjection = new InMemoryMoviesProjection(),
_totalMoviesProjection = new InMemoryTotalMoviesProjection());
_store = new AggregateStore(_eventStore, "sample");
RebuildAsync().Wait();
Console.WriteLine("Movie catalog sample!");
while (true)
{
Console.WriteLine("");
Console.WriteLine("Actions:");
Console.WriteLine(" -i: Insert a movie");
Console.WriteLine(" -b: Bulk insert movies");
Console.WriteLine(" -a: Parallel bulk insert movies");
Console.WriteLine(" -u: Update movie");
Console.WriteLine(" -l: List events");
Console.WriteLine(" -p: Print movies");
Console.WriteLine(" -t: Total movies");
Console.WriteLine(" -m: Load movie aggregate");
Console.WriteLine(" -r: Rollback");
Console.WriteLine(" -s: Change auto-increment strategy");
Console.WriteLine(" -e: Exit");
Console.Write("Choose an action: ");
switch (Console.ReadLine())
{
case "i":
InsertMovieAsync().Wait();
break;
case "b":
BulkInsertMoviesAsync().Wait();
break;
case "a":
ParallelBulkInsertMoviesAsync().Wait();
break;
case "u":
UpdateMovieAsync().Wait();
break;
case "l":
ListEventsAsync().Wait();
break;
case "m":
LoadMovieAsync().Wait();
break;
case "r":
RollbackAsync().Wait();
break;
case "p":
PrintMovies();
break;
case "t":
TotalMovies();
break;
case "s":
ChangeStrategyAsync().Wait();
break;
case "e":
return;
}
}
}
public ExposedMongoEventStore(MongoDbEventStore <TAuthenticationToken> mongoDbEventStore)
{
PropertyInfo propertyInfo = mongoDbEventStore.GetType().GetProperty("MongoCollection", BindingFlags.Instance | BindingFlags.NonPublic);
MongoCollection = (IMongoCollection <MongoDbEventData>)propertyInfo.GetValue(mongoDbEventStore);
}
public async Task RehydrateAggregate()
{
var store = new MongoDbEventStore();
var agg = await store.GetRehydratedAggregateAsync <TestAggregate>(AggregateId);
}
public MongoDbEventStoreFactory()
{
_eventStore = new MongoDbEventStore(MongoHelper.InitializeTestDatabase(), "events");
}
public IncrementCountersStrategy(MongoDbEventStore <T> eventStore)
{
_collection = eventStore.Database.GetCollection <Counter>("counters");
}
