public IEnumerable <IAggregateRootEvent> GetAggregateHistory(Guid id) { lock (_lockObject) { return(SingleAggregateInstanceEventStreamMutator.MutateCompleteAggregateHistory(_migrationFactories, _events.Where(e => e.AggregateRootId == id).ToList()) .ToList());; } }
public void When_there_are_no_migrations_mutation_takes_less_than_a_millisecond() { var eventMigrations = Seq.Create <IEventMigration>().ToArray(); TimeAsserter.Execute( maxAverage: 1.Milliseconds(), iterations: 10, description: "load aggregate in isolated scope", timeFormat: "ss\\.fff", action: () => { SingleAggregateInstanceEventStreamMutator.MutateCompleteAggregateHistory(eventMigrations, _history); }); }
public void With_four_migrations_that_change_nothing_mutation_takes_less_than_10_milliseconds() { var eventMigrations = Seq.Create <IEventMigration>( Before <E3> .Insert <E1>(), Before <E5> .Insert <E1>(), Before <E7> .Insert <E1>(), Before <E9> .Insert <E1>() ).ToArray(); var maxAverage = 10.Milliseconds().AdjustRuntimeForNCrunch(boost: 6); TimeAsserter.Execute( maxTotal: maxAverage, maxTries: 10, description: "load aggregate in isolated scope", timeFormat: "ss\\.fff", action: () => { SingleAggregateInstanceEventStreamMutator.MutateCompleteAggregateHistory(eventMigrations, _history); }); }
public void With_four_migrations_mutation_that_all_actually_changes_things_migration_takes_less_than_15_milliseconds() { var eventMigrations = Seq.Create <IEventMigration>( Before <E2> .Insert <E3>(), Before <E4> .Insert <E5>(), Before <E6> .Insert <E7>(), Before <E8> .Insert <E9>() ).ToArray(); var maxAverage = TestEnvironmentPerformance.AdjustRuntime(15.Milliseconds(), boost: 2); TimeAsserter.Execute( maxTotal: maxAverage, description: "load aggregate in isolated scope", maxTries: 10, timeFormat: "ss\\.fff", action: () => { SingleAggregateInstanceEventStreamMutator.MutateCompleteAggregateHistory(eventMigrations, _history); }); }
private IEnumerable <IAggregateRootEvent> GetAggregateHistoryInternal(Guid aggregateId, bool takeWriteLock) { _usageGuard.AssertNoContextChangeOccurred(this); _schemaManager.SetupSchemaIfDatabaseUnInitialized(); lock (AggregateLockManager.GetAggregateLockObject(aggregateId)) { var cachedAggregateHistory = _cache.GetCopy(aggregateId); var newEventsFromDatabase = _eventReader.GetAggregateHistory( aggregateId: aggregateId, startAfterInsertedVersion: cachedAggregateHistory.MaxSeenInsertedVersion, takeWriteLock: takeWriteLock); var containsRefactoringEvents = newEventsFromDatabase.Where(IsRefactoringEvent).Any(); if (containsRefactoringEvents && cachedAggregateHistory.MaxSeenInsertedVersion > 0) { _cache.Remove(aggregateId); return(GetAggregateHistoryInternal(aggregateId: aggregateId, takeWriteLock: takeWriteLock)); } var currentHistory = cachedAggregateHistory.Events.Count == 0 ? SingleAggregateInstanceEventStreamMutator.MutateCompleteAggregateHistory(_migrationFactories, newEventsFromDatabase) : cachedAggregateHistory.Events.Concat(newEventsFromDatabase).ToList(); //Should within a transaction a process write events, read them, then fail to commit we will have cached events that are not persisted unless we refuse to cache them here. if (!_aggregatesWithEventsAddedByThisInstance.Contains(aggregateId)) { var maxSeenInsertedVersion = newEventsFromDatabase.Any() ? newEventsFromDatabase.Max(@event => @event.InsertedVersion) : cachedAggregateHistory.MaxSeenInsertedVersion; _cache.Store( aggregateId, new SqlServerEventStoreEventsCache.Entry(events: currentHistory, maxSeenInsertedVersion: maxSeenInsertedVersion)); } return(currentHistory); } }
public void PersistMigrations() { this.Log().Warn($"Starting to persist migrations"); long migratedAggregates = 0; long updatedAggregates = 0; long newEventCount = 0; var logInterval = 1.Minutes(); var lastLogTime = DateTime.Now; const int recoverableErrorRetriesToMake = 5; var aggregateIdsInCreationOrder = StreamAggregateIdsInCreationOrder().ToList(); foreach (var aggregateId in aggregateIdsInCreationOrder) { try { var succeeded = false; int retries = 0; while (!succeeded) { try { //todo: Look at batching the inserting of events in a way that let's us avoid taking a lock for a long time as we do now. This might be a problem in production. using (var transaction = new TransactionScope(TransactionScopeOption.Required, scopeTimeout: 10.Minutes())) { lock (AggregateLockManager.GetAggregateLockObject(aggregateId)) { var updatedThisAggregate = false; var original = _eventReader.GetAggregateHistory(aggregateId: aggregateId, takeWriteLock: true).ToList(); var startInsertingWithVersion = original.Max(@event => @event.InsertedVersion) + 1; var updatedAggregatesBeforeMigrationOfThisAggregate = updatedAggregates; SingleAggregateInstanceEventStreamMutator.MutateCompleteAggregateHistory( _migrationFactories, original, newEvents => { //Make sure we don't try to insert into an occupied InsertedVersion newEvents.ForEach(@event => @event.InsertedVersion = startInsertingWithVersion++); //Save all new events so they get an InsertionOrder for the next refactoring to work with in case it acts relative to any of these events _eventWriter.InsertRefactoringEvents(newEvents); updatedAggregates = updatedAggregatesBeforeMigrationOfThisAggregate + 1; newEventCount += newEvents.Count(); updatedThisAggregate = true; }); if (updatedThisAggregate) { _eventWriter.FixManualVersions(aggregateId); } transaction.Complete(); _cache.Remove(aggregateId); } migratedAggregates++; succeeded = true; } } catch (Exception e) when(IsRecoverableSqlException(e) && ++retries <= recoverableErrorRetriesToMake) { this.Log().Warn($"Failed to persist migrations for aggregate: {aggregateId}. Exception appers to be recoverable so running retry {retries} out of {recoverableErrorRetriesToMake}", e); } } } catch (Exception exception) { this.Log().Error($"Failed to persist migrations for aggregate: {aggregateId}", exception: exception); } if (logInterval < DateTime.Now - lastLogTime) { lastLogTime = DateTime.Now; Func <int> percentDone = () => (int)(((double)migratedAggregates / aggregateIdsInCreationOrder.Count) * 100); this.Log().Info($"{percentDone()}% done. Inspected: {migratedAggregates} / {aggregateIdsInCreationOrder.Count}, Updated: {updatedAggregates}, New Events: {newEventCount}"); } } this.Log().Warn($"Done persisting migrations."); this.Log().Info($"Inspected: {migratedAggregates} , Updated: {updatedAggregates}, New Events: {newEventCount}"); }
private static void RunScenarioWithEventStoreType (MigrationScenario scenario, Type eventStoreType, WindsorContainer container, IList <IEventMigration> migrations, int indexOfScenarioInBatch) { var startingMigrations = migrations.ToList(); migrations.Clear(); var timeSource = container.Resolve <DummyTimeSource>(); IReadOnlyList <IAggregateRootEvent> eventsInStoreAtStart; using (container.BeginScope()) //Why is this needed? It fails without it but I do not understand why... { var eventStore = container.Resolve <IEventStore>(); eventsInStoreAtStart = eventStore.ListAllEventsForTestingPurposesAbsolutelyNotUsableForARealEventStoreOfAnySize(); } Console.WriteLine($"\n########Running Scenario {indexOfScenarioInBatch}"); var original = TestAggregate.FromEvents(DummyTimeSource.Now, scenario.AggregateId, scenario.OriginalHistory).History.ToList(); Console.WriteLine($"Original History: "); original.ForEach(e => Console.WriteLine($" {e}")); Console.WriteLine(); var initialAggregate = TestAggregate.FromEvents(timeSource, scenario.AggregateId, scenario.OriginalHistory); var expected = TestAggregate.FromEvents(timeSource, scenario.AggregateId, scenario.ExpectedHistory).History.ToList(); var expectedCompleteEventstoreStream = eventsInStoreAtStart.Concat(expected).ToList(); Console.WriteLine($"Expected History: "); expected.ForEach(e => Console.WriteLine($" {e}")); Console.WriteLine(); var initialAggregate2 = TestAggregate.FromEvents(timeSource, scenario.AggregateId, scenario.OriginalHistory); timeSource.UtcNow += 1.Hours();//Bump clock to ensure that times will be be wrong unless the time from the original events are used.. Console.WriteLine("Doing pure in memory "); IReadOnlyList <IAggregateRootEvent> otherHistory = SingleAggregateInstanceEventStreamMutator.MutateCompleteAggregateHistory( scenario.Migrations, initialAggregate2.History.Cast <AggregateRootEvent>().ToList()); AssertStreamsAreIdentical(expected, otherHistory, $"Direct call to SingleAggregateInstanceEventStreamMutator.MutateCompleteAggregateHistory"); container.ExecuteUnitOfWorkInIsolatedScope(() => container.Resolve <IEventStoreSession>().Save(initialAggregate)); migrations.AddRange(startingMigrations); var migratedHistory = container.ExecuteUnitOfWorkInIsolatedScope(() => container.Resolve <IEventStoreSession>().Get <TestAggregate>(initialAggregate.Id)).History; AssertStreamsAreIdentical(expected, migratedHistory, "Loaded un-cached aggregate"); var migratedCachedHistory = container.ExecuteUnitOfWorkInIsolatedScope(() => container.Resolve <IEventStoreSession>().Get <TestAggregate>(initialAggregate.Id)).History; AssertStreamsAreIdentical(expected, migratedCachedHistory, "Loaded cached aggregate"); Console.WriteLine(" Streaming all events in store"); var streamedEvents = container.ExecuteUnitOfWorkInIsolatedScope(() => container.Resolve <IEventStore>().ListAllEventsForTestingPurposesAbsolutelyNotUsableForARealEventStoreOfAnySize().ToList()); AssertStreamsAreIdentical(expectedCompleteEventstoreStream, streamedEvents, "Streaming all events in store"); Console.WriteLine(" Persisting migrations"); using (container.BeginScope()) { container.Resolve <IEventStore>().PersistMigrations(); } migratedHistory = container.ExecuteUnitOfWorkInIsolatedScope(() => container.Resolve <IEventStoreSession>().Get <TestAggregate>(initialAggregate.Id)).History; AssertStreamsAreIdentical(expected, migratedHistory, "Loaded aggregate"); Console.WriteLine("Streaming all events in store"); streamedEvents = container.ExecuteUnitOfWorkInIsolatedScope(() => container.Resolve <IEventStore>().ListAllEventsForTestingPurposesAbsolutelyNotUsableForARealEventStoreOfAnySize().ToList()); AssertStreamsAreIdentical(expectedCompleteEventstoreStream, streamedEvents, "Streaming all events in store"); Console.WriteLine(" Disable all migrations so that none are used when reading from the event stores"); migrations.Clear(); migratedHistory = container.ExecuteUnitOfWorkInIsolatedScope(() => container.Resolve <IEventStoreSession>().Get <TestAggregate>(initialAggregate.Id)).History; AssertStreamsAreIdentical(expected, migratedHistory, "loaded aggregate"); Console.WriteLine("Streaming all events in store"); streamedEvents = container.ExecuteUnitOfWorkInIsolatedScope(() => container.Resolve <IEventStore>().ListAllEventsForTestingPurposesAbsolutelyNotUsableForARealEventStoreOfAnySize().ToList()); AssertStreamsAreIdentical(expectedCompleteEventstoreStream, streamedEvents, "Streaming all events in store"); if (eventStoreType == typeof(SqlServerEventStore)) { Console.WriteLine("Clearing sql server eventstore cache"); container.ExecuteUnitOfWorkInIsolatedScope(() => ((SqlServerEventStore)container.Resolve <IEventStore>()).ClearCache()); migratedHistory = container.ExecuteUnitOfWorkInIsolatedScope(() => container.Resolve <IEventStoreSession>().Get <TestAggregate>(initialAggregate.Id)).History; AssertStreamsAreIdentical(expected, migratedHistory, "Loaded aggregate"); Console.WriteLine("Streaming all events in store"); streamedEvents = container.ExecuteUnitOfWorkInIsolatedScope(() => container.Resolve <IEventStore>().ListAllEventsForTestingPurposesAbsolutelyNotUsableForARealEventStoreOfAnySize().ToList()); AssertStreamsAreIdentical(expectedCompleteEventstoreStream, streamedEvents, "Streaming all events in store"); } }