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>());