public IndexModel(IDataService DataService, IFilterProcessor filterProcessor)
{
SuperHeroList = new List <SuperHero>();
_dataService = DataService;
_filterProcessor = filterProcessor;
}
protected static FilterResult TestProcessorResults(string line, IFilterProcessor processor)
{
var resultToTest = new FilterResult
{
IsMatch = true,
Result = line
};
return(processor.Next(resultToTest));
}
/// <inheritdoc/>
public async Task <FilterValidationResult> Validate <TDefinition>(IFilterProcessor <TDefinition> filter, CancellationToken cancellationToken)
where TDefinition : IFilterDefinition
{
var tryGetProcessorState = await _streamProcessorStates
.TryGetFor(new StreamProcessorId(filter.Scope, filter.Definition.TargetStream.Value, filter.Definition.SourceStream), cancellationToken)
.ConfigureAwait(false);
if (!StreamProcessorHasProcessedEvents(tryGetProcessorState, out var validationResult, out var lastUnprocessedEvent))
{
return(validationResult);
}
_logger.TryGetFilterDefinition(filter.Identifier, _tenant);
var tryGetFilterDefinition = await _filterDefinitions.TryGetFromStream(filter.Scope, filter.Definition.TargetStream, cancellationToken).ConfigureAwait(false);
if (!FilterDefinitionHasBeenPersisted(tryGetFilterDefinition, out var persistedDefinition, out validationResult))
{
_logger.NoPersistedFilterDefinition(filter.Identifier, _tenant);
return(validationResult);
}
var definitionResult = _definitionComparer.DefinitionsAreEqual(persistedDefinition, filter.Definition);
if (!definitionResult.Success)
{
return(definitionResult);
}
if (FilterDefinitionTypeHasChanged(persistedDefinition, filter.Definition))
{
return(FilterValidationResult.Failed("Filter definition type has changed"));
}
_logger.FindingFilterValidator(filter.Identifier);
if (!TryGetValidatorFor <TDefinition>(out var validator))
{
return(FilterValidationResult.Failed($"No available filter validator for type {filter.Definition.GetType()}"));
}
_logger.ValidatingFilter(filter.Identifier);
return(await validator.Validate((TDefinition)persistedDefinition, filter, lastUnprocessedEvent, cancellationToken).ConfigureAwait(false));
}
/// <inheritdoc/> public Task <FilterValidationResult> Validate(IFilterDefinition persistedDefinition, IFilterProcessor <PublicFilterDefinition> filter, CancellationToken cancellationToken) => _byComparingStreams.Validate(persistedDefinition, filter, cancellationToken);
/// <inheritdoc/>
public Task <FilterValidationResult> Validate <TDefinition>(IFilterDefinition persistedDefinition, IFilterProcessor <TDefinition> filter, CancellationToken cancellationToken)
where TDefinition : IFilterDefinition
{
_logger.Trace("Finding validator for filter '{TargetStream}'", filter.Definition.TargetStream);
if (TryGetValidatorFor <TDefinition>(out var validator))
{
_logger.Trace("Validating filter '{TargetStream}'", filter.Definition.TargetStream);
return(validator.Validate(persistedDefinition, filter, cancellationToken));
}
return(Task.FromResult(new FilterValidationResult()));
}
async Task <FilterValidationResult> PerformValidation(IFilterProcessor <IFilterDefinition> filter, StreamPosition lastUnprocessedEvent, CancellationToken cancellationToken)
{
try
{
var streamDefinition = new StreamDefinition(filter.Definition);
var oldStreamEventsFetcher = await _eventFetchers.GetRangeFetcherFor(
filter.Scope,
streamDefinition,
cancellationToken).ConfigureAwait(false);
var eventLogFetcher = await _eventFetchers.GetRangeFetcherFor(
filter.Scope,
new EventLogStreamDefinition(),
cancellationToken).ConfigureAwait(false);
var oldStream = oldStreamEventsFetcher.FetchRange(
new StreamPositionRange(StreamPosition.Start, ulong.MaxValue),
cancellationToken);
var eventLogStream = eventLogFetcher.FetchRange(new StreamPositionRange(StreamPosition.Start, lastUnprocessedEvent), cancellationToken);
await using var oldStreamEnumerator = oldStream.GetAsyncEnumerator(cancellationToken);
var newStreamPosition = 0;
await foreach (var eventFromEventLog in eventLogStream.WithCancellation(cancellationToken))
{
var filteringResult = await filter.Filter(eventFromEventLog.Event, PartitionId.None, filter.Identifier, eventFromEventLog.Event.ExecutionContext, cancellationToken).ConfigureAwait(false);
if (filteringResult is FailedFiltering failedResult)
{
return(FilterValidationResult.Failed(failedResult.FailureReason));
}
if (!filteringResult.IsIncluded)
{
continue;
}
if (!await oldStreamEnumerator.MoveNextAsync())
{
return(FilterValidationResult.Failed("The number of events included in the new stream generated from the filter does not match the old stream."));
}
var oldStreamEvent = oldStreamEnumerator.Current;
var filteredEvent = new StreamEvent(
eventFromEventLog.Event,
new StreamPosition((ulong)newStreamPosition++),
filter.Definition.TargetStream,
filteringResult.Partition,
streamDefinition.Partitioned);
if (EventsAreNotEqual(filter.Definition, filteredEvent, oldStreamEvent, out var failedValidation))
{
return(failedValidation);
}
}
if (await oldStreamEnumerator.MoveNextAsync())
{
return(FilterValidationResult.Failed($"The number of events included in the new stream generated from the filter does not match the old stream."));
}
return(FilterValidationResult.Succeeded());
}
catch (Exception exception)
{
return(FilterValidationResult.Failed(exception.Message));
}
}
/// <inheritdoc /> public Task <FilterValidationResult> Validate(PublicFilterDefinition persistedDefinition, IFilterProcessor <PublicFilterDefinition> filter, StreamPosition lastUnprocessedEvent, CancellationToken cancellationToken) => PerformValidation(filter, lastUnprocessedEvent, cancellationToken);
/// <inheritdoc/> public Task <FilterValidationResult> Validate(IFilterDefinition persistedDefinition, IFilterProcessor <TypeFilterWithEventSourcePartitionDefinition> filter, CancellationToken cancellationToken) => _byComparingStreams.Validate(persistedDefinition, filter, cancellationToken);
/// <inheritdoc/>
public async Task <FilterValidationResult> Validate(TypeFilterWithEventSourcePartitionDefinition persistedDefinition, IFilterProcessor <TypeFilterWithEventSourcePartitionDefinition> filter, StreamPosition lastUnprocessedEvent, CancellationToken cancellationToken)
{
try
{
var changedEventTypes = GetChangedEventTypes(persistedDefinition, filter.Definition);
if (EventTypesHaveNotChanged(changedEventTypes))
{
return(FilterValidationResult.Succeeded());
}
var streamTypesFetcher = await _eventFetchers.GetTypeFetcherFor(
filter.Scope,
new EventLogStreamDefinition(),
cancellationToken).ConfigureAwait(false);
var typesInSourceStream = await streamTypesFetcher.FetchInRange(
new StreamPositionRange(StreamPosition.Start, lastUnprocessedEvent),
cancellationToken).ConfigureAwait(false);
return(SourceStreamContainsChangedEventTypes(typesInSourceStream, changedEventTypes)
? FilterValidationResult.Failed("The new filter definition has added or removed event types that have already been filtered")
: FilterValidationResult.Succeeded());
}
catch (Exception exception)
{
return(FilterValidationResult.Failed(exception.Message));
}
}
