public async Task Given_ConfiguredRequest_When_Process_Then_HandlersCalledAfterPredicate() { var context = new DefaultHttpContext(); A.CallTo(() => _predicate.Invoke(A <IWebRequestEvent> ._)).Returns(true); await _sut.ProcessAsync(context); A.CallTo(() => _eventHandlerFactory.Create(A <IEnumerable <IEventHandlerSpecification <IWebRequest> > > .That.Contains(_handlerSpec))).MustHaveHappened(); A.CallTo(() => _predicate.Invoke(A <IWebRequestEvent> ._)).MustHaveHappened().Then( A.CallTo(() => _responseFactory.Invoke(A <IWebResponse> ._)).MustHaveHappened()); A.CallTo(() => _predicate.Invoke(A <IWebRequestEvent> ._)).MustHaveHappened().Then( A.CallTo(() => _eventHandler.ExecuteHandlersAsync(A <IWebRequest> ._, A <CancellationToken> ._)).MustHaveHappened()); }
public async Task Given_WebRequestSpec_When_Build_Then_ConfigBuilt() { var predicate = A.Dummy <Func <IWebRequestEvent, bool> >(); var predicateSpec = A.Fake <IWebRequestPredicateSpecification>(); A.CallTo(() => predicateSpec.Build()).Returns(predicate); var responseFactory = A.Dummy <Func <IWebResponse, Task> >(); var responseSpec = A.Fake <IWebRequestResponseSpecification>(); A.CallTo(() => responseSpec.BuildFactory()).Returns(responseFactory); var handlerSpec = A.Fake <IEventHandlerSpecification <IWebRequest> >(); _sut.AddPredicateSpecification(predicateSpec); _sut.SetResponseSpecification(responseSpec); _sut.AddHandlerSpecification(handlerSpec); var config = _sut.Build(); var request = A.Dummy <IWebRequestEvent>(); var response = A.Dummy <IWebResponse>(); config.Matches(request); await config.WriteResponse(response); A.CallTo(() => predicate.Invoke(A <IWebRequestEvent> ._)).MustHaveHappened(); A.CallTo(() => responseFactory.Invoke(A <IWebResponse> ._)).MustHaveHappened(); A.CallTo(() => _eventHandlerFactory.Create(A <IEnumerable <IEventHandlerSpecification <IWebRequest> > > ._)).MustHaveHappened(); Assert.That(config, Is.Not.Null); }
public void IterationSetup() { var tcs = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); var numEventsProcessed = 0; _dispatcher = new Mock <ReverseCallDispatcher>(); _dispatcher .Setup(_ => _.Reject(It.IsAny <EventHandlerRegistrationResponse>(), It.IsAny <CancellationToken>())) .Returns(Task.CompletedTask); _dispatcher .Setup(_ => _.Accept(It.IsAny <EventHandlerRegistrationResponse>(), It.IsAny <CancellationToken>())) .Returns(tcs.Task); _dispatcher .Setup(_ => _.Call(It.IsAny <HandleEventRequest>(), It.IsAny <Dolittle.Runtime.Execution.ExecutionContext>(), It.IsAny <CancellationToken>())) .Returns <HandleEventRequest, Dolittle.Runtime.Execution.ExecutionContext, CancellationToken>((request, _, __) => { Interlocked.Add(ref numEventsProcessed, 1); var response = new EventHandlerResponse(); if (numEventsProcessed == NumberEventsToProcess) { tcs.SetResult(); } return(Task.FromResult(response)); }); var eventHandlers = new List <IEventHandler>(); eventHandlers.AddRange(Enumerable.Range(0, EventHandlers).Select(_ => _eventHandlerFactory.Create( new EventHandlerRegistrationArguments(Runtime.CreateExecutionContextFor("d9fd643f-ce74-4ae5-b706-b76859fd8827"), Guid.NewGuid(), _eventTypes, Partitioned, ScopeId.Default), _dispatcher.Object, CancellationToken.None))); _eventHandlersToRun = eventHandlers; }
public async Task SetupAsync() { _eventHandler = A.Fake <IEventHandler <IWebRequest> >(); _eventHandlerFactory = A.Fake <IEventHandlerFactory>(); A.CallTo(() => _eventHandlerFactory.Create(A <IEnumerable <IEventHandlerSpecification <IWebRequest> > > ._)).Returns(_eventHandler); _predicate = A.Fake <Func <IWebRequestEvent, bool> >(); var predicateSpec = A.Fake <IWebRequestPredicateSpecification>(); A.CallTo(() => predicateSpec.Build()).Returns(_predicate); _responseFactory = A.Fake <Func <IWebResponse, Task> >(); var responseSpec = A.Fake <IWebRequestResponseSpecification>(); A.CallTo(() => responseSpec.BuildFactory()).Returns(_responseFactory); _handler = A.Dummy <Func <IEventContext <IWebRequest>, CancellationToken, Task> >(); _handlerSpec = A.Fake <IEventHandlerSpecification <IWebRequest> >(); A.CallTo(() => _handlerSpec.Build()).Returns(_handler); _sut = new WebComponent(); var configSpec = _sut.CreateConfigurationSpecification <WebComponentSpecification>(_eventHandlerFactory); configSpec.OnRequest(r => { r.AddPredicateSpecification(predicateSpec); r.SetResponseSpecification(responseSpec); r.AddHandlerSpecification(_handlerSpec); }); await configSpec.ApplyAsync(); }
/// <inheritdoc/> public override async Task Connect( IAsyncStreamReader <EventHandlerClientToRuntimeMessage> runtimeStream, IServerStreamWriter <EventHandlerRuntimeToClientMessage> clientStream, ServerCallContext context) { _logger.ConnectingEventHandler(); using var cts = CancellationTokenSource.CreateLinkedTokenSource(_hostApplicationLifetime.ApplicationStopping, context.CancellationToken); try { var connectResult = await _reverseCallServices.Connect(runtimeStream, clientStream, context, _eventHandlersProtocol, cts.Token).ConfigureAwait(false); if (!connectResult.Success) { return; } using var dispatcher = connectResult.Result.dispatcher; var arguments = connectResult.Result.arguments; using var eventHandler = _configuration.Value.Fast ? _eventHandlerFactory.CreateFast(arguments, _configuration.Value.ImplicitFilter, dispatcher, context.CancellationToken) : _eventHandlerFactory.Create(arguments, dispatcher, context.CancellationToken); await _eventHandlers.RegisterAndStart( eventHandler, (failure, cancellation) => dispatcher.Reject(new EventHandlerRegistrationResponse { Failure = failure.ToProtobuf() }, cancellation), cts.Token).ConfigureAwait(false); } finally { cts.Cancel(); } }
public async Task PublishAsync <TArgs>(TArgs args) { var handlers = _eventHandlerFactory.Create <TArgs>(); foreach (var handler in handlers) { await handler.HandleAsync(args).ConfigureAwait(false); } }
public void Register <T>(IEventHandlerFactory <T> handlerFactory) where T : class, IEvent { _ensureKey <T>(); var t = typeof(T); _handlers[t].Add(async e => { var handler = handlerFactory.Create(); await handler.HandleAsync((T)e); }); }
public IObserver Create(IConsumer consumer) { var handler = _eventHandlerFactory.Create(_configuration.HandlerConfig); if (_configuration.BatchProcessingRequired) { return(new BatchEventObserver( _configuration.BatchConfiguration, handler, consumer, _configuration.SkipUnknownEvents)); } return(new EventObserver(handler, consumer, _configuration.SkipUnknownEvents)); }
public AggregateSubscriberConfigurationBuilder SubscribeTo <TEvent>() where TEvent : IEvent { if (!_projectionGatewayConfigurationBuilder.Subscriptions.ContainsKey(_aggregateRoot) || !_projectionGatewayConfigurationBuilder.Subscriptions[_aggregateRoot].Any(x => x.EventType == typeof(TEvent))) { Action <object> eventHandler = @event => { var handlers = _eventHandlerFactory.Create <TEvent>(); foreach (var domainEventHandler in handlers) { domainEventHandler.Handle((TEvent)@event); } }; _projectionGatewayConfigurationBuilder.Subscriptions.Add(_aggregateRoot, new Subscription(typeof(TEvent), eventHandler)); } return(this); }
private void HandleEvent <TEvent>(IEvent evt) where TEvent : IEvent { var types = _eventRegister.FindHandlerType <TEvent>(); //去除并行线程,使用并行线程在task使用量大的情况下会出现死锁 foreach (var a in types) { try { _logger.LogDebug($"执行事件业务[{evt.GetType().Name} - {evt.Id}] - {a.Name}"); _eventHandlerFactory.Create <TEvent>(a).Handle((TEvent)evt); } catch (Exception ex) { _logger.LogError(ex, $"执行事件类型[{a.FullName}]异常,事件id:{evt.Id}"); } } }
/// <summary> /// <para> /// <paramref name="subscriber" /> subscribes to <see cref="ISubscriber{T}" /> that it implemented. /// For example, if it implemented <see cref="ISubscriber{T}" /> of <see cref="string" />. /// It will receives any published messages that is <see cref="string" /> or its subclass. /// </para> /// <para> /// If <paramref name="subscriber" /> does not implement <see cref="ISubscriber{T}" /> or /// it has already subscribe will be ignored. /// </para> /// </summary> /// <param name="subscriber">Object that implements <see cref="ISubscriber{T}" />.</param> /// <exception cref="ArgumentNullException"><paramref name="subscriber" />is null.</exception> public void Subscribe(ISubscriber subscriber) { if (subscriber == null) { throw new ArgumentNullException("subscriber"); } lock (_eventHandlers) { // Does not allow double subscribe if (_eventHandlers.Any(h => h.Matches(subscriber))) { return; } var handler = _handlerFactory.Create(subscriber); // Registers if there is atleast one type if (handler.Types.Any()) { _eventHandlers.Add(handler); } } }
public IDisposable Subscribe <TEvent>() where TEvent : IEvent { var externalEventType = _antiCorruption.GetMappedEventType(typeof(TEvent)); var subscription = _bus.SubscribeAsync( typeof(E <>).MakeGenericType(externalEventType), Assembly.GetEntryAssembly().GetName().Name, externalEvent => Task.Factory.StartNew(() => { var eventEnvelope = (E)externalEvent; var mappedInternalEvent = _antiCorruption.MapExternalEvent <TEvent>(eventEnvelope.Body); var @event = new Envelope <TEvent>(eventEnvelope.MessageId, mappedInternalEvent, eventEnvelope.IsRedelivered); //TODO: Мб избавиться от Generic E<T>? var eventHandlers = _eventHandlerFactory.Create <Envelope <TEvent> >(); foreach (var domainEventHandler in eventHandlers) { domainEventHandler.Handle(@event); } })); return(subscription); }
public void Handle <TEvent>(TEvent @event) where TEvent : IEvent { var handler = _factory.Create <TEvent>(); handler.Handle(@event); }
protected IEventHandler <TEventData> CreateHandler() { return(_eventHandlerFactory.Create(_handlerSpecifications)); }