protected override void Given()
{
var container = new Container(x => x.AddRegistry(new BlockingHandlerRegistry()));
var resolutionContext = new HandlerResolutionContext("test");
var handlerResolver = new StructureMapHandlerResolver(container);
var handler = handlerResolver.ResolveHandler <OrderPlaced>(resolutionContext);
Assert.That(handler, Is.Not.Null);
// we use the obsolete interface"IHandler<T>" here
#pragma warning disable 618
var blockingHandler = (BlockingHandler <OrderPlaced>)handler;
_resolvedHandler = (BlockingOrderProcessor)blockingHandler.Inner;
#pragma warning restore 618
DoneSignal = _resolvedHandler.DoneSignal.Task;
Subscriber = CreateMeABus.WithLogging(new LoggerFactory())
.InRegion("eu-west-1")
.WithSqsTopicSubscriber()
.IntoQueue("container-test")
.WithMessageHandler <OrderPlaced>(handlerResolver);
Subscriber.StartListening();
}
protected override Task Given()
{
var container = new Container(x => x.AddRegistry(new SingleHandlerRegistry()));
var resolutionContext = new HandlerResolutionContext("test");
var handlerResolver = new StructureMapHandlerResolver(container);
var handler = handlerResolver.ResolveHandler <OrderPlaced>(resolutionContext);
handler.ShouldNotBeNull();
_handlerFuture = ((OrderProcessor)handler).Future;
DoneSignal = _handlerFuture.DoneSignal;
var fixture = new JustSayingFixture();
Subscriber = fixture.Builder()
.WithSqsTopicSubscriber()
.IntoQueue("container-test")
.WithMessageHandler <OrderPlaced>(handlerResolver);
SubscriberCts = new CancellationTokenSource();
Subscriber.StartListening(SubscriberCts.Token);
return(Task.CompletedTask);
}
public void TestQueueBResolution()
{
var context = new HandlerResolutionContext("QueueB");
var handler = _handlerResolver.ResolveHandler <TestMessage>(context);
handler.ShouldNotBeNull();
handler.ShouldBeAssignableTo <HandlerB>();
}
public void TestQueueBResolution()
{
var context = new HandlerResolutionContext("QueueB");
var handler = _handlerResolver.ResolveHandler <TestMessage>(context);
Assert.That(handler, Is.Not.Null);
Assert.That(handler, Is.InstanceOf <HandlerB>());
}
public void TestOtherQueueNameResolution()
{
var context = new HandlerResolutionContext("QueueWithAnyOtherName");
var handler = _handlerResolver.ResolveHandler <TestMessage>(context);
Assert.That(handler, Is.Not.Null);
Assert.That(handler, Is.InstanceOf <HandlerC>());
}
public void TestOtherQueueNameResolution()
{
var context = new HandlerResolutionContext("QueueWithAnyOtherName");
var handler = _handlerResolver.ResolveHandler <TestMessage>(context);
handler.ShouldNotBeNull();
handler.ShouldBeAssignableTo <HandlerC>();
}
public IHandlerAsync <T> ResolveHandler <T>(HandlerResolutionContext context)
{
if (typeof(T) == typeof(OrderPlaced) && context.QueueName.EndsWith("-dispatched", StringComparison.Ordinal))
{
return(new OrderDispatcher(Future) as IHandlerAsync <T>);
}
throw new NotImplementedException();
}
/// <inheritdoc />
void ISubscriptionBuilder <T> .Configure(
JustSayingBus bus,
IHandlerResolver resolver,
IVerifyAmazonQueues creator,
ILoggerFactory loggerFactory)
{
var logger = loggerFactory.CreateLogger <TopicSubscriptionBuilder <T> >();
var subscriptionConfig = new SqsReadConfiguration(SubscriptionType.ToTopic)
{
QueueName = TopicName
};
ConfigureReads?.Invoke(subscriptionConfig);
var config = bus.Config;
subscriptionConfig.ApplyTopicNamingConvention <T>(config.TopicNamingConvention);
subscriptionConfig.ApplyQueueNamingConvention <T>(config.QueueNamingConvention);
subscriptionConfig.SubscriptionGroupName ??= subscriptionConfig.QueueName;
subscriptionConfig.PublishEndpoint = subscriptionConfig.TopicName;
subscriptionConfig.Validate();
var queueWithStartup = creator.EnsureTopicExistsWithQueueSubscribed(
config.Region,
bus.SerializationRegister,
subscriptionConfig,
config.MessageSubjectProvider);
bus.AddStartupTask(queueWithStartup.StartupTask);
bus.AddQueue(subscriptionConfig.SubscriptionGroupName, queueWithStartup.Queue);
logger.LogInformation(
"Created SQS topic subscription on topic '{TopicName}' and queue '{QueueName}'.",
subscriptionConfig.TopicName,
subscriptionConfig.QueueName);
var resolutionContext = new HandlerResolutionContext(subscriptionConfig.QueueName);
var proposedHandler = resolver.ResolveHandler <T>(resolutionContext);
if (proposedHandler == null)
{
throw new HandlerNotRegisteredWithContainerException(
$"There is no handler for '{typeof(T)}' messages.");
}
bus.AddMessageHandler(subscriptionConfig.QueueName,
() => resolver.ResolveHandler <T>(resolutionContext));
logger.LogInformation(
"Added a message handler for message type for '{MessageType}' on topic '{TopicName}' and queue '{QueueName}'.",
typeof(T),
subscriptionConfig.TopicName,
subscriptionConfig.QueueName);
}
public IHandlerAsync <T> ResolveHandler <T>(HandlerResolutionContext context)
{
var handler = _container.GetInstance <IHandlerAsync <T> >();
if (handler != null)
{
return(handler);
}
return(null);
}
public IHandlerAsync <T> ResolveHandler <T>(HandlerResolutionContext context)
{
var namedHandler = _container.TryGetInstance <IHandlerAsync <T> >(context.QueueName);
if (namedHandler != null)
{
return(namedHandler);
}
return(_container.GetInstance <IHandlerAsync <T> >());
}
/// <inheritdoc />
void ISubscriptionBuilder <T> .Configure(
JustSayingBus bus,
IHandlerResolver resolver,
IVerifyAmazonQueues creator,
ILoggerFactory loggerFactory)
{
var logger = loggerFactory.CreateLogger <QueueSubscriptionBuilder <T> >();
var subscriptionConfig = new SqsReadConfiguration(SubscriptionType.PointToPoint)
{
QueueName = QueueName
};
ConfigureReads?.Invoke(subscriptionConfig);
var config = bus.Config;
subscriptionConfig.ApplyTopicNamingConvention <T>(config.TopicNamingConvention);
subscriptionConfig.ApplyQueueNamingConvention <T>(config.QueueNamingConvention);
subscriptionConfig.SubscriptionGroupName ??= subscriptionConfig.QueueName;
subscriptionConfig.Validate();
var queue = creator.EnsureQueueExists(config.Region, subscriptionConfig);
bus.AddStartupTask(
queue.Queue.EnsureQueueAndErrorQueueExistAndAllAttributesAreUpdatedAsync(subscriptionConfig));
bus.AddQueue(subscriptionConfig.SubscriptionGroupName, queue.Queue);
logger.LogInformation(
"Created SQS subscriber for message type '{MessageType}' on queue '{QueueName}'.",
typeof(T),
subscriptionConfig.QueueName);
var resolutionContext = new HandlerResolutionContext(subscriptionConfig.QueueName);
var proposedHandler = resolver.ResolveHandler <T>(resolutionContext);
if (proposedHandler == null)
{
throw new HandlerNotRegisteredWithContainerException(
$"There is no handler for '{typeof(T)}' messages.");
}
bus.AddMessageHandler(subscriptionConfig.QueueName,
() => resolver.ResolveHandler <T>(resolutionContext));
logger.LogInformation(
"Added a message handler for message type for '{MessageType}' on topic '{TopicName}' and queue '{QueueName}'.",
typeof(T),
subscriptionConfig.TopicName,
subscriptionConfig.QueueName);
}
/// <inheritdoc />
void ISubscriptionBuilder <T> .Configure(
JustSayingBus bus,
IHandlerResolver handlerResolver,
IServiceResolver serviceResolver,
IVerifyAmazonQueues creator,
IAwsClientFactoryProxy awsClientFactoryProxy,
ILoggerFactory loggerFactory)
{
var logger = loggerFactory.CreateLogger <QueueSubscriptionBuilder <T> >();
var attachedQueueConfig = new QueueAddressConfiguration();
ConfigureReads?.Invoke(attachedQueueConfig);
IAmazonSQS sqsClient = awsClientFactoryProxy
.GetAwsClientFactory()
.GetSqsClient(RegionEndpoint.GetBySystemName(_queueAddress.RegionName));
var queue = new QueueAddressQueue(_queueAddress, sqsClient);
attachedQueueConfig.SubscriptionGroupName ??= queue.QueueName;
attachedQueueConfig.Validate();
bus.AddQueue(attachedQueueConfig.SubscriptionGroupName, queue);
logger.LogInformation(
"Created SQS queue subscription for '{MessageType}' on '{QueueName}'",
typeof(T), queue.QueueName);
var resolutionContext = new HandlerResolutionContext(queue.QueueName);
var proposedHandler = handlerResolver.ResolveHandler <T>(resolutionContext);
if (proposedHandler == null)
{
throw new HandlerNotRegisteredWithContainerException(
$"There is no handler for '{typeof(T)}' messages.");
}
var middlewareBuilder = new HandlerMiddlewareBuilder(handlerResolver, serviceResolver);
var handlerMiddleware = middlewareBuilder
.Configure(MiddlewareConfiguration ?? (b => b.UseDefaults <T>(proposedHandler.GetType())))
.Build();
bus.AddMessageMiddleware <T>(queue.QueueName, handlerMiddleware);
logger.LogInformation(
"Added a message handler for message type for '{MessageType}' on queue '{QueueName}'",
typeof(T), queue.QueueName);
}
protected override async Task <bool> RunInnerAsync(
HandleMessageContext context,
Func <CancellationToken, Task <bool> > func,
CancellationToken stoppingToken)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
stoppingToken.ThrowIfCancellationRequested();
var resolutionContext = new HandlerResolutionContext(context.QueueName);
IHandlerAsync <T> handler = _handlerResolver(resolutionContext);
return(await handler.Handle(context.MessageAs <T>()).ConfigureAwait(false));
}
/// <inheritdoc />
public IHandlerAsync <T> ResolveHandler <T>(HandlerResolutionContext context)
{
bool logAtDebug = Logger.IsEnabled(LogLevel.Debug);
if (logAtDebug)
{
Logger.LogDebug(
"Resolving handler for message type {MessageType} for queue {QueueName}.",
typeof(T).FullName,
context.QueueName);
}
var handlers = ServiceProvider.GetServices <IHandlerAsync <T> >().ToArray();
if (handlers.Length == 0)
{
throw new InvalidOperationException($"No handler for message type {typeof(T).FullName} is registered.");
}
else if (handlers.Length > 1)
{
if (logAtDebug)
{
Logger.LogDebug(
"Resolved handler types for message type {MessageType} for queue {QueueName}: {ResolvedHandlerTypes}",
typeof(T).FullName,
context.QueueName,
string.Join(", ", handlers.Select((p) => p.GetType().FullName)));
}
throw new NotSupportedException($"{handlers.Length} handlers for message type {typeof(T).FullName} are registered. Only one handler is supported per message type.");
}
var handler = handlers[0];
if (logAtDebug)
{
Logger.LogDebug(
"Resolved handler of type {ResolvedHandlerType} for queue {QueueName}.",
handler.GetType().Name,
context.QueueName);
}
return(handler);
}
public IHandlerAsync <T> ResolveHandler <T>(HandlerResolutionContext context)
{
var handler = _container.GetInstance <IHandlerAsync <T> >();
if (handler != null)
{
return(handler);
}
// we use the obsolete interface"IHandler<T>" here
#pragma warning disable 618
var syncHandler = _container.GetInstance <IHandler <T> >();
if (syncHandler != null)
{
return(new BlockingHandler <T>(syncHandler));
}
#pragma warning restore 618
return(null);
}
protected override void Given()
{
var container = new Container(x => x.AddRegistry(new SingleHandlerRegistry()));
var resolutionContext = new HandlerResolutionContext("test");
var handlerResolver = new StructureMapHandlerResolver(container);
var handler = handlerResolver.ResolveHandler <OrderPlaced>(resolutionContext);
handler.ShouldNotBeNull();
_handlerFuture = ((OrderProcessor)handler).Future;
DoneSignal = _handlerFuture.DoneSignal;
Subscriber = CreateMeABus.WithLogging(new LoggerFactory())
.InRegion("eu-west-1")
.WithSqsTopicSubscriber()
.IntoQueue("container-test")
.WithMessageHandler <OrderPlaced>(handlerResolver);
Subscriber.StartListening();
}
public IHandlerAsync <T> ResolveHandler <T>(HandlerResolutionContext context) => _container.GetInstance <IHandlerAsync <T> >();
public IHandlerAsync <T> ResolveHandler <T>(HandlerResolutionContext context)
{
return((IHandlerAsync <T>)_provider.GetService(typeof(IHandlerAsync <T>)));
}
public IHandlerAsync <CreateSongCommand> ResolveHandler(HandlerResolutionContext context)
{
return(new CreateSongCommandHandler());
}
public IHandlerAsync <T> ResolveHandler <T>(HandlerResolutionContext context)
{
return(_container.Resolve <IHandlerAsync <T> >());
}
