/// <summary>
/// Initializes a new instance of <see cref="EventHandler"/>.
/// </summary>
/// <param name="streamProcessors">The <see cref="IStreamProcessors" />.</param>
/// <param name="filterValidationForAllTenants">The <see cref="IValidateFilterForAllTenants" /> for validating the filter definition.</param>
/// <param name="streamDefinitions">The<see cref="IStreamDefinitions" />.</param>
/// <param name="arguments">Connecting arguments.</param>
/// <param name="filterProcessorForTenant"></param>
/// <param name="eventProcessorForTenant">The event processor.</param>
/// <param name="acceptRegistration">Accepts the event handler registration.</param>
/// <param name="rejectRegistration">Rejects the event handler registration.</param>
/// <param name="logger">Logger for logging.</param>
/// <param name="executionContext">The execution context for the event handler.</param>
/// <param name="cancellationToken">Cancellation token that can cancel the hierarchy.</param>
public EventHandler(
IStreamProcessors streamProcessors,
IValidateFilterForAllTenants filterValidationForAllTenants,
IStreamDefinitions streamDefinitions,
EventHandlerRegistrationArguments arguments,
Func <TenantId, IFilterProcessor <TypeFilterWithEventSourcePartitionDefinition> > filterProcessorForTenant,
Func <TenantId, IEventProcessor> eventProcessorForTenant,
Func <CancellationToken, Task> acceptRegistration,
Func <Failure, CancellationToken, Task> rejectRegistration,
ILogger logger,
ExecutionContext executionContext,
CancellationToken cancellationToken)
{
_logger = logger;
_streamProcessors = streamProcessors;
_filterValidator = filterValidationForAllTenants;
_streamDefinitions = streamDefinitions;
_arguments = arguments;
_filterProcessorForTenant = filterProcessorForTenant;
_executionContext = executionContext;
_eventProcessorForTenant = eventProcessorForTenant;
_acceptRegistration = acceptRegistration;
_rejectRegistration = rejectRegistration;
_cancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
}
/// <inheritdoc/>
public async Task <Try> TryUpdateAll(ExecutionContext executionContext, CancellationToken cancellationToken)
{
_logger.UpdatingAllEmbeddingStates(_embedding);
var keys = await _embeddingStore.TryGetKeys(_embedding, cancellationToken).ConfigureAwait(false);
if (!keys.Success)
{
return(keys);
}
var result = Try.Succeeded();
foreach (var key in keys.Result)
{
_logger.UpdatingEmbeddingStateFor(_embedding, key);
var updateResult = await TryUpdateEmbedding(key, executionContext, cancellationToken).ConfigureAwait(false);
if (!updateResult.Success)
{
_logger.FailedUpdatingEmbeddingStateFor(_embedding, key, updateResult.Exception);
result = result.Success ? updateResult : result;
}
}
return(result);
}
async Task <IProcessingResult> Process(HandleEventRequest request, ExecutionContext executionContext, CancellationToken cancellationToken)
{
var response = await _dispatcher.Call(request, executionContext, cancellationToken).ConfigureAwait(false);
return(response switch
{
{ Failure : null } => new SuccessfulProcessing(),
async Task <Try> TryUpdateEmbedding(ProjectionKey key, ExecutionContext executionContext, CancellationToken cancellationToken)
{
var currentState = await _embeddingStore.TryGet(_embedding, key, cancellationToken).ConfigureAwait(false);
if (!currentState.Success)
{
return(currentState);
}
var unprocessedEvents = await TryGetUnprocessedEvents(key, currentState.Result.Version, cancellationToken).ConfigureAwait(false);
if (!unprocessedEvents.Success)
{
return(Try.Failed(unprocessedEvents.Exception));
}
if (!unprocessedEvents.Result.Any())
{
return(Try.Succeeded());
}
var projectedState = await _projectManyEvents.TryProject(currentState, unprocessedEvents, executionContext, cancellationToken).ConfigureAwait(false);
if (projectedState.Success || projectedState.IsPartialResult)
{
var updateState = await TryUpdateOrDeleteState(projectedState.Result, cancellationToken).ConfigureAwait(false);
if (updateState.Success && projectedState.IsPartialResult)
{
return(projectedState.Exception);
}
return(updateState);
}
return(Try.Failed(projectedState.Exception));
}
Try <StreamProcessor> TryRegisterStreamProcessor <TFilterDefinition>(
ScopeId scopeId,
TFilterDefinition filterDefinition,
Func <TenantId, IFilterProcessor <TFilterDefinition> > getFilterProcessor,
ExecutionContext executionContext,
CancellationToken cancellationToken)
where TFilterDefinition : IFilterDefinition
{
_logger.RegisteringStreamProcessorForFilter(filterDefinition.TargetStream, filterDefinition.SourceStream);
try
{
return(_streamProcessors.TryCreateAndRegister(
scopeId,
filterDefinition.TargetStream.Value,
new EventLogStreamDefinition(),
getFilterProcessor,
executionContext,
cancellationToken));
}
catch (Exception ex)
{
if (!cancellationToken.IsCancellationRequested)
{
_logger.ErrorWhileRegisteringStreamProcessorForFilter(ex, filterDefinition.TargetStream, filterDefinition.SourceStream);
}
return(ex);
}
}
/// <inheritdoc />
protected override void Setup(IServiceProvider services)
{
_eventStore = services.GetRequiredService <IEventStore>();
_executionContext = Runtime.CreateExecutionContextFor(ConfiguredTenants.First());
var events = new List <UncommittedEvent>();
for (var n = 0; n < EventsToCommit; n++)
{
events.Add(new UncommittedEvent(
new EventSourceId("8453f4d4-861a-4042-a4e3-c1abf1c8eadd"),
new Artifact(new ArtifactId(Guid.Parse("752f88c9-70f0-4ffe-82b6-a69dcc96672e")), ArtifactGeneration.First),
false,
"{ \"hello\": \"world\" }"));
}
_eventsToCommit = new UncommittedEvents(events);
if (PreExistingEvents < 1)
{
return;
}
var preExistingEvents = new List <UncommittedEvent>();
for (var n = 0; n < PreExistingEvents; n++)
{
preExistingEvents.Add(new UncommittedEvent(
new EventSourceId("8453f4d4-861a-4042-a4e3-c1abf1c8eadd"),
new Artifact(new ArtifactId(Guid.Parse("752f88c9-70f0-4ffe-82b6-a69dcc96672e")), ArtifactGeneration.First),
false,
"{ \"hello\": \"world\" }"));
}
_eventStore.Commit(new UncommittedEvents(preExistingEvents), _executionContext).GetAwaiter().GetResult();
}
async Task <IFilterResult> Filter(FilterEventRequest request, ExecutionContext executionContext, CancellationToken cancellationToken)
{
var response = await _dispatcher.Call(request, executionContext, cancellationToken).ConfigureAwait(false);
return(response switch
{
{ Failure : null } => new SuccessfulFiltering(response.IsIncluded, response.PartitionId),
static void should_have_same_execution_context(ExecutionContext execution_context, Dolittle.Runtime.Events.Store.MongoDB.Events.ExecutionContext stored_execution_context)
{
stored_execution_context.Correlation.ShouldEqual(execution_context.CorrelationId.Value);
stored_execution_context.Environment.ShouldEqual(execution_context.Environment.Value);
stored_execution_context.Microservice.ShouldEqual(execution_context.Microservice.Value);
stored_execution_context.Tenant.ShouldEqual(execution_context.Tenant.Value);
should_have_the_same_version(execution_context.Version, stored_execution_context.Version);
should_have_the_same_claims(execution_context.Claims, stored_execution_context.Claims);
}
/// <summary>
/// Initializes a new instance of the <see cref="EventHorizonConnection" /> class.
/// </summary>
/// <param name="executionContext">The <see cref="ExecutionContext"/>.</param>
/// <param name="reverseCallClient">The reverse call client.</param>
/// <param name="metrics">The system for collecting metrics.</param>
/// <param name="logger">The logger.</param>
public EventHorizonConnection(
ExecutionContext executionContext,
IReverseCallClient <ConsumerSubscriptionRequest, Contracts.SubscriptionResponse, ConsumerRequest, ConsumerResponse> reverseCallClient,
IMetricsCollector metrics,
ILogger logger)
{
_executionContext = executionContext;
_reverseCallClient = reverseCallClient;
_metrics = metrics;
_logger = logger;
}
Task <Try <ExecutionContext> > CreateExecutionContextOrReject <TClientMessage, TConnectRequest, TResponse>(
IReverseCallDispatcher <TClientMessage, FilterRuntimeToClientMessage, TConnectRequest, FilterRegistrationResponse, FilterEventRequest, TResponse> dispatcher,
ExecutionContext requestExecutionContext,
CancellationToken cancellationToken)
where TClientMessage : IMessage, new()
where TConnectRequest : class
where TResponse : class
=> _executionContextCreator
.TryCreateUsing(requestExecutionContext)
.Catch(async exception =>
{
_logger.ExecutionContextIsNotValid(exception);
var failure = new Failure(FiltersFailures.CannotRegisterFilterOnNonWriteableStream, $"Execution context is invalid: {exception.Message}");
await WriteFailedRegistrationResponse(dispatcher, failure, cancellationToken).ConfigureAwait(false);
});
/// <summary>
/// Initializes a new instance of the <see cref="ScopedStreamProcessor"/> class.
/// </summary>
/// <param name="tenantId">The <see cref="TenantId"/>.</param>
/// <param name="streamProcessorId">The <see cref="IStreamProcessorId" />.</param>
/// <param name="sourceStreamDefinition">The source stream <see cref="IStreamDefinition" />.</param>
/// <param name="initialState">The <see cref="StreamProcessorState" />.</param>
/// <param name="processor">An <see cref="IEventProcessor" /> to process the event.</param>
/// <param name="streamProcessorStates">The <see cref="IResilientStreamProcessorStateRepository" />.</param>
/// <param name="eventsFromStreamsFetcher">The<see cref="ICanFetchEventsFromStream" />.</param>
/// <param name="executionContext">The <see cref="ExecutionContext"/> of the stream processor.</param>
/// <param name="eventFetcherPolicies">The policies to use while fetching events.</param>
/// <param name="eventWatcher">The <see cref="IStreamEventWatcher" /> to wait for events to be available in stream.</param>
/// <param name="timeToRetryGetter">The <see cref="ICanGetTimeToRetryFor{T}" /> <see cref="StreamProcessorState" />.</param>
/// <param name="logger">An <see cref="ILogger" /> to log messages.</param>
public ScopedStreamProcessor(
TenantId tenantId,
IStreamProcessorId streamProcessorId,
IStreamDefinition sourceStreamDefinition,
StreamProcessorState initialState,
IEventProcessor processor,
IResilientStreamProcessorStateRepository streamProcessorStates,
ICanFetchEventsFromStream eventsFromStreamsFetcher,
ExecutionContext executionContext,
IEventFetcherPolicies eventFetcherPolicies,
IStreamEventWatcher eventWatcher,
ICanGetTimeToRetryFor <StreamProcessorState> timeToRetryGetter,
ILogger logger)
: base(tenantId, streamProcessorId, sourceStreamDefinition, initialState, processor, eventsFromStreamsFetcher, executionContext, eventFetcherPolicies, eventWatcher, logger)
{
_streamProcessorStates = streamProcessorStates;
_timeToRetryGetter = timeToRetryGetter;
}
/// <inheritdoc />
public async Task <AbstractScopedStreamProcessor> Create(
IStreamDefinition streamDefinition,
IStreamProcessorId streamProcessorId,
IEventProcessor eventProcessor,
ExecutionContext executionContext,
CancellationToken cancellationToken)
{
var processorState = await GetOrCreateStreamProcessorState(
streamProcessorId,
streamDefinition.Partitioned
?Partitioned.StreamProcessorState.New
: StreamProcessorState.New,
cancellationToken)
.ConfigureAwait(false);
AbstractScopedStreamProcessor streamProcessor;
if (streamDefinition.Partitioned)
{
if (processorState is not Partitioned.StreamProcessorState partitionedProcessorState)
{
throw new ExpectedPartitionedStreamProcessorState(streamProcessorId);
}
var eventFetcher = await _eventFetchers.GetPartitionedFetcherFor(eventProcessor.Scope, streamDefinition, cancellationToken).ConfigureAwait(false);
streamProcessor = _createPartitionedStreamProcessor(streamDefinition, streamProcessorId, eventFetcher, eventProcessor, partitionedProcessorState, executionContext);
}
else
{
if (processorState is not StreamProcessorState unpartitionedProcessorState)
{
throw new ExpectedUnpartitionedStreamProcessorState(streamProcessorId);
}
var eventFetcher = await _eventFetchers.GetFetcherFor(eventProcessor.Scope, streamDefinition, cancellationToken).ConfigureAwait(false);
streamProcessor = _createUnpartitionedStreamProcessor(streamDefinition, streamProcessorId, eventFetcher, eventProcessor, unpartitionedProcessorState, executionContext);
}
NotifyStream(streamProcessorId.ScopeId, streamDefinition, processorState.Position);
return(streamProcessor);
}
/// <summary>
/// Initializes a new instance of the <see cref="ScopedStreamProcessor"/> class.
/// </summary>
/// <param name="tenantId">The <see cref="TenantId"/>.</param>
/// <param name="streamProcessorId">The <see cref="IStreamProcessorId" />.</param>
/// <param name="sourceStreamDefinition">The source stream <see cref="StreamDefinition" />.</param>
/// <param name="initialState">The <see cref="StreamProcessorState" />.</param>
/// <param name="processor">An <see cref="IEventProcessor" /> to process the event.</param>
/// <param name="streamProcessorStates">The <see cref="IResilientStreamProcessorStateRepository" />.</param>
/// <param name="eventsFromStreamsFetcher">The<see cref="ICanFetchEventsFromStream" />.</param>
/// <param name="executionContext">The <see cref="ExecutionContext"/> of the stream processor.</param>
/// <param name="failingPartitionsFactory">The factory to use to create the <see cref="IFailingPartitions" />.</param>
/// <param name="eventFetcherPolicies">The policies to use while fetching events.</param>
/// <param name="streamWatcher">The <see cref="IStreamEventWatcher" />.</param>
/// <param name="timeToRetryGetter">The <see cref="ICanGetTimeToRetryFor{T}" /> <see cref="StreamProcessorState" />.</param>
/// <param name="logger">An <see cref="ILogger" /> to log messages.</param>
public ScopedStreamProcessor(
TenantId tenantId,
IStreamProcessorId streamProcessorId,
IStreamDefinition sourceStreamDefinition,
StreamProcessorState initialState,
IEventProcessor processor,
IResilientStreamProcessorStateRepository streamProcessorStates,
ICanFetchEventsFromPartitionedStream eventsFromStreamsFetcher,
ExecutionContext executionContext,
Func <IEventProcessor, ICanFetchEventsFromPartitionedStream, Func <StreamEvent, ExecutionContext>, IFailingPartitions> failingPartitionsFactory,
IEventFetcherPolicies eventFetcherPolicies,
IStreamEventWatcher streamWatcher,
ICanGetTimeToRetryFor <StreamProcessorState> timeToRetryGetter,
ILogger logger)
: base(tenantId, streamProcessorId, sourceStreamDefinition, initialState, processor, eventsFromStreamsFetcher, executionContext, eventFetcherPolicies, streamWatcher, logger)
{
_streamProcessorStates = streamProcessorStates;
_failingPartitions = failingPartitionsFactory(processor, eventsFromStreamsFetcher, GetExecutionContextForEvent);
_timeToRetryGetter = timeToRetryGetter;
}
/// <summary>
/// Initializes a new instance of the <see cref="StreamProcessor"/> class.
/// </summary>
/// <param name="subscriptionId">The identifier of the subscription the stream processor will receive events for.</param>
/// <param name="executionContext">The <see cref="ExecutionContext"/>.</param>
/// <param name="eventProcessor">The event processor that writes the received events to a scoped event log.</param>
/// <param name="eventsFetcher">The event fetcher that receives fetches events over an event horizon connection.</param>
/// <param name="streamProcessorStates">The repository to use for getting the subscription state.</param>
/// <param name="eventsFetcherPolicy">The policy around fetching events.</param>
/// <param name="metrics">The system for collecting metrics.</param>
/// <param name="loggerFactory">The factory for creating loggers.</param>
public StreamProcessor(
SubscriptionId subscriptionId,
ExecutionContext executionContext,
IEventProcessor eventProcessor,
EventsFromEventHorizonFetcher eventsFetcher,
IResilientStreamProcessorStateRepository streamProcessorStates,
IEventFetcherPolicies eventsFetcherPolicy,
IMetricsCollector metrics,
ILoggerFactory loggerFactory)
{
_identifier = subscriptionId;
_executionContext = executionContext;
_eventProcessor = eventProcessor;
_streamProcessorStates = streamProcessorStates;
_eventsFetcher = eventsFetcher;
_eventsFetcherPolicy = eventsFetcherPolicy;
_metrics = metrics;
_loggerFactory = loggerFactory;
_logger = loggerFactory.CreateLogger <StreamProcessor>();
}
async Task <Try <EmbeddingCurrentState> > TryProjectNewState(
EmbeddingCurrentState current,
Try <UncommittedEvents> newTransitionEvents,
IEnumerable <ProjectionState> previousStates,
ExecutionContext executionContext,
CancellationToken cancellationToken)
{
var intermediateState = await _projector.TryProject(current, newTransitionEvents.Result, executionContext, cancellationToken).ConfigureAwait(false);
if (!intermediateState.Success)
{
return(intermediateState.IsPartialResult
? new CouldNotProjectAllEvents(_embeddingId, intermediateState.Exception)
: new FailedProjectingEvents(_embeddingId, intermediateState.Exception));
}
var loopDetected = _loopDetector.TryCheckForProjectionStateLoop(intermediateState.Result.State, previousStates);
return(loopDetected switch
{
{ Success : false } => loopDetected.Exception,
public static void should_be_the_correct_response(
this CommitAggregateEventsResponse response,
UncommittedAggregateEvents uncommitted_events,
ExecutionContext execution_context,
EventLogSequenceNumber start_sequence_number = null,
AggregateRootVersion start_aggregate_root_version = null)
{
var committedEvents = response.Events.ToCommittedEvents();
committedEvents.Count.ShouldEqual(uncommitted_events.Count);
if (uncommitted_events.Count == 0)
{
return;
}
committedEvents.AggregateRoot.ShouldEqual(uncommitted_events.AggregateRoot.Id);
committedEvents.EventSource.ShouldEqual(uncommitted_events.EventSource);
for (var i = 0; i < committedEvents.Count; i++)
{
var committedEvent = committedEvents[i];
var uncommittedEvent = uncommitted_events[i];
if (start_sequence_number != null)
{
committedEvent.EventLogSequenceNumber.ShouldEqual(new EventLogSequenceNumber(start_sequence_number + (ulong)i));
}
if (start_aggregate_root_version != null)
{
committedEvent.AggregateRootVersion.ShouldEqual(new AggregateRootVersion(start_aggregate_root_version + (ulong)i));
}
committedEvent.AggregateRoot.ShouldEqual(uncommitted_events.AggregateRoot);
committedEvent.ExecutionContext.ShouldEqual(execution_context);
committedEvent.Content.ShouldEqual(uncommittedEvent.Content);
committedEvent.Public.ShouldEqual(uncommittedEvent.Public);
committedEvent.Type.ShouldEqual(uncommittedEvent.Type);
committedEvent.EventSource.ShouldEqual(uncommittedEvent.EventSource);
}
}
/// <inheritdoc />
protected override void Setup(IServiceProvider services)
{
_eventStore = services.GetRequiredService <IEventStore>();
_executionContext = Runtime.CreateExecutionContextFor(ConfiguredTenants.First());
var events = new List <UncommittedEvent>();
for (var n = 0; n < EventsToCommit; n++)
{
events.Add(new UncommittedEvent(
new EventSourceId("46c4de33-9a60-4465-97ab-a2a7f5b7e6a3"),
new Artifact(new ArtifactId(Guid.Parse("08db4b0a-3724-444f-9968-ada44922fb78")), ArtifactGeneration.First),
false,
"{ \"hello\": \"world\" }"));
}
_eventsToCommit = new UncommittedAggregateEvents(
new EventSourceId("46c4de33-9a60-4465-97ab-a2a7f5b7e6a3"),
new Artifact(new ArtifactId(Guid.Parse("1ad7a5dc-12e9-493a-ba10-714c88be4da7")), ArtifactGeneration.First),
AggregateRootVersion.Initial,
events);
}
public static void should_be_the_correct_responses(this CommitAggregateEventsResponse[] responses, UncommittedAggregateEvents[] uncommitted_events, ExecutionContext execution_context, bool random_commit_order = false)
{
var startEventLogSequenceNumber = EventLogSequenceNumber.Initial;
for (var i = 0; i < responses.Length; i++)
{
var response = responses[i];
var events = uncommitted_events[i];
response.should_be_the_correct_response(events, execution_context, random_commit_order ? response.Events?.Events?.First().EventLogSequenceNumber : startEventLogSequenceNumber);
startEventLogSequenceNumber += (ulong)events.Count;
}
}
/// <inheritdoc/>
public Task <Try <UncommittedAggregateEvents> > TryDelete(EmbeddingCurrentState current, ExecutionContext executionContext, CancellationToken cancellationToken)
=> DoWork(
current,
newCurrent => Try <bool> .Do(() => newCurrent.Type is EmbeddingCurrentStateType.Deleted),
(newCurrent, token) => _embedding.TryDelete(newCurrent, executionContext, token),
executionContext,
cancellationToken);
/// <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));
}
public static async Task <CommitEventsResponse> Commit(this IEventStore eventStore, UncommittedEvents events, Dolittle.Runtime.Execution.ExecutionContext executionContext)
{
var request = new CommitEventsRequest {
CallContext = new CallRequestContext {
ExecutionContext = executionContext.ToProtobuf()
}
};
request.Events.AddRange(events.Select(_ => new UncommittedEventContract
{
Content = _.Content,
Public = _.Public,
EventType = _.Type.ToProtobuf(),
EventSourceId = _.EventSource
}));
var response = await eventStore.CommitEvents(request, CancellationToken.None).ConfigureAwait(false);
return(response);
}
/// <inheritdoc/>
public override Task <IFilterResult> Filter(CommittedEvent @event, PartitionId partitionId, EventProcessorId eventProcessorId, ExecutionContext executionContext, CancellationToken cancellationToken)
{
var request = new FilterEventRequest
{
Event = @event.ToProtobuf(),
ScopeId = Scope.ToProtobuf()
};
return(Filter(request, executionContext, cancellationToken));
}
/// <inheritdoc/>
public async Task <IProcessingResult> Process(CommittedEvent @event, PartitionId partitionId, string failureReason, uint retryCount, ExecutionContext executionContext, CancellationToken cancellationToken)
{
_logger.FilteringEventAgain(Identifier, Scope, @event.Type.Id, partitionId, retryCount, failureReason);
var result = await Filter(@event, partitionId, Identifier, failureReason, retryCount, executionContext, cancellationToken).ConfigureAwait(false);
return(await HandleResult(result, @event, partitionId, cancellationToken).ConfigureAwait(false));
}
/// <inheritdoc/> public abstract Task <IFilterResult> Filter(CommittedEvent @event, PartitionId partitionId, EventProcessorId eventProcessorId, ExecutionContext executionContext, CancellationToken cancellationToken);
async Task <Try <UncommittedAggregateEvents> > DoWork(
EmbeddingCurrentState current,
Func <EmbeddingCurrentState, Try <bool> > isDesiredState,
Func <EmbeddingCurrentState, CancellationToken, Task <Try <UncommittedEvents> > > getTransitionEvents,
ExecutionContext executionContext,
CancellationToken cancellationToken)
{
try
{
_logger.CalculatingStateTransitionEvents(_embeddingId, current.Key, current.Version);
var allTransitionEvents = new List <UncommittedEvents>();
var previousStates = new List <ProjectionState>
{
current.State
};
while (true)
{
if (cancellationToken.IsCancellationRequested)
{
_logger.CalculatingStateTransitionEventsCancelled(_embeddingId, current.Key, current.Version);
return(new CalculateStateTransitionEventsCancelled(_embeddingId));
}
var getEventsToCommit = TryCheckIfDesiredState(current, allTransitionEvents, isDesiredState, out var eventsToCommit);
if (!getEventsToCommit.Success || getEventsToCommit.Result)
{
if (getEventsToCommit.Exception != default)
{
_logger.CalculatingStateTransitionEventsFailedCheckingIfDesiredState(
_embeddingId,
current.Key,
current.Version,
getEventsToCommit.Exception);
return(getEventsToCommit.Exception);
}
return(eventsToCommit);
}
var addNewTransitionEvents = await TryGetAndAddNewTransitionEventsInto(
allTransitionEvents,
current,
getTransitionEvents,
cancellationToken).ConfigureAwait(false);
if (!addNewTransitionEvents.Success)
{
_logger.CalculatingStateTransitionEventsFailedGettingNextTransitionEvents(
_embeddingId,
current.Key,
current.Version,
addNewTransitionEvents.Exception);
return(addNewTransitionEvents.Exception);
}
var projectIntermediateState = await TryProjectNewState(current, addNewTransitionEvents, previousStates, executionContext, cancellationToken).ConfigureAwait(false);
if (!projectIntermediateState.Success)
{
_logger.CalculatingStateTransitionEventsFailedProjectingNewState(
_embeddingId,
current.Key,
current.Version,
addNewTransitionEvents.Exception);
return(projectIntermediateState.Exception);
}
previousStates.Add(projectIntermediateState.Result.State);
current = projectIntermediateState;
}
}
catch (Exception ex)
{
return(ex);
}
}
public static async Task <CommitAggregateEventsResponse> Commit(this IEventStore eventStore, UncommittedAggregateEvents events, Dolittle.Runtime.Execution.ExecutionContext executionContext)
{
var response = await eventStore.CommitAggregateEvents(events.ToCommitRequest(executionContext), CancellationToken.None);
return(response);
}
/// <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));
}
public static async Task <FetchForAggregateResponse> FetchForAggregate(this IEventStore eventStore, ArtifactId aggregateRootId, EventSourceId eventSourceId, Dolittle.Runtime.Execution.ExecutionContext executionContext)
{
var response = await eventStore.FetchAggregateEvents(new FetchForAggregateRequest
{
CallContext = new CallRequestContext
{
ExecutionContext = executionContext.ToProtobuf()
},
Aggregate = new Aggregate {
AggregateRootId = aggregateRootId.ToProtobuf(), EventSourceId = eventSourceId
}
}, CancellationToken.None);
return(response);
}
/// <inheritdoc/> public abstract Task <IFilterResult> Filter(CommittedEvent @event, PartitionId partitionId, EventProcessorId eventProcessorId, string failureReason, uint retryCount, ExecutionContext executionContext, CancellationToken cancellationToken);
/// <inheritdoc/>
public Task <Try <UncommittedAggregateEvents> > TryConverge(EmbeddingCurrentState current, ProjectionState desired, ExecutionContext executionContext, CancellationToken cancellationToken)
=> DoWork(
current,
newCurrent => _stateComparer.TryCheckEquality(newCurrent.State, desired),
(newCurrent, token) => _embedding.TryCompare(newCurrent, desired, executionContext, token),
executionContext,
cancellationToken);
