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