void NotifyStream(ScopeId scopeId, TypeFilterWithEventSourcePartitionDefinition filterDefinition, StreamPosition position)
{
if (position == StreamPosition.Start)
{
return;
}
if (filterDefinition.Public)
{
_streamWatcher.NotifyForEvent(filterDefinition.TargetStream, position - 1);
}
else
{
_streamWatcher.NotifyForEvent(scopeId, filterDefinition.TargetStream, position - 1);
}
}
void NotifyStream(ScopeId scopeId, IStreamDefinition streamDefinition, StreamPosition position)
{
if (position == StreamPosition.Start)
{
return;
}
if (streamDefinition.Public)
{
_streamWatcher.NotifyForEvent(streamDefinition.StreamId, position - 1);
}
else
{
_streamWatcher.NotifyForEvent(scopeId, streamDefinition.StreamId, position - 1);
}
}
/// <inheritdoc/>
public async Task <EventLogSequenceNumber> Write(CommittedEvent @event, ConsentId consentId, ScopeId scope, CancellationToken cancellationToken)
{
_logger.WritingEventHorizonEvent(
@event.EventLogSequenceNumber,
@event.ExecutionContext.Tenant,
@event.ExecutionContext.Microservice,
scope);
var writtenStreamPosition = await _eventsToStreamsWriter.Write(
await _streams.GetEventLog(scope, cancellationToken).ConfigureAwait(false),
_eventFilter,
streamPosition => _eventConverter.ToEventLogEvent(
new CommittedExternalEvent(
streamPosition.Value,
@event.Occurred,
@event.EventSource,
@event.ExecutionContext,
@event.Type,
false,
@event.Content,
@event.EventLogSequenceNumber,
DateTimeOffset.UtcNow,
consentId)),
cancellationToken).ConfigureAwait(false);
_streamWatcher.NotifyForEvent(scope, StreamId.EventLog, writtenStreamPosition);
return(writtenStreamPosition.Value);
}
/// <inheritdoc/>
public async Task Write(CommittedEvent @event, StreamId streamId, PartitionId partitionId, CancellationToken cancellationToken)
{
_logger.WritingEventToPublisStream(@event.EventLogSequenceNumber, streamId);
var writtenStreamPosition = await _eventsToStreamsWriter.Write(
await _streams.GetPublic(streamId, cancellationToken).ConfigureAwait(false),
_filter,
streamPosition => _eventConverter.ToStoreStreamEvent(@event, streamPosition, partitionId),
cancellationToken).ConfigureAwait(false);
_streamWatcher.NotifyForEvent(streamId, writtenStreamPosition);
}
protected static void setup_event_stream(params StreamEvent[] streamEvents)
{
events_fetcher
.Setup(_ => _.Fetch(It.IsAny <StreamPosition>(), It.IsAny <CancellationToken>()))
.Returns <StreamPosition, CancellationToken>((position, ct) =>
{
var events = streamEvents.Skip((int)position.Value);
return(events.Any()
? Task.FromResult(Try <IEnumerable <StreamEvent> > .Succeeded(events))
: Task.FromResult(Try <IEnumerable <StreamEvent> > .Failed(new Exception())));
});
event_waiter.NotifyForEvent(source_stream_id, (ulong)(streamEvents.Length - 1));
}
/// <inheritdoc/>
public async Task Write(CommittedEvent @event, ScopeId scope, StreamId stream, PartitionId partition, CancellationToken cancellationToken)
{
_logger.WritingEventToStream(@event.EventLogSequenceNumber, stream, scope);
var writtenStreamPosition = await Write(
await _streams.Get(scope, stream, cancellationToken).ConfigureAwait(false),
_streamFilter,
streamPosition =>
@event is CommittedExternalEvent externalEvent?
_eventConverter.ToStoreStreamEvent(externalEvent, streamPosition, partition)
: _eventConverter.ToStoreStreamEvent(@event, streamPosition, partition),
cancellationToken).ConfigureAwait(false);
_streamWatcher.NotifyForEvent(scope, stream, writtenStreamPosition);
}
/// <inheritdoc />
public async Task <Try> Persist(Commit commit, CancellationToken cancellationToken)
{
var eventsToStore = _commitConverter.ToEvents(commit).ToArray();
if (eventsToStore.Length == 0)
{
return(new NoEventsToCommit());
}
using var session = await _streams.StartSessionAsync(cancellationToken : cancellationToken).ConfigureAwait(false);
try
{
session.StartTransaction();
await _streams.DefaultEventLog.InsertManyAsync(
session,
eventsToStore,
cancellationToken : cancellationToken).ConfigureAwait(false);
await _aggregateVersions.UpdateAggregateVersions(session, commit, cancellationToken).ConfigureAwait(false);
await session.CommitTransactionAsync(cancellationToken).ConfigureAwait(false);
//TODO: Notifying for events should be a concern handled by actors
_streamWatcher.NotifyForEvent(ScopeId.Default, StreamId.EventLog, eventsToStore.Max(_ => _.EventLogSequenceNumber));
return(Try.Succeeded());
}
catch (MongoWaitQueueFullException ex)
{
await session.AbortTransactionAsync(cancellationToken).ConfigureAwait(false);
return(new EventStoreUnavailable("Mongo wait queue is full", ex));
}
catch (Exception ex)
{
await session.AbortTransactionAsync(cancellationToken).ConfigureAwait(false);
return(ex);
}
}