public IBasicConsumer ConfigureConsume(IBasicConsumer consumer, ConsumeConfiguration cfg)
{
CheckPropertyValues(cfg);
if (cfg.PrefetchCount > 0)
{
_logger.LogInformation("Setting Prefetch Count to {prefetchCount}.", cfg.PrefetchCount);
consumer.Model.BasicQos(
prefetchSize: 0,
prefetchCount: cfg.PrefetchCount,
global: false
);
}
_logger.LogInformation("Preparing to consume message from queue '{queueName}'.", cfg.QueueName);
consumer.Model.BasicConsume(
queue: cfg.QueueName,
autoAck: cfg.AutoAck,
consumerTag: cfg.ConsumerTag,
noLocal: cfg.NoLocal,
exclusive: cfg.Exclusive,
arguments: cfg.Arguments,
consumer: consumer);
return(consumer);
}
public void Configuration_ExtensionNotIConsumeConfiguration_ShouldUseEmtpyOne()
{
var extension = new Mock <IExtension>();
var testee = new ConsumeConfiguration(extension.Object);
testee.Configuration.Should().BeEmpty();
}
protected virtual void AddAcknowledgementToContext(IPipeContext context, ConsumeConfiguration cfg)
{
if (cfg.AutoAck)
{
return;
}
context.Properties.TryAdd(PipeKey.MessageAcknowledgement, new Ack());
}
protected virtual void AlignConsumerConfig(ConsumeConfiguration consumeConfig, QueueDeclaration declaration)
{
if (consumeConfig == null)
{
return;
}
consumeConfig.QueueName = declaration.Name;
}
public Task <IBasicConsumer> GetConsumerAsync(ConsumeConfiguration cfg, IModel channel = null, CancellationToken token = default(CancellationToken))
{
var consumerKey = CreateConsumerKey(cfg);
var lazyConsumerTask = _consumerCache.GetOrAdd(consumerKey, routingKey =>
{
return(new Lazy <Task <IBasicConsumer> >(async() =>
{
var consumer = await CreateConsumerAsync(channel, token);
return consumer;
}));
});
return(lazyConsumerTask.Value);
}
public void Configuration_ExtensionIHaveExtensionConfigurationSectionName_ShouldAcquireNameFromExtension()
{
var extension = new Mock <IExtension>();
var consumer = extension.As <IConsumeConfiguration>();
var expected = new KeyValuePair <string, string>("Value", "Key");
consumer.Setup(n => n.Configuration).Returns(
new Dictionary <string, string> {
{ expected.Key, expected.Value }
});
var testee = new ConsumeConfiguration(extension.Object);
testee.Configuration.Should().Contain(expected);
}
protected virtual void CheckPropertyValues(ConsumeConfiguration cfg)
{
if (cfg == null)
{
throw new ArgumentException("Unable to create consumer. The provided configuration is null");
}
if (string.IsNullOrEmpty(cfg.QueueName))
{
throw new ArgumentException("Unable to create consume. No queue name provided.");
}
if (string.IsNullOrEmpty(cfg.ConsumerTag))
{
throw new ArgumentException("Unable to create consume. Consumer tag cannot be undefined.");
}
}
public void Configuration_ExtensionIHaveExtensionConfigurationSectionName_ShouldAcquireNameFromExtension()
{
var extension = A.Fake <IExtension>(builder => builder.Implements(typeof(IConsumeConfiguration)));
var consumer = extension as IConsumeConfiguration;
var expected = new KeyValuePair <string, string>("Value", "Key");
A.CallTo(() => consumer.Configuration)
.Returns(new Dictionary <string, string> {
{ expected.Key, expected.Value }
});
var testee = new ConsumeConfiguration(extension);
testee.Configuration.Should().Contain(expected);
}
public Task <IBasicConsumer> GetConfiguredConsumerAsync(ConsumeConfiguration cfg, IModel channel = null, CancellationToken token = default(CancellationToken))
{
var consumerKey = CreateConsumerKey(cfg);
var lazyConsumerTask = _consumerCache.GetOrAdd(consumerKey, routingKey =>
{
return(new Lazy <Task <IBasicConsumer> >(async() =>
{
var consumer = await CreateConsumerAsync(channel, token);
ConfigureConsume(consumer, cfg);
return consumer;
}));
});
if (lazyConsumerTask.Value.IsCompleted && lazyConsumerTask.Value.Result.Model.IsClosed)
{
_consumerCache.TryRemove(consumerKey, out _);
return(GetConsumerAsync(cfg, channel, token));
}
return(lazyConsumerTask.Value);
}
protected string CreateConsumerKey(ConsumeConfiguration cfg)
{
return($"{cfg.QueueName}:{cfg.RoutingKey}:{cfg.AutoAck}");
}
protected virtual void BasicConsume(IBasicConsumer consumer, ConsumeConfiguration config)
{
_factory.ConfigureConsume(consumer, config);
}
protected virtual ExceptionInformation CreateExceptionInformation(Exception exception, BasicDeliverEventArgs args, ConsumeConfiguration cfg, IPipeContext context)
{
return(new ExceptionInformation
{
Message = $"An unhandled exception was thrown when consuming a message\n MessageId: {args.BasicProperties.MessageId}\n Queue: '{cfg.QueueName}'\n Exchange: '{cfg.ExchangeName}'\nSee inner exception for more details.",
ExceptionType = exception.GetType().FullName,
StackTrace = exception.StackTrace,
InnerMessage = exception.Message
});
}
public static async Task <IBasicConsumer> CreateConsumerAsync(this IBusClient client, ConsumeConfiguration config = null, CancellationToken ct = default(CancellationToken))
{
var result = await client.InvokeAsync(ConsumerAction, context =>
{
context.Properties.Add(PipeKey.ConsumeConfiguration, config);
}, ct);
return(result.GetConsumer());
}
