/// <summary>
/// Converts an <see cref="EventProcessorId" /> into its <see cref="BsonDocument" /> representation
/// </summary>
/// <param name="id">The <see cref="EventProcessorId" /></param>
/// <returns>A <see cref="BsonDocument" /> representation of the <see cref="EventProcessorId" /></returns>
public static BsonDocument AsBson(this EventProcessorId id)
{
return(new BsonDocument(new Dictionary <string, object>
{
{ Constants.ID, id.Value }
}));
}
Try <StreamProcessor> TryRegisterFilterStreamProcessor <TFilterDefinition>(
ScopeId scopeId,
EventProcessorId eventHandlerId,
Func <IFilterProcessor <TypeFilterWithEventSourcePartitionDefinition> > getFilterProcessor,
CancellationToken cancellationToken)
where TFilterDefinition : IFilterDefinition
{
_logger.Debug("Registering stream processor for Filter '{Filter}' on Event Log", eventHandlerId);
try
{
return(_streamProcessors.TryRegister(
scopeId,
eventHandlerId,
new EventLogStreamDefinition(),
getFilterProcessor,
cancellationToken,
out var outputtedFilterStreamProcessor), outputtedFilterStreamProcessor);
}
catch (Exception ex)
{
if (!cancellationToken.IsCancellationRequested)
{
_logger.Warning(
ex,
"Error occurred while trying to register stream processor for Filter '{Filter}'",
eventHandlerId);
}
return(ex);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="EventProcessor"/> class.
/// </summary>
/// <param name="scope">The <see cref="ScopeId" />.</param>
/// <param name="id">The <see cref="EventProcessorId" />.</param>
/// <param name="dispatcher"><see cref="ReverseCallDispatcherType"/> dispatcher.</param>
/// <param name="logger">The <see cref="ILogger" />.</param>
public EventProcessor(ScopeId scope, EventProcessorId id, ReverseCallDispatcherType dispatcher, ILogger logger)
{
Scope = scope;
Identifier = id;
_dispatcher = dispatcher;
_logger = logger;
}
/// <summary>
///
/// </summary>
/// <param name="eventProcessorId"></param>
/// <param name="committedEventVersion"></param>
/// <param name="partitionKey"></param>
/// <returns></returns>
public static Offset From(EventProcessorId eventProcessorId, CommittedEventVersion committedEventVersion, string partitionKey)
{
return(new Offset {
Id = eventProcessorId.ToString(), Major = committedEventVersion.Major, Minor = committedEventVersion.Minor,
Revision = committedEventVersion.Revision, PartitionKey = partitionKey
});
}
/// <summary>
/// Builds a <see cref="FilterDefinition{BsonDocument}" /> corresponding to the <see cref="EventProcessorId" /> supplied
/// </summary>
/// <param name="id">A <see cref="EventProcessorId" /></param>
/// <returns>A <see cref="FilterDefinition{BsonDocument}" /> corresponding to the <see cref="EventProcessorId" /></returns>
public static FilterDefinition <BsonDocument> ToFilter(this EventProcessorId id)
{
var builder = Builders <BsonDocument> .Filter;
var filter = builder.Eq(Constants.ID, id.Value);
return(filter);
}
Persistence.Offset GetOffset(EventProcessorId id)
{
using (var es = _database.GetContext())
{
return(es.Offsets.SingleOrDefault(_ => _.Id == id.ToString()));
}
}
Try <StreamProcessor> TryRegisterEventProcessorStreamProcessor(
ScopeId scopeId,
EventProcessorId eventHandlerId,
IStreamDefinition streamDefinition,
Func <IEventProcessor> getEventProcessor,
CancellationToken cancellationToken)
{
_logger.Debug("Registering stream processor for Event Processor '{EventProcessor}' on Stream '{SourceStream}'", eventHandlerId, streamDefinition.StreamId);
try
{
return(_streamProcessors.TryRegister(
scopeId,
eventHandlerId,
streamDefinition,
getEventProcessor,
cancellationToken,
out var outputtedEventProcessorStreamProcessor), outputtedEventProcessorStreamProcessor);
}
catch (Exception ex)
{
if (!cancellationToken.IsCancellationRequested)
{
_logger.Warning(
ex,
"Error occurred while trying to register stream processor for Event Processor '{EventProcessor}'",
eventHandlerId);
}
return(ex);
}
}
/// <inheritdoc />
public void Set(EventProcessorId eventProcessorId, CommittedEventVersion committedEventVersion)
{
_connection.AppendToStreamAsync(
GetStreamForEventProcessorId(eventProcessorId),
ExpectedVersion.Any,
CreateCommittedEventVersionEvent(committedEventVersion)
).Wait();
}
/// <inheritdoc />
public void Set(EventProcessorId eventProcessorId, CommittedEventVersion committedEventVersion)
{
var versionBson = committedEventVersion.AsBson();
versionBson.Add(Constants.ID, eventProcessorId.Value);
_offsets.ReplaceOne(eventProcessorId.ToFilter(), versionBson, new UpdateOptions {
IsUpsert = true
});
}
/// <inheritdoc />
public CommittedEventVersion Get(EventProcessorId eventProcessorId)
{
var result = _connection.ReadEventAsync(GetStreamForEventProcessorId(eventProcessorId), StreamPosition.End, true).Result;
if (result.Event.HasValue)
{
return(_serializer.FromJsonBytes <CommittedEventVersion>(result.Event.Value.Event.Data));
}
return(CommittedEventVersion.None);
}
/// <inheritdoc />
public CommittedEventVersion Get(EventProcessorId eventProcessorId)
{
var version = GetOffset(eventProcessorId);
if (version == null)
{
return(CommittedEventVersion.None);
}
return(version.ToCommittedEventVersion());
}
/// <inheritdoc />
public CommittedEventVersion Get(EventProcessorId eventProcessorId)
{
var version = _offsets.Find(eventProcessorId.ToFilter()).SingleOrDefault();
if (version == null)
{
return(CommittedEventVersion.None);
}
return(version.ToCommittedEventVersion());
}
/// <summary>
/// Initializes a new instance of the <see cref="EventProcessor"/> class.
/// </summary>
/// <param name="scope">The <see cref="ScopeId" />.</param>
/// <param name="id">The <see cref="EventProcessorId" />.</param>
/// <param name="dispatcher"><see cref="IReverseCallDispatcher{TClientMessage, TServerMessage, TConnectArguments, TConnectResponse, TRequest, TResponse}"/> dispatcher.</param>
/// <param name="logger">The <see cref="ILogger" />.</param>
public EventProcessor(
ScopeId scope,
EventProcessorId id,
IReverseCallDispatcher <EventHandlerClientToRuntimeMessage, EventHandlerRuntimeToClientMessage, EventHandlerRegistrationRequest, EventHandlerRegistrationResponse, HandleEventRequest, EventHandlerResponse> dispatcher,
ILogger logger)
{
Scope = scope;
Identifier = id;
_dispatcher = dispatcher;
_logger = logger;
_logMessagePrefix = $"Event Processor '{Identifier}'";
}
/// <inheritdoc />
public void Set(EventProcessorId eventProcessorId, CommittedEventVersion committedEventVersion)
{
using (var es = _database.GetContext())
{
//TODO: this can be optimized so that the update is the thing we expect most and the insert is the edge case
var commandText = "INSERT OR REPLACE INTO Offsets (Id, Major, Minor, Revision) VALUES (@Id,@Major,@Minor,@Revision);";
var id = new SqliteParameter("@Id", eventProcessorId.Value.ToString());
var major = new SqliteParameter("@Major", committedEventVersion.Major);
var minor = new SqliteParameter("@Minor", committedEventVersion.Minor);
var revision = new SqliteParameter("@Revision", committedEventVersion.Revision);
es.Database.ExecuteSqlCommand(commandText, id, major, minor, revision);
}
}
/// <summary>
/// Initializes a new instance of <see cref="ProcessMethodEventProcessor"/>
/// </summary>
/// <param name="objectFactory"><see cref="IObjectFactory"/> for going between <see cref="PropertyBag"/> and instances of types</param>
/// <param name="container"><see cref="IContainer"/> to use for getting instances of <see cref="ICanProcessEvents"/> implementation</param>
/// <param name="identifier"><see cref="EventProcessorId"/> that uniquely identifies the <see cref="ProcessMethodEventProcessor"/></param>
/// <param name="eventIdentifier"><see cref="Artifact">Identifier</see> for identifying the <see cref="IEvent"/></param>
/// <param name="eventType"><see cref="Type"/> type of <see cref="IEvent"/>></param>
/// <param name="methodInfo"><see cref="MethodInfo"/> for the actual process method</param>
/// <param name="logger"></param>
public ProcessMethodEventProcessor(
IObjectFactory objectFactory,
IContainer container,
EventProcessorId identifier,
Artifact eventIdentifier,
Type eventType,
MethodInfo methodInfo,
ILogger logger)
{
Identifier = identifier;
Event = eventIdentifier;
_logger = logger;
_logger.Trace($"ProcessMethodEventProcessor for '{eventIdentifier}' exists on type '{methodInfo}'");
_invoker = GetProcessorMethodInvokerFor(methodInfo, eventType, objectFactory, container, logger);
}
async Task SetAsync(EventProcessorId eventProcessorId, CommittedEventVersion committedEventVersion)
{
var offset = Offset.From(eventProcessorId, committedEventVersion, _config.BasePartitionKey);
try
{
var result = await _config.Client.UpsertDocumentAsync(_config.OffsetsUri, offset, new RequestOptions { PartitionKey = new PartitionKey(_config.BasePartitionKey) });
_logger.Debug(ResponseMetadata.FromOffset("Setting Offset", result)?.ToString());
}
catch (DocumentClientException ex)
{
throw new EventStorePersistenceError("Error", ex);
}
}
async Task <bool> RejectIfInvalidFilterId <TClientMessage, TConnectRequest, TResponse>(
IReverseCallDispatcher <TClientMessage, FilterRuntimeToClientMessage, TConnectRequest, FilterRegistrationResponse, FilterEventRequest, TResponse> dispatcher,
EventProcessorId filterId,
CancellationToken cancellationToken)
where TClientMessage : IMessage, new()
where TConnectRequest : class
where TResponse : class
{
StreamId filterStream = filterId.Value;
if (filterStream.IsNonWriteable)
{
_logger.FilterIsInvalid(filterStream);
var failure = new Failure(FiltersFailures.CannotRegisterFilterOnNonWriteableStream, $"Filter Id: '{filterId.Value}' is an invalid Stream Id");
await WriteFailedRegistrationResponse(dispatcher, failure, cancellationToken).ConfigureAwait(false);
return(true);
}
return(false);
}
public void IterationSetup()
{
_stopStreamProcessorSource = new CancellationTokenSource();
var numEventsProcessed = 0;
_streamProcessorsToRun = Enumerable.Range(0, EventHandlerFilters).Select(_ =>
{
var eventHandlerId = new EventProcessorId(Guid.NewGuid());
return(_streamProcessors.TryCreateAndRegister(
ScopeId.Default,
eventHandlerId,
new EventLogStreamDefinition(),
tenant => new TypeFilterWithEventSourcePartition(
ScopeId.Default,
new TypeFilterWithEventSourcePartitionDefinition(StreamId.EventLog, eventHandlerId.Value, _eventTypes, Partitioned),
GetEventWriterForTenant(tenant),
_loggerFactor.CreateLogger <TypeFilterWithEventSourcePartition>()),
Runtime.CreateExecutionContextFor("e3921d20-da26-422e-bf13-e959a5f505ef"),
_stopStreamProcessorSource.Token).Result);
}).ToArray();
IWriteEventsToStreams GetEventWriterForTenant(TenantId tenant)
{
var writer = _getEventsToStreamsWriter(tenant);
var wrappedWriter = new Mock <IWriteEventsToStreams>();
wrappedWriter
.Setup(_ => _.Write(It.IsAny <CommittedEvent>(), It.IsAny <ScopeId>(), It.IsAny <StreamId>(), Moq.It.IsAny <PartitionId>(), Moq.It.IsAny <CancellationToken>()))
.Returns <CommittedEvent, ScopeId, StreamId, PartitionId, CancellationToken>(async(@event, scope, stream, partition, cancellation) =>
{
Interlocked.Add(ref numEventsProcessed, 1);
await writer.Write(@event, scope, stream, partition, cancellation).ConfigureAwait(false);
if (numEventsProcessed == NumberEventsToProcess)
{
_stopStreamProcessorSource.Cancel();
}
});
return(wrappedWriter.Object);
}
}
/// <inheritdoc />
public bool TryRegister(
ScopeId scopeId,
EventProcessorId eventProcessorId,
IStreamDefinition streamDefinition,
Func <IEventProcessor> getEventProcessor,
CancellationToken cancellationToken,
out StreamProcessor streamProcessor)
{
streamProcessor = default;
var streamProcessorId = new StreamProcessorId(scopeId, eventProcessorId, streamDefinition.StreamId);
if (_streamProcessors.ContainsKey(streamProcessorId))
{
_logger.Warning("Stream Processor with Id: '{streamProcessorId}' already registered", streamProcessorId);
return(false);
}
streamProcessor = new StreamProcessor(
streamProcessorId,
_onAllTenants,
streamDefinition,
getEventProcessor,
() => Unregister(streamProcessorId),
_getScopedStreamProcessorsCreator,
_executionContextManager,
_loggerManager.CreateLogger <StreamProcessor>(),
cancellationToken);
if (!_streamProcessors.TryAdd(streamProcessorId, streamProcessor))
{
_logger.Warning("Stream Processor with Id: '{StreamProcessorId}' already registered", streamProcessorId);
streamProcessor = default;
return(false);
}
_logger.Trace("Stream Processor with Id: '{StreamProcessorId}' registered", streamProcessorId);
return(true);
}
/// <inheritdoc />
public CommittedEventVersion Get(EventProcessorId eventProcessorId)
{
return(_lastProcessed.TryGetValue(eventProcessorId, out CommittedEventVersion lastProcessedVersion) ? lastProcessedVersion : CommittedEventVersion.None);
}
/// <inheritdoc/>
public override Task <IFilterResult> Filter(CommittedEvent @event, PartitionId partitionId, EventProcessorId eventProcessorId, string failureReason, uint retryCount, ExecutionContext executionContext, CancellationToken cancellationToken)
{
if ([email protected])
{
return(Task.FromResult <IFilterResult>(new SuccessfulFiltering(false, PartitionId.None)));
}
var request = new FilterEventRequest
{
Event = @event.ToProtobuf(),
ScopeId = Scope.ToProtobuf(),
RetryProcessingState = new RetryProcessingState {
FailureReason = failureReason, RetryCount = retryCount
}
};
return(Filter(request, executionContext, cancellationToken));
}
/// <inheritdoc/>
public override Task <IFilterResult> Filter(CommittedEvent @event, PartitionId partitionId, EventProcessorId eventProcessorId, ExecutionContext executionContext, CancellationToken cancellationToken)
{
if ([email protected])
{
return(Task.FromResult <IFilterResult>(new SuccessfulFiltering(false, PartitionId.None)));
}
var request = new FilterEventRequest
{
Event = @event.ToProtobuf(),
ScopeId = Scope.ToProtobuf()
};
return(Filter(request, executionContext, cancellationToken));
}
/// <inheritdoc/> public abstract Task <IFilterResult> Filter(CommittedEvent @event, PartitionId partitionId, EventProcessorId eventProcessorId, string failureReason, uint retryCount, CancellationToken cancellationToken);
/// <inheritdoc/> public abstract Task <IFilterResult> Filter(CommittedEvent @event, PartitionId partitionId, EventProcessorId eventProcessorId, CancellationToken cancellationToken);
internal static partial void ConnectingEventHandlerWithId(this ILogger logger, EventProcessorId eventHandler);
/// <inheritdoc/>
public override Task <IFilterResult> Filter(CommittedEvent @event, PartitionId partitionId, EventProcessorId eventProcessorId, string failureReason, uint retryCount, CancellationToken cancellationToken)
{
_logger.Debug(
"Filter event that occurred @ {Occurred} to public events stream '{TargetStream}' again for the {RetryCount}. time because: {FailureReason}",
@event.Occurred,
Definition.TargetStream,
retryCount,
failureReason);
if ([email protected])
{
return(Task.FromResult <IFilterResult>(new SuccessfulFiltering(false, Guid.Empty)));
}
var request = new FilterEventRequest
{
Event = @event.ToProtobuf(),
ScopeId = Scope.ToProtobuf(),
RetryProcessingState = new RetryProcessingState {
FailureReason = failureReason, RetryCount = retryCount
}
};
return(Filter(request, cancellationToken));
}
/// <inheritdoc/>
public override Task <IFilterResult> Filter(CommittedEvent @event, PartitionId partitionId, EventProcessorId eventProcessorId, CancellationToken cancellationToken)
{
_logger.Debug(
"Filter event that occurred @ {Occurred} to public events stream '{TargetStream}'",
@event.Occurred,
Definition.TargetStream);
if ([email protected])
{
return(Task.FromResult <IFilterResult>(new SuccessfulFiltering(false, Guid.Empty)));
}
var request = new FilterEventRequest
{
Event = @event.ToProtobuf(),
ScopeId = Scope.ToProtobuf()
};
return(Filter(request, cancellationToken));
}
/// <inheritdoc />
public void Set(EventProcessorId eventProcessorId, CommittedEventVersion committedEventVersion)
{
_lastProcessed.AddOrUpdate(eventProcessorId, committedEventVersion, (id, v) => committedEventVersion);
_logger.Information($"Saving event processor offset");
_jsRuntime.Invoke($"{_globalObject}.save", eventProcessorId, committedEventVersion);
}
public EventProcessorOffset(EventProcessorId eventProcessorId, CommittedEventVersion content)
{
EventProcessorId = eventProcessorId;
Content = content;
}
public static Mock <IEventProcessor> an_event_processor_mock(Artifact artifact, EventProcessorId id)
{
var mock = new Mock <IEventProcessor>();
mock.SetupGet(_ => _.Event).Returns(artifact);
mock.SetupGet(_ => _.Identifier).Returns(id);
return(mock);
}
