private async Task PublishInternalAsync(PipelineEvent pipelineEvent, IEnumerable <Subscription> subscriptions)
{
_logger.PublishingEvent(pipelineEvent);
var eventsSubscriptions = _subscriptionsMatchingService
.GetMatchingSubscriptionsForEvent(subscriptions, pipelineEvent.Event);
var exceptions = new List <Exception>();
foreach (var eventsSubscription in eventsSubscriptions)
{
var exception = await eventsSubscription.PublishEventAsync(pipelineEvent).ConfigureAwait(false);
if (exception != null)
{
exceptions.Add(exception);
_logger.EventHandlerThrew(exception);
}
}
if (exceptions.Any())
{
throw new SubscriptionPublishAggregateException(exceptions);
}
}
public void SetUp()
{
_eventsQueue = new EventsQueue(_eventsQueueName);
var pipelineEvent = new PipelineEvent(new object());
_queuedPipelineEvent = new QueuedPipelineEvent(() => Task.CompletedTask);
}
public bool IsSatisfiedBy(PipelineEvent pipelineEvent)
{
Guard.AgainstNull(pipelineEvent, "pipelineEvent");
return(_assessors.All(assessor => assessor.Invoke(pipelineEvent))
&&
_specifications.All(specification => specification.IsSatisfiedBy(pipelineEvent)));
}
public DeserializationExceptionEventArgs(PipelineEvent pipelineEvent, IQueue workQueue, IQueue errorQueue,
Exception exception)
: base(pipelineEvent)
{
WorkQueue = workQueue;
ErrorQueue = errorQueue;
Exception = exception;
}
public void PublishEventAsync_WithEventTypeMismatch_ShouldThrow()
{
var pipelineEvent = new PipelineEvent(123);
Assert.That(async() =>
{
await _subscription.PublishEventAsync(pipelineEvent);
}, Throws.TypeOf <EventTypeMismatchException>());
}
public void SetUp()
{
_originalEvent = new TestEvent
{
Property1 = 20
};
_pipelineEvent = new PipelineEvent(_originalEvent);
_jsonEventsSerializationService = new JsonEventsSerializationService();
}
public void SetUp()
{
_pipelineEvent = new PipelineEvent(new TestEvent());
_subscription = new Subscription(typeof(TestEvent), new Action <object>(HandlerAction));
_asyncSubscription = new Subscription(typeof(TestEvent), new Func <object, Task>(HandlerActionAsync));
_isThrowingEnabled = false;
_handlerActionEvent = null;
}
public HandlerExceptionEventArgs(PipelineEvent pipelineEvent,
TransportMessage transportMessage, object message, IQueue workQueue,
IQueue errorQueue, Exception exception)
: base(pipelineEvent)
{
TransportMessage = transportMessage;
Message = message;
WorkQueue = workQueue;
ErrorQueue = errorQueue;
Exception = exception;
}
public Task PublishEventToScopedSubscriptionsAsync(PipelineEvent pipelineEvent, IEventsScope eventsScope)
{
if (eventsScope == null)
{
throw new ArgumentNullException(nameof(eventsScope));
}
var subscriptions = eventsScope.GetSubscriptionsFeature().GetSubscriptions(_scopedSubscriptionsService);
return(PublishInternalAsync(pipelineEvent, subscriptions));
}
private void DisposeDatabaseContext(PipelineEvent pipelineEvent)
{
if (_projectionConfiguration.IsSharedConnection)
{
pipelineEvent.Pipeline.State.Get <IDatabaseContext>().AttemptDispose();
}
else
{
pipelineEvent.Pipeline.State.Get <IDatabaseContext>("EventProjectionDatabaseContext").AttemptDispose();
pipelineEvent.Pipeline.State.Get <IDatabaseContext>("EventStoreDatabaseContext").AttemptDispose();
}
}
public async Task SendAsync(PipelineEvent pipelineEvent)
{
var serializedEvent = _eventsSerializationService.SerializeEvent(pipelineEvent);
var message = new Message(serializedEvent)
{
MessageId = Guid.NewGuid().ToString()
};
await _topicClient.SendAsync(message).ConfigureAwait(false);
_logger.MessageSent(message.MessageId);
}
public MessageHandlerInvokeResult Invoke(PipelineEvent pipelineEvent)
{
var messageType = pipelineEvent.Pipeline.State.GetTransportMessage().MessageType;
if (!_invokeCounts.ContainsKey(messageType))
{
_invokeCounts.Add(messageType,0);
}
_invokeCounts[messageType] = _invokeCounts[messageType] + 1;
return MessageHandlerInvokeResult.InvokedHandler(this);
}
private static Task InvokeEventHandlerAsync(PipelineEvent pipelineEvent, Delegate eventHandler)
{
var isAsync = eventHandler.Method.ReturnType == typeof(Task);
if (isAsync)
{
return((Task)eventHandler.DynamicInvoke(pipelineEvent.Event));
}
eventHandler.DynamicInvoke(pipelineEvent.Event);
return(Task.CompletedTask);
}
public Task InvokeAsync(
ProjectionPipelineModuleConfig config,
PipelineContext pipelineContext,
NextModuleDelegate invokeNextModule
)
{
var projectedEvent = config.EventProjection.Convert(pipelineContext.PipelineEvent.Event);
var projectedPipelineEvent = new PipelineEvent(projectedEvent);
pipelineContext.PipelineEvent = projectedPipelineEvent;
return(invokeNextModule(pipelineContext));
}
public void RaisedEvent(PipelineEvent pEvent)
{
if (OnEventRaised == null)
{
return;
}
Parallel.ForEach(OnEventRaised.GetInvocationList(), t => {
((EventHandler <PipelineEventEventArgs>)t).BeginInvoke(
this, new PipelineEventEventArgs()
{
Event = pEvent
}, null, null);
});
}
/// <inheritdoc />
public async Task RouteEventAsync(PipelineEvent pipelineEvent, IEventsScope eventsScope)
{
using (_logger.BeginEventRoutingScope(pipelineEvent))
{
var pipelines = _pipelinesService.GetPipelines(pipelineEvent.EventType);
foreach (var pipeline in pipelines)
{
_logger.EventRoutedToPipeline();
await pipeline.ProcessEventAsync(pipelineEvent, eventsScope).ConfigureAwait(false);
}
}
}
public void SetUp()
{
_appServiceProviderMock = new Mock <IRootAppServiceProvider>(MockBehavior.Strict);
_eventsContextMock = new Mock <IEventsContext>(MockBehavior.Strict);
_pipelineMock = new Mock <IPipeline>(MockBehavior.Strict);
_eventsQueueNamesServiceMock = new Mock <IEventsQueueNamesService>(MockBehavior.Strict);
_eventsScopeMock = new Mock <IEventsScope>(MockBehavior.Strict);
_eventsScopeQueuesFeatureMock = new Mock <IEventsScopeQueuesFeature>(MockBehavior.Strict);
_eventsQueue = new EventsQueue(_queueName);
_pipelineEvent = MakeNewPipelineEvent();
_eventsQueuesService = new EventsQueuesService(_eventsContextMock.Object, _eventsQueueNamesServiceMock.Object);
}
public void SetUp()
{
_loggerMock = new Mock <ILogger <RoutingService> >(MockBehavior.Strict);
_loggerScopeMock = new Mock <IDisposable>(MockBehavior.Strict);
_pipelineMock = new Mock <IPipeline>(MockBehavior.Strict);
_pipelinesServiceMock = new Mock <IPipelinesService>(MockBehavior.Strict);
_eventsScopeMock = new Mock <IEventsScope>(MockBehavior.Strict);
_routingService = new RoutingService(
_loggerMock.Object,
_pipelinesServiceMock.Object
);
_pipelineEvent = new PipelineEvent(new object());
}
public MessageNotHandledEventArgs(PipelineEvent pipelineEvent, IQueue workQueue, IQueue errorQueue,
TransportMessage transportMessage, object message)
: base(pipelineEvent)
{
Guard.AgainstNull(pipelineEvent, "pipelineEvent");
Guard.AgainstNull(workQueue, "workQueue");
Guard.AgainstNull(errorQueue, "errorQueue");
Guard.AgainstNull(transportMessage, "transportMessage");
Guard.AgainstNull(message, "message");
WorkQueue = workQueue;
ErrorQueue = errorQueue;
TransportMessage = transportMessage;
Message = message;
}
public void SetUp()
{
_serviceProviderMock = new Mock <IServiceProvider>(MockBehavior.Strict);
_eventsQueuesServiceMock = new Mock <IEventsQueuesService>(MockBehavior.Strict);
_eventsScopeMock = new Mock <IEventsScope>(MockBehavior.Strict);
_enqueuePipelineModuleConfig = new EnqueuePipelineModuleConfig
{
QueueName = QueueName
};
_pipelineEvent = new PipelineEvent(new object());
_pipelineContext = new PipelineContext(_pipelineEvent, _eventsScopeMock.Object, _serviceProviderMock.Object);
_enqueuePipelineModule = new EnqueuePipelineModule(_eventsQueuesServiceMock.Object);
}
public void SetUp()
{
_azureSignalRClientMock = new Mock <IEventSendingService>(MockBehavior.Strict);
_serviceProviderMock = new Mock <IServiceProvider>(MockBehavior.Strict);
_eventsScopeMock = new Mock <IEventsScope>(MockBehavior.Strict);
_azureSignalRPipelineModuleConfig = new AzureSignalRPipelineModuleConfig
{
HubMethodName = nameof(AzureSignalRPipelineModuleConfig.HubMethodName),
HubName = nameof(AzureSignalRPipelineModuleConfig.HubName),
PublicationMethod = PublicationMethod.User,
ReceiverIdsProviderAction = e => _receiverIds
};
_pipelineEvent = new PipelineEvent(typeof(object));
_pipelineContext = new PipelineContext(_pipelineEvent, _eventsScopeMock.Object, _serviceProviderMock.Object);
_azureSignalRPipelineModule = new AzureSignalRPipelineModule(_azureSignalRClientMock.Object);
}
public async Task MessageHandler_ShouldDeserializeAndPublishEventToGlobalSubscriptions()
{
await _azureTopicEventReceiver.StartReceivingAsync(CancellationToken.None);
var messageBytes = new byte[] { 1, 2, 3, 4, 5 };
var pipelineEvent = new PipelineEvent(typeof(object));
_eventsSerializationServiceMock
.Setup(x => x.DeserializeEvent(It.Is <byte[]>(y => y.SequenceEqual(messageBytes))))
.Returns(pipelineEvent)
.Verifiable();
_publishingServiceMock
.Setup(x => x.PublishEventToGlobalSubscriptionsAsync(pipelineEvent))
.Returns(Task.CompletedTask)
.Verifiable();
await _messageHandler(new Message(messageBytes), CancellationToken.None);
}
public void SetUp()
{
_loggerMock = new Mock <ILogger <PublishingService> >(MockBehavior.Strict);
_globalSubscriptionsServiceMock = new Mock <IGlobalSubscriptionsService>(MockBehavior.Strict);
_scopedSubscriptionsServiceMock = new Mock <IScopedSubscriptionsService>(MockBehavior.Strict);
_subscriptionsMatchingServiceMock = new Mock <ISubscriptionsMatchingService>(MockBehavior.Strict);
_eventsScopeMock = new Mock <IEventsScope>(MockBehavior.Strict);
_eventsScopeSubscriptionsFeatureMock = new Mock <IEventsScopeSubscriptionsFeature>(MockBehavior.Strict);
_publishingService = new PublishingService(
_loggerMock.Object,
_globalSubscriptionsServiceMock.Object,
_scopedSubscriptionsServiceMock.Object,
_subscriptionsMatchingServiceMock.Object
);
Action <object> subscription0HandlerAction = args =>
{
ThrowIfEnabled();
_subscription0Event = args;
};
Action <object> subscription1HandlerAction = args =>
{
ThrowIfEnabled();
_subscription1Event = args;
};
_subscriptions = new[]
{
new Subscription(typeof(object), subscription0HandlerAction.GetInvocationList()[0]),
new Subscription(typeof(object), subscription1HandlerAction.GetInvocationList()[0]),
};
_pipelineEvent = new PipelineEvent(typeof(object));
_subscription1Event = null;
_subscription0Event = null;
_isThrowingEnabled = false;
}
public MessageHandlerInvokeResult Invoke(PipelineEvent pipelineEvent)
{
Guard.AgainstNull(pipelineEvent, "pipelineEvent");
var state = pipelineEvent.Pipeline.State;
var bus = state.GetServiceBus();
var message = state.GetMessage();
var handler = bus.Configuration.MessageHandlerFactory.GetHandler(message);
if (handler == null)
{
return(MessageHandlerInvokeResult.InvokeFailure());
}
try
{
var transportMessage = state.GetTransportMessage();
var messageType = message.GetType();
var contextType = typeof(HandlerContext <>).MakeGenericType(messageType);
var method = handler.GetType().GetMethod("ProcessMessage", new[] { contextType });
if (method == null)
{
throw new ProcessMessageMethodMissingException(string.Format(
EsbResources.ProcessMessageMethodMissingException,
handler.GetType().FullName,
messageType.FullName));
}
var handlerContext = Activator.CreateInstance(contextType, bus, transportMessage, message, state.GetActiveState());
method.Invoke(handler, new[] { handlerContext });
}
finally
{
bus.Configuration.MessageHandlerFactory.ReleaseHandler(handler);
}
return(MessageHandlerInvokeResult.InvokedHandler(handler));
}
internal async Task <Exception> PublishEventAsync(PipelineEvent pipelineEvent)
{
if (pipelineEvent == null)
{
throw new ArgumentNullException(nameof(pipelineEvent));
}
if (!EventType.IsInstanceOfType(pipelineEvent.Event))
{
throw new EventTypeMismatchException();
}
try
{
await InvokeEventHandlerAsync(pipelineEvent, _eventsHandler).ConfigureAwait(false);
return(null);
}
catch (TargetInvocationException ex)
{
return(ex.InnerException);
}
}
public void SetUp()
{
_pipelineEvent = new PipelineEvent(new object());
_topicClientMock = new Mock <ITopicClient>(MockBehavior.Strict);
_loggerMock = new Mock <ILogger <AzureTopicEventSender> >(MockBehavior.Strict);
_eventsSerializationServiceMock = new Mock <IEventsSerializationService>(MockBehavior.Strict);
_topicClientFactoryMock = new Mock <ITopicClientFactory>(MockBehavior.Strict);
_topicClientFactoryMock
.Setup(x => x.GetNew(Constants.ValidConnectionString))
.Returns(_topicClientMock.Object)
.Verifiable();
_azureTopicEventSender = new AzureTopicEventSender(
_loggerMock.Object,
Options.Create(new AzureTopicEventSenderOptions
{
SendConnectionString = Constants.ValidConnectionString
}),
_eventsSerializationServiceMock.Object,
_topicClientFactoryMock.Object
);
}
public void EnqueueEvent(IEventsScope eventsScope, PipelineEvent pipelineEvent, string queueName, Func <Task> invokeNextModule)
{
if (eventsScope == null)
{
throw new ArgumentNullException(nameof(eventsScope));
}
if (pipelineEvent == null)
{
throw new ArgumentNullException(nameof(pipelineEvent));
}
if (queueName == null)
{
throw new ArgumentNullException(nameof(queueName));
}
if (!_eventsQueueNamesService.IsQueueNameExisting(queueName))
{
throw new EventsQueueNotFoundException();
}
var queue = eventsScope.GetQueuesFeature().GetOrAddEventsQueue(_eventsContext, queueName);
queue.Enqueue(new QueuedPipelineEvent(invokeNextModule));
}
public QueueEmptyEventArgs(PipelineEvent pipelineEvent, IQueue queue)
: base(pipelineEvent)
{
Queue = queue;
}
public Task PublishEventToGlobalSubscriptionsAsync(PipelineEvent pipelineEvent) => PublishInternalAsync(pipelineEvent, _globalSubscriptionsService.GetGlobalSubscriptions());
public PipelineEventEventArgs(PipelineEvent pipelineEvent)
{
PipelineEvent = pipelineEvent;
}
private static void DisposeDatabaseContext(PipelineEvent pipelineEvent)
{
pipelineEvent.Pipeline.State.Get <IDatabaseContext>().AttemptDispose();
}
/// <inheritdoc />
public byte[] SerializeEvent(PipelineEvent pipelineEvent)
{
var data = JsonConvert.SerializeObject(pipelineEvent, pipelineEvent.EventType, _serializerSettings);
return(Encoding.UTF8.GetBytes(data));
}