async Task <Partitioned.ScopedStreamProcessor> CreatePartitionedScopedStreamProcessor(
IStreamProcessorId streamProcessorId,
IEventProcessor eventProcessor,
ICanFetchEventsFromPartitionedStream eventsFromStreamsFetcher,
CancellationToken cancellationToken)
{
var tryGetStreamProcessorState = await _streamProcessorStates.TryGetFor(streamProcessorId, cancellationToken).ConfigureAwait(false);
if (!tryGetStreamProcessorState.Success)
{
tryGetStreamProcessorState = Partitioned.StreamProcessorState.New;
await _streamProcessorStates.Persist(streamProcessorId, tryGetStreamProcessorState.Result, cancellationToken).ConfigureAwait(false);
}
if (!tryGetStreamProcessorState.Result.Partitioned)
{
throw new ExpectedPartitionedStreamProcessorState(streamProcessorId);
}
return(new Partitioned.ScopedStreamProcessor(
_tenant,
streamProcessorId,
tryGetStreamProcessorState.Result as Partitioned.StreamProcessorState,
eventProcessor,
_streamProcessorStates,
eventsFromStreamsFetcher,
new Partitioned.FailingPartitions(_streamProcessorStates, eventProcessor, eventsFromStreamsFetcher, _eventsFetcherPolicy, _loggerManager.CreateLogger <Partitioned.FailingPartitions>()),
_eventsFetcherPolicy,
_loggerManager.CreateLogger <Partitioned.ScopedStreamProcessor>()));
}
public async Task <IActionResult> Get([FromQuery] PagingParameters pagingParameters)
{
using (var logger = _loggerManager.CreateLogger())
{
try
{
var courses = await _courseService.FindAll(pagingParameters);
logger.LogInformation("Course are retreived");
var metadata = new
{
courses.TotalCount,
courses.PageSize,
courses.CurrentPage,
courses.TotalPages,
courses.HasNext,
courses.HasPrevious
};
Response.Headers.Add("X-Pagination", JsonConvert.SerializeObject(metadata));
if (courses != null)
{
return(Ok(courses));
}
return(NoContent());
}
catch (Exception ex)
{
logger.LogError("Something happend while getting courses", ex);
return(StatusCode(500));
}
}
}
/// <inheritdoc/>
public override async Task Connect(
IAsyncStreamReader <FilterClientToRuntimeMessage> runtimeStream,
IServerStreamWriter <FilterRuntimeToClientMessage> clientStream,
ServerCallContext context)
{
_logger.Debug("Connecting Unpartitioned Filter");
using var cts = CancellationTokenSource.CreateLinkedTokenSource(_hostApplicationLifetime.ApplicationStopping, context.CancellationToken);
var cancellationToken = cts.Token;
var dispatcher = _reverseCallDispatchers.GetFor <FilterClientToRuntimeMessage, FilterRuntimeToClientMessage, FilterRegistrationRequest, FilterRegistrationResponse, FilterEventRequest, FilterResponse>(
runtimeStream,
clientStream,
context,
_ => _.RegistrationRequest,
(serverMessage, registrationResponse) => serverMessage.RegistrationResponse = registrationResponse,
(serverMessage, request) => serverMessage.FilterRequest = request,
_ => _.FilterResult,
_ => _.CallContext,
(request, context) => request.CallContext = context,
_ => _.CallContext,
(message, ping) => message.Ping = ping,
message => message.Pong);
if (await RejectIfNotReceivedArguments(dispatcher, cancellationToken).ConfigureAwait(false))
{
return;
}
var arguments = dispatcher.Arguments;
var executionContext = arguments.CallContext.ExecutionContext.ToExecutionContext();
_logger.Trace("Setting execution context{NewLine}{ExecutionContext}", System.Environment.NewLine, executionContext);
_executionContextManager.CurrentFor(arguments.CallContext.ExecutionContext);
var filterId = arguments.FilterId.To <StreamId>();
var scopeId = arguments.ScopeId.To <ScopeId>();
var sourceStreamId = StreamId.EventLog;
if (await RejectIfInvalidFilterId(dispatcher, filterId, cancellationToken).ConfigureAwait(false))
{
return;
}
var filterDefinition = new FilterDefinition(sourceStreamId, filterId, partitioned: false);
await RegisterFilter(
dispatcher,
scopeId,
filterDefinition,
() => new FilterProcessor(
scopeId,
filterDefinition,
dispatcher,
_getEventsToStreamsWriter(),
_loggerManager.CreateLogger <FilterProcessor>()),
cancellationToken).ConfigureAwait(false);
}
public async Task <IEnumerable <LineViewDto> > GetLines()
{
using (var logger = _loggerManager.CreateLogger())
{
var result = await _repository.GetAllAsync("Day");
var mappedLineDto = _mapper.Map <IEnumerable <LineViewDto> >(result.ToList());
logger.LogInformation($"The Lines are retrieved successfully.");
return(mappedLineDto);
}
}
public async Task <IEnumerable <UserViewModel> > GetUserViewModels()
{
using (var logger = _loggerManager.CreateLogger())
{
var users = await _repository.GetAllAsync("Role");
logger.LogInformation("Users are retreived successfully.");
var mappedUsers = _mapper.Map <IEnumerable <UserViewModel> >(users.ToList());
logger.LogInformation("Users are mapped successfully.");
return(mappedUsers);
}
}
public async Task AddAsync(T entity)
{
using (var logger = _loggerManager.CreateLogger())
{
entity.IsActive = true;
entity.CreationDate = DateTime.Now;
var mapped = _mapper.Map <B>(entity);
logger.LogInformation($"The {typeof(B)} mapped successfully.");
_repository.Add(mapped);
await _repository.SaveAsync();
}
}
public async Task <IActionResult> GetAll()
{
using (var logger = _loggerManager.CreateLogger())
{
var result = await _clientService.GetClients();
if (result.Any())
{
logger.LogInformation($"Retrieve [{result.ToList().Count}] of clients from database.");
return(Ok(result));
}
logger.LogInformation($"No clients retreived from database.");
return(NoContent());
}
}
/// <summary>
/// Initializes a new instance of the <see cref="Subscriptions"/> class.
/// </summary>
/// <param name="streamProcessorStates">The <see cref="IResilientStreamProcessorStateRepository" />.</param>
/// <param name="eventsFetcherPolicy">The <see cref="IAsyncPolicyFor{T}" /> <see cref="ICanFetchEventsFromStream" />.</param>
/// <param name="loggerManager">The <see cref="ILoggerManager" />.</param>
public Subscriptions(IResilientStreamProcessorStateRepository streamProcessorStates, IAsyncPolicyFor <ICanFetchEventsFromStream> eventsFetcherPolicy, ILoggerManager loggerManager)
{
_streamProcessorStates = streamProcessorStates;
_eventsFetcherPolicy = eventsFetcherPolicy;
_loggerManager = loggerManager;
_logger = loggerManager.CreateLogger <Subscriptions>();
}
/// <inheritdoc/>
public IReverseCallDispatcher <TClientMessage, TServerMessage, TConnectArguments, TConnectResponse, TRequest, TResponse> GetFor <TClientMessage, TServerMessage, TConnectArguments, TConnectResponse, TRequest, TResponse>(
IAsyncStreamReader <TClientMessage> clientStream,
IServerStreamWriter <TServerMessage> serverStream,
ServerCallContext context,
Func <TClientMessage, TConnectArguments> getConnectArguments,
Action <TServerMessage, TConnectResponse> setConnectResponse,
Action <TServerMessage, TRequest> setMessageRequest,
Func <TClientMessage, TResponse> getMessageResponse,
Func <TConnectArguments, ReverseCallArgumentsContext> getArgumentsContext,
Action <TRequest, ReverseCallRequestContext> setRequestContext,
Func <TResponse, ReverseCallResponseContext> getResponseContex,
Action <TServerMessage, Ping> setPing,
Func <TClientMessage, Pong> getPong)
where TClientMessage : IMessage, new()
where TServerMessage : IMessage, new()
where TConnectArguments : class
where TConnectResponse : class
where TRequest : class
where TResponse : class
=> new ReverseCallDispatcher <TClientMessage, TServerMessage, TConnectArguments, TConnectResponse, TRequest, TResponse>(
clientStream,
serverStream,
context,
getConnectArguments,
setConnectResponse,
setMessageRequest,
getMessageResponse,
getArgumentsContext,
setRequestContext,
getResponseContex,
setPing,
getPong,
_executionContextManager,
_loggerManager.CreateLogger <ReverseCallDispatcher <TClientMessage, TServerMessage, TConnectArguments, TConnectResponse, TRequest, TResponse> >());
/// <summary>
/// Initializes the stream processor.
/// </summary>
/// <returns>A <see cref="Task" />that represents the asynchronous operation.</returns>
public async Task Initialize()
{
_cancellationToken.ThrowIfCancellationRequested();
if (_initialized)
{
throw new StreamProcessorAlreadyInitialized(_identifier);
}
var tryGetStreamProcessorState = await _streamProcessorStates.TryGetFor(_identifier, _cancellationToken).ConfigureAwait(false);
if (!tryGetStreamProcessorState.Success)
{
tryGetStreamProcessorState = StreamProcessorState.New;
await _streamProcessorStates.Persist(_identifier, tryGetStreamProcessorState.Result, _cancellationToken).ConfigureAwait(false);
}
_streamProcessor = new ScopedStreamProcessor(
_identifier.ConsumerTenantId,
_identifier,
tryGetStreamProcessorState.Result as StreamProcessorState,
_eventProcessor,
_streamProcessorStates,
_eventsFetcher,
_eventsFetcherPolicy,
_loggerManager.CreateLogger <ScopedStreamProcessor>());
_initialized = true;
}
/// <summary>
/// Initializes a new instance of the <see cref="StreamProcessors"/> class.
/// </summary>
/// <param name="onAllTenants">The <see cref="IPerformActionOnAllTenants" />.</param>
/// <param name="getScopedStreamProcessorsCreator">The <see cref="FactoryFor{T}" /> <see cref="ICreateScopedStreamProcessors" />.</param>
/// <param name="executionContextManager">The <see cref="IExecutionContextManager" />.</param>
/// <param name="loggerManager">The <see cref="ILoggerManager" />.</param>
public StreamProcessors(
IPerformActionOnAllTenants onAllTenants,
FactoryFor <ICreateScopedStreamProcessors> getScopedStreamProcessorsCreator,
IExecutionContextManager executionContextManager,
ILoggerManager loggerManager)
{
_onAllTenants = onAllTenants;
_getScopedStreamProcessorsCreator = getScopedStreamProcessorsCreator;
_streamProcessors = new ConcurrentDictionary <StreamProcessorId, StreamProcessor>();
_executionContextManager = executionContextManager;
_loggerManager = loggerManager;
_logger = loggerManager.CreateLogger <StreamProcessors>();
}
/// <inheritdoc/>
public IEventProcessor GetFor <TEventType>(EventHandlerId id, ScopeId scope, bool partitioned, IEventHandler <TEventType> handler)
where TEventType : IEvent
=> new EventHandlerProcessor <TEventType>(
id,
scope,
partitioned,
handler,
_handlersClient,
_reverseCallClients,
_eventProcessingCompletion,
_artifactTypeMap,
_converter,
_loggerManager.CreateLogger <EventHandlerProcessor <TEventType> >());
public IEnumerable <WeatherForecast> Get()
{
using (var logger = _logger.CreateLogger())
{
logger.LogInformation("infoooo");
var rng = new Random();
return(Enumerable.Range(1, 5).Select(index => new WeatherForecast
{
Date = DateTime.Now.AddDays(index),
TemperatureC = rng.Next(-20, 55),
Summary = Summaries[rng.Next(Summaries.Length)]
})
.ToArray());
}
}
public async Task <bool> Create(DepartmentDto entity)
{
using (var logger = _loggerManager.CreateLogger())
{
var department = _mapper.Map <Department>(entity);
await _repository.Create(department);
var result = await _repository.SaveAsync();
logger.LogInformation($"Department {department.Code} is added.");
return(result);
}
}
public async Task <bool> Create(CourseDto entity)
{
using (var logger = _loggerManager.CreateLogger())
{
var course = _mapper.Map <Course>(entity);
await _repository.Create(course);
var result = await _repository.SaveAsync();
logger.LogInformation($"Course {course.Code} is added.");
return(result);
}
}
public async Task <bool> Create(StudentCourseDto entity)
{
using (var logger = _loggerManager.CreateLogger())
{
var studCrs = _mapper.Map <StudentCourse>(entity);
await _repository.Create(studCrs);
var result = await _repository.SaveAsync();
logger.LogInformation($"Degree {entity.Degree} of Student {studCrs.Id} is created.");
return(result);
}
}
/// <summary>
/// Initialize the entire DependencyInversion pipeline.
/// </summary>
/// <param name="assemblies"><see cref="IAssemblies"/> for the application.</param>
/// <param name="typeFinder"><see cref="ITypeFinder"/> for doing discovery.</param>
/// <param name="scheduler"><see cref="IScheduler"/> for scheduling work.</param>
/// <param name="fileSystem"><see cref="IFileSystem"/> to use.</param>
/// <param name="loggerManager"><see cref="ILoggerManager"/> for creating loggers.</param>
/// <param name="bindings">Additional bindings.</param>
/// <param name="bootContainer">A <see cref="BootContainer"/> used during booting.</param>
/// <returns>Configured <see cref="IContainer"/> and <see cref="IBindingCollection"/>.</returns>
public static BootResult Start(
IAssemblies assemblies,
ITypeFinder typeFinder,
IScheduler scheduler,
IFileSystem fileSystem,
ILoggerManager loggerManager,
IEnumerable <Binding> bindings = null,
BootContainer bootContainer = null)
{
var logger = loggerManager.CreateLogger(typeof(Boot));
logger.Trace("DependencyInversion start");
var initialBindings = GetBootBindings(assemblies, typeFinder, scheduler, fileSystem, loggerManager);
if (bootContainer == null)
{
bootContainer = new BootContainer(initialBindings, new NewBindingsNotificationHub());
}
_container = bootContainer;
var otherBindings = new List <Binding>();
if (bindings != null)
{
otherBindings.AddRange(bindings);
}
otherBindings.Add(Bind(typeof(IContainer), () => _container, false));
logger.Trace("Discover and Build bindings");
var bindingCollection = DiscoverAndBuildBuildBindings(
bootContainer,
typeFinder,
scheduler,
logger,
initialBindings,
otherBindings);
logger.Trace("Discover container");
_container = DiscoverAndConfigureContainer(bootContainer, assemblies, typeFinder, bindingCollection);
BootContainer.ContainerReady(_container);
logger.Trace("Return boot result");
return(new BootResult(_container, bindingCollection));
}
public async Task <IEnumerable <ClientViewDto> > GetClients()
{
using (var logger = _loggerManager.CreateLogger())
{
var clients = await _repository.GetAllAsync("Line");
logger.LogInformation("All clients are retrieved");
ClientViewDto[] clientViewDtos = new ClientViewDto[clients.Count()];
for (int i = 0; i < clients.Count(); i++)
{
ClientViewDto mappedLine = _mapper.Map <ClientViewDto>(clients.ElementAt(i));
mappedLine.Day = await _dayService.GetByIdAsync(clients.ElementAt(i).Line.DayId);
clientViewDtos[i] = mappedLine;
}
logger.LogInformation("All clients are mapped successfully");
return(clientViewDtos);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="EventHandlersService"/> class.
/// </summary>
/// <param name="hostApplicationLifetime">The <see cref="IHostApplicationLifetime" />.</param>
/// <param name="filterForAllTenants">The <see cref="IValidateFilterForAllTenants" />.</param>
/// <param name="streamProcessors">The <see cref="IStreamProcessors" />.</param>
/// <param name="getEventsToStreamsWriter">The <see cref="FactoryFor{T}" /> <see cref="IWriteEventsToStreams" />.</param>
/// <param name="streamDefinitions">The<see cref="IStreamDefinitions" />.</param>
/// <param name="reverseCallDispatchers">The <see cref="IReverseCallDispatchers"/> for working with reverse calls.</param>
/// <param name="executionContextManager">The <see cref="IExecutionContextManager" />.</param>
/// <param name="loggerManager">The <see cref="ILoggerManager"/>.</param>
public EventHandlersService(
IHostApplicationLifetime hostApplicationLifetime,
IValidateFilterForAllTenants filterForAllTenants,
IStreamProcessors streamProcessors,
FactoryFor <IWriteEventsToStreams> getEventsToStreamsWriter,
IStreamDefinitions streamDefinitions,
IReverseCallDispatchers reverseCallDispatchers,
IExecutionContextManager executionContextManager,
ILoggerManager loggerManager)
{
_filterForAllTenants = filterForAllTenants;
_streamProcessors = streamProcessors;
_getEventsToStreamsWriter = getEventsToStreamsWriter;
_streamDefinitions = streamDefinitions;
_reverseCallDispatchers = reverseCallDispatchers;
_executionContextManager = executionContextManager;
_loggerManager = loggerManager;
_logger = loggerManager.CreateLogger <EventHandlersService>();
_hostApplicationLifetime = hostApplicationLifetime;
}
/// <summary>
/// Initialize the entire DependencyInversion pipeline with a specified <see cref="Type"/> of container.
/// </summary>
/// <param name="assemblies"><see cref="IAssemblies"/> for the application.</param>
/// <param name="typeFinder"><see cref="ITypeFinder"/> for doing discovery.</param>
/// <param name="scheduler"><see cref="IScheduler"/> for scheduling work.</param>
/// <param name="fileSystem"><see cref="IFileSystem"/> to use.</param>
/// <param name="loggerManager"><see cref="ILoggerManager"/> for creating loggers.</param>
/// <param name="containerType"><see cref="Type"/>Container type.</param>
/// <param name="bindings">Additional bindings.</param>
/// <param name="bootContainer">A <see cref="BootContainer"/> used during booting.</param>
/// <returns>Configured <see cref="IContainer"/> and <see cref="IBindingCollection"/>.</returns>
public static IBindingCollection Start(
IAssemblies assemblies,
ITypeFinder typeFinder,
IScheduler scheduler,
IFileSystem fileSystem,
ILoggerManager loggerManager,
Type containerType,
IEnumerable <Binding> bindings = null,
BootContainer bootContainer = null)
{
var logger = loggerManager.CreateLogger(typeof(Boot));
logger.Trace("DependencyInversion start");
var initialBindings = GetBootBindings(assemblies, typeFinder, scheduler, fileSystem, loggerManager);
if (bootContainer == null)
{
bootContainer = new BootContainer(initialBindings, new NewBindingsNotificationHub());
}
_container = bootContainer;
var otherBindings = new List <Binding>();
if (bindings != null)
{
otherBindings.AddRange(bindings);
}
otherBindings.Add(Bind(typeof(IContainer), containerType, true));
logger.Trace("Discover and Build bindings");
return(DiscoverAndBuildBuildBindings(
bootContainer,
typeFinder,
scheduler,
logger,
initialBindings,
otherBindings));
}
/// <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);
}
/// <summary>
/// Initializes a new instance of the <see cref="Subscription"/> class.
/// </summary>
/// <param name="consentId">The <see cref="ConsentId" />.</param>
/// <param name="subscriptionId">The <see cref="StreamProcessorId" />.</param>
/// <param name="eventProcessor">The <see cref="IEventProcessor" />.</param>
/// <param name="eventsFetcher">The <see cref="EventsFromEventHorizonFetcher" />.</param>
/// <param name="streamProcessorStates">The <see cref="IResilientStreamProcessorStateRepository" />.</param>
/// <param name="unregister">An <see cref="Action" /> that unregisters the <see cref="ScopedStreamProcessor" />.</param>
/// <param name="eventsFetcherPolicy">The <see cref="IAsyncPolicyFor{T}" /> <see cref="ICanFetchEventsFromStream" />.</param>
/// <param name="loggerManager">The <see cref="ILoggerManager" />.</param>
/// <param name="cancellationToken">The <see cref="CancellationToken" />.</param>
public Subscription(
ConsentId consentId,
SubscriptionId subscriptionId,
EventProcessor eventProcessor,
EventsFromEventHorizonFetcher eventsFetcher,
IResilientStreamProcessorStateRepository streamProcessorStates,
Action unregister,
IAsyncPolicyFor <ICanFetchEventsFromStream> eventsFetcherPolicy,
ILoggerManager loggerManager,
CancellationToken cancellationToken)
{
_identifier = subscriptionId;
_eventProcessor = eventProcessor;
_unregister = unregister;
_streamProcessorStates = streamProcessorStates;
_eventsFetcher = eventsFetcher;
_eventsFetcherPolicy = eventsFetcherPolicy;
_loggerManager = loggerManager;
_logger = loggerManager.CreateLogger <StreamProcessor>();
_cancellationToken = cancellationToken;
_unregisterTokenRegistration = _cancellationToken.Register(_unregister);
ConsentId = consentId;
}
/// <inheritdoc/>
public override async Task Connect(
IAsyncStreamReader <EventHandlerClientToRuntimeMessage> runtimeStream,
IServerStreamWriter <EventHandlerRuntimeToClientMessage> clientStream,
ServerCallContext context)
{
_logger.Debug("Connecting Event Handler");
using var cts = CancellationTokenSource.CreateLinkedTokenSource(_hostApplicationLifetime.ApplicationStopping, context.CancellationToken);
var cancellationToken = cts.Token;
var dispatcher = _reverseCallDispatchers.GetFor <EventHandlerClientToRuntimeMessage, EventHandlerRuntimeToClientMessage, EventHandlerRegistrationRequest, EventHandlerRegistrationResponse, HandleEventRequest, EventHandlerResponse>(
runtimeStream,
clientStream,
context,
_ => _.RegistrationRequest,
(serverMessage, registrationResponse) => serverMessage.RegistrationResponse = registrationResponse,
(serverMessage, request) => serverMessage.HandleRequest = request,
_ => _.HandleResult,
_ => _.CallContext,
(request, context) => request.CallContext = context,
_ => _.CallContext,
(message, ping) => message.Ping = ping,
message => message.Pong);
_logger.Trace("Waiting for connection arguments...");
if (!await dispatcher.ReceiveArguments(cancellationToken).ConfigureAwait(false))
{
const string message = "Event Handlers connection arguments were not received";
_logger.Warning(message);
var failure = new Failure(EventHandlersFailures.NoEventHandlerRegistrationReceived, message);
await WriteFailedRegistrationResponse(dispatcher, failure, cancellationToken).ConfigureAwait(false);
return;
}
_logger.Trace("Received connection arguments");
var arguments = dispatcher.Arguments;
var executionContext = arguments.CallContext.ExecutionContext.ToExecutionContext();
_logger.Trace("Setting execution context{NewLine}{ExecutionContext}", System.Environment.NewLine, executionContext);
_executionContextManager.CurrentFor(executionContext);
var sourceStream = StreamId.EventLog;
_logger.Trace("Received Source Stream '{SourceStream}'", sourceStream);
var eventHandlerId = arguments.EventHandlerId.To <EventProcessorId>();
_logger.Trace("Received Event Handler '{EventHandler}'", eventHandlerId);
StreamId targetStream = eventHandlerId.Value;
var scopeId = arguments.ScopeId.To <ScopeId>();
_logger.Trace("Received Scope '{Scope}'", scopeId);
var types = arguments.Types_.Select(_ => _.Id.To <ArtifactId>());
_logger.Trace("Received Types: [{Types}]'", string.Join(", ", types.Select(_ => $"'{_}'")));
var partitioned = arguments.Partitioned;
_logger.Trace("Event Handler '{EventHandler}' {PartitionedString}", eventHandlerId, partitioned ? "is partitioned" : "is not partitioned");
if (targetStream.IsNonWriteable)
{
_logger.Warning("Cannot register Event Handler '{EventHandler}' because it is an invalid Stream Id", eventHandlerId);
var failure = new Failure(
EventHandlersFailures.CannotRegisterEventHandlerOnNonWriteableStream,
$"Cannot register Event Handler: '{eventHandlerId}' because it is an invalid Stream Id");
await WriteFailedRegistrationResponse(dispatcher, failure, cancellationToken).ConfigureAwait(false);
return;
}
_logger.Debug("Connecting Event Handler '{EventHandlerId}'", eventHandlerId);
var filterDefinition = new TypeFilterWithEventSourcePartitionDefinition(sourceStream, targetStream, types, partitioned);
var filteredStreamDefinition = new StreamDefinition(filterDefinition);
Func <IFilterProcessor <TypeFilterWithEventSourcePartitionDefinition> > getFilterProcessor = () => new TypeFilterWithEventSourcePartition(
scopeId,
filterDefinition,
_getEventsToStreamsWriter(),
_loggerManager.CreateLogger <TypeFilterWithEventSourcePartition>());
var tryRegisterFilterStreamProcessor = TryRegisterFilterStreamProcessor <TypeFilterWithEventSourcePartitionDefinition>(
scopeId,
eventHandlerId,
getFilterProcessor,
cancellationToken);
if (!tryRegisterFilterStreamProcessor.Success)
{
if (tryRegisterFilterStreamProcessor.HasException)
{
var exception = tryRegisterFilterStreamProcessor.Exception;
_logger.Warning(exception, "An error occurred while registering Event Handler '{EventHandlerId}'", eventHandlerId);
ExceptionDispatchInfo.Capture(exception).Throw();
}
else
{
_logger.Debug("Failed to register Event Handler '{EventHandlerId}'. Filter already registered", eventHandlerId);
var failure = new Failure(
FiltersFailures.FailedToRegisterFilter,
$"Failed to register Event Handler: {eventHandlerId}. Filter already registered.");
await WriteFailedRegistrationResponse(dispatcher, failure, cancellationToken).ConfigureAwait(false);
return;
}
}
using var filterStreamProcessor = tryRegisterFilterStreamProcessor.Result;
var tryRegisterEventProcessorStreamProcessor = TryRegisterEventProcessorStreamProcessor(
scopeId,
eventHandlerId,
filteredStreamDefinition,
() => new EventProcessor(
scopeId,
eventHandlerId,
dispatcher,
_loggerManager.CreateLogger <EventProcessor>()),
cancellationToken);
if (!tryRegisterEventProcessorStreamProcessor.Success)
{
if (tryRegisterEventProcessorStreamProcessor.HasException)
{
var exception = tryRegisterEventProcessorStreamProcessor.Exception;
_logger.Warning(exception, "An error occurred while registering Event Handler' {EventHandlerId}", eventHandlerId);
ExceptionDispatchInfo.Capture(exception).Throw();
}
else
{
_logger.Warning("Failed to register Event Handler: {eventHandlerId}. Event Processor already registered on Source Stream '{SourceStreamId}'", eventHandlerId, eventHandlerId);
var failure = new Failure(
FiltersFailures.FailedToRegisterFilter,
$"Failed to register Event Handler: {eventHandlerId}. Event Processor already registered on Source Stream: '{eventHandlerId}'");
await WriteFailedRegistrationResponse(dispatcher, failure, cancellationToken).ConfigureAwait(false);
return;
}
}
using var eventProcessorStreamProcessor = tryRegisterEventProcessorStreamProcessor.Result;
var tryStartEventHandler = await TryStartEventHandler(
dispatcher,
filterStreamProcessor,
eventProcessorStreamProcessor,
scopeId,
filterDefinition,
getFilterProcessor,
cancellationToken).ConfigureAwait(false);
if (!tryStartEventHandler.Success)
{
cts.Cancel();
if (tryStartEventHandler.HasException)
{
var exception = tryStartEventHandler.Exception;
_logger.Debug(exception, "An error occurred while starting Event Handler '{EventHandlerId}' in Scope {ScopeId}", eventHandlerId, scopeId);
ExceptionDispatchInfo.Capture(exception).Throw();
}
else
{
_logger.Warning("Could not start Event Handler '{EventHandlerId}' in Scope: {ScopeId}", eventHandlerId, scopeId);
return;
}
}
var tasks = tryStartEventHandler.Result;
try
{
await Task.WhenAny(tasks).ConfigureAwait(false);
if (TryGetException(tasks, out var ex))
{
_logger.Warning(ex, "An error occurred while running Event Handler '{EventHandlerId}' in Scope: '{ScopeId}'", eventHandlerId, scopeId);
ExceptionDispatchInfo.Capture(ex).Throw();
}
}
finally
{
cts.Cancel();
await Task.WhenAll(tasks).ConfigureAwait(false);
_logger.Debug("Event Handler: '{EventHandler}' in Scope: '{ScopeId}' disconnected", eventHandlerId, scopeId);
}
}
/// <summary> /// Creates an <see cref="EventFilterProcessor"/> for registering and invoking an instance of <see cref="ICanFilterEvents"/>. /// </summary> /// <param name="id">The unique <see cref="FilterId"/> for the event filter.</param> /// <param name="scope">The <see cref="ScopeId"/> of the scope in the Event Store where the filter will run.</param> /// <param name="filter">The <see cref="ICanFilterEvents"/> to use for filtering the events.</param> /// <returns>An <see cref="EventFilterProcessor"/> for registering and invoking an instance of <see cref="ICanFilterEvents"/>.</returns> public EventFilterProcessor GetFor(FilterId id, ScopeId scope, ICanFilterEvents filter) => new EventFilterProcessor(id, scope, _client, _reverseCallClients, filter, _converter, _loggerManager.CreateLogger <EventFilterProcessor>());
