public static void UseEventMessageProcessor(
this IAppBuilder app,
EventProcessorHost eventProcessorHost,
EventDataSerializer serializer,
IMessageHandler messageHandler)
{
app.UseEventMessageProcessor(
eventProcessorHost,
serializer,
messageHandler,
_defaultExceptionHandler);
}
public async Task UseEventMessageProcessor_registers_EventMessageProcessorFactory_correctly()
{
// Arrange
var message = fixture.Create <BlogPostCreated>();
var envelope = new Envelope(message);
Envelope handled = null;
var messageHandler = Mock.Of <IMessageHandler>();
Mock.Get(messageHandler)
.Setup(x => x.Handle(It.IsNotNull <Envelope>(), It.IsAny <CancellationToken>()))
.Callback <Envelope, CancellationToken>((m, t) => handled = m)
.Returns(Task.FromResult(true));
var serializer = new EventDataSerializer();
var eventHubClient = EventHubClient.CreateFromConnectionString(eventHubConnectionString, eventHubPath);
var messageBus = new EventHubMessageBus(eventHubClient, serializer);
CancellationToken cancellationToken;
using (TestServer server = TestServer.Create(app =>
{
app.UseEventMessageProcessor(
new EventProcessorHost(
eventHubPath,
consumerGroupName,
eventHubConnectionString,
storageConnectionString),
serializer,
messageHandler);
var properties = new AppProperties(app.Properties);
cancellationToken = properties.OnAppDisposing;
}))
{
// Act
await messageBus.Send(envelope, CancellationToken.None);
for (int i = 0; i < 10 && handled == null; i++)
{
await Task.Delay(TimeSpan.FromMilliseconds(1000));
}
// Assert
Mock.Get(messageHandler).Verify(x => x.Handle(It.IsAny <Envelope>(), cancellationToken), Times.Once());
handled.ShouldBeEquivalentTo(envelope, opts => opts.RespectingRuntimeTypes());
}
}
public static void UseEventMessageProcessor(
this IAppBuilder app,
EventProcessorHost eventProcessorHost,
EventDataSerializer serializer,
IMessageHandler messageHandler,
IMessageProcessingExceptionHandler <EventData> exceptionHandler)
{
if (app == null)
{
throw new ArgumentNullException(nameof(app));
}
if (eventProcessorHost == null)
{
throw new ArgumentNullException(nameof(eventProcessorHost));
}
if (serializer == null)
{
throw new ArgumentNullException(nameof(serializer));
}
if (messageHandler == null)
{
throw new ArgumentNullException(nameof(messageHandler));
}
if (exceptionHandler == null)
{
throw new ArgumentNullException(nameof(exceptionHandler));
}
CancellationToken cancellationToken = new AppProperties(app.Properties).OnAppDisposing;
var processorFactory = new EventMessageProcessorFactory(
serializer,
messageHandler,
exceptionHandler,
cancellationToken);
Start(eventProcessorHost, processorFactory);
cancellationToken.Register(() => Stop(eventProcessorHost));
}
private IReadOnlyList <EventData> SerializeEventData(OperationContext context, ContentLocationEventData[] events)
{
// EventDataSerializer is not thread-safe.
// This is usually not a problem, because the nagle queue that is used by this class
// kind of guarantees that it would be just a single thread responsible for sending the events
// to event hub.
// But this is not the case when the batch size is 1 (used by tests only).
// In this case a special version of a nagle queue is created, that doesn't have this guarantee.
// In this case this method can be called from multiple threads causing serialization/deserialization issues.
// So to prevent random test failures because of the state corruption we're using lock
// if the batch size is 1.
if (_configuration.EventBatchSize == 1)
{
lock (EventDataSerializer)
{
return(EventDataSerializer.Serialize(context, events));
}
}
return(EventDataSerializer.Serialize(context, events));
}
private IReadOnlyList <EventData> SerializeEventData(OperationContext context, ContentLocationEventData[] events)
{
return(EventDataSerializer.Serialize(context, events));
}
