Beispiel #1
0
        /// <inheritdoc/>
        public async Task <CommittedAggregateEvents> CommitAggregateEvents(UncommittedAggregateEvents events, CancellationToken cancellationToken)
        {
            ThrowIfNoEventsToCommit(events);
            try
            {
                using var session = await _streams.StartSessionAsync(cancellationToken : cancellationToken).ConfigureAwait(false);

                return(await session.WithTransactionAsync(
                           async (transaction, cancel) =>
                {
                    var eventLogSequenceNumber = (ulong)await _streams.DefaultEventLog.CountDocumentsAsync(
                        transaction,
                        _eventFilter.Empty,
                        cancellationToken: cancel).ConfigureAwait(false);
                    var aggregateRootVersion = events.ExpectedAggregateRootVersion.Value;

                    var committedEvents = new List <CommittedAggregateEvent>();

                    foreach (var @event in events)
                    {
                        var committedEvent = await _eventCommitter.CommitAggregateEvent(
                            transaction,
                            events.AggregateRoot,
                            aggregateRootVersion,
                            eventLogSequenceNumber,
                            DateTimeOffset.UtcNow,
                            events.EventSource,
                            _executionContextManager.Current,
                            @event,
                            cancel).ConfigureAwait(false);
                        committedEvents.Add(committedEvent);
                        eventLogSequenceNumber++;
                        aggregateRootVersion++;
                    }

                    await _aggregateRoots.IncrementVersionFor(
                        transaction,
                        events.EventSource,
                        events.AggregateRoot.Id,
                        events.ExpectedAggregateRootVersion,
                        aggregateRootVersion,
                        cancel).ConfigureAwait(false);

                    return new CommittedAggregateEvents(events.EventSource, events.AggregateRoot.Id, committedEvents);
                },
                           cancellationToken : cancellationToken).ConfigureAwait(false));
            }
            catch (MongoWaitQueueFullException ex)
            {
                throw new EventStoreUnavailable("Mongo wait queue is full", ex);
            }
        }