public async Task ShouldPublishToPoisonQueueWhenHandlerThrows()
{
var context = MockPartitionContext.CreateWithNoopCheckpoint("1");
var attemptedToResolveHandler = false;
var events = new[] { new EventData() };
var resolver = new MockMessageHandlerResolver(
async(body, headers) =>
{
attemptedToResolveHandler = true;
await Task.Yield();
throw new Exception("This message was bad.");
});
var poisonHandler = (MockPoisonMessageHandler)DependencyResolverFactory
.GetResolver()
.GetService(typeof(IPoisonMessageHandler));
var processor = new EventProcessor(resolver, new MockCircuitBreaker(), 1, "test", Mock.Of <IDispatcherInstrumentationPublisher>());
await processor.ProcessEventsAsync(context, events);
Assert.True(attemptedToResolveHandler);
Assert.True(
poisonHandler.Messages.Any(),
String.Format("Expected poison handler to have messages; count = {0}",
poisonHandler.Messages.Count()));
}
public async Task ShouldNotPublishToPoisonQueueWhenMessageIsHandled()
{
var handled = false;
var context = MockPartitionContext.CreateWithNoopCheckpoint("1");
var events = new[] { new EventData() };
var resovler = new MockMessageHandlerResolver(
(body, headers) =>
{
handled = true;
return(Task.FromResult <object>(null));
});
var poisonHandler = (MockPoisonMessageHandler)DependencyResolverFactory
.GetResolver()
.GetService(typeof(IPoisonMessageHandler));
var processor = new EventProcessor(resovler, new MockCircuitBreaker(), 1, "test", Mock.Of <IDispatcherInstrumentationPublisher>());
await processor.ProcessEventsAsync(context, events);
Assert.True(handled);
Assert.False(
poisonHandler.Messages.Any(),
String.Format("Expected poison handler to have no messages; count = {0}",
poisonHandler.Messages.Count()));
}
void Application_Start(object sender, EventArgs e)
{
var assemblise = new string[]
{
"SuperCom.Host",
"Sql.Infrastructure.IoC"
};
DependencyResolverFactory.Initialize(assemblise);
_resolver = DependencyResolverFactory.GetResolver();
GlobalConfiguration.Configuration.Services.Replace(
typeof(IHttpControllerActivator),
new WindsorCompositionRoot(_resolver.GetResolver));
AreaRegistration.RegisterAllAreas();
GlobalConfiguration.Configure(WebApiConfig.Register);
RouteConfig.RegisterRoutes(RouteTable.Routes);
}
protected async Task InitializeAsync(
string hostName,
string eventHubName,
string consumerGroupName,
string eventHubConnectionString,
string checkpointStorageAccount,
int maxBatchSize,
int prefetchCount,
TimeSpan receiveTimeout,
int maxConcurrencyPerProcessor,
IEnumerable <Type> typesToSearch,
Func <string, string, ICircuitBreaker> circuitBreakerFactory,
IDispatcherInstrumentationPublisher instrumentationPublisher)
{
Logger.Info("Initializing event hub listener for {0} ({1})", eventHubName, consumerGroupName);
// Get the consumer group via the Service Bus namespace (identifies the
// consumer)
var ns = NamespaceManager.CreateFromConnectionString(eventHubConnectionString);
try
{
await ns.GetConsumerGroupAsync(eventHubName, consumerGroupName);
Logger.Info("Found consumer group {1} for {0}", eventHubName, consumerGroupName);
}
catch (Exception e)
{
Logger.Error(e, "Could not establish connection to {0} in event hub {1}", consumerGroupName, eventHubName);
throw;
}
var eventHubId = ConfigurationHelper.GetEventHubName(ns.Address, eventHubName);
// Use a custom event processor factory to pass parameters to the
// event host processor
var factory = new EventProcessorFactory(
handlerResolver: new MessageHandlerResolver(typesToSearch, DependencyResolverFactory.GetResolver()),
maxConcurrency: maxConcurrencyPerProcessor,
circuitBreakerFactory: circuitBreakerFactory,
eventHubName: eventHubId,
instrumentationPublisher: instrumentationPublisher);
var options = new EventProcessorOptions
{
MaxBatchSize = maxBatchSize,
PrefetchCount = prefetchCount,
ReceiveTimeOut = receiveTimeout
};
options.ExceptionReceived += options_ExceptionReceived;
// Create the event processor host and register via the factory
_host = new EventProcessorHost(
hostName,
consumerGroupName: consumerGroupName,
eventHubPath: eventHubName,
eventHubConnectionString: eventHubConnectionString,
storageConnectionString: checkpointStorageAccount
);
await _host.RegisterEventProcessorFactoryAsync(factory, options);
Logger.Info("Event processor registered for {0} ({1})", eventHubName, consumerGroupName);
}