public QueueInfoSnapshot GetQueueInfo(string subscriberName, bool temporary)
{
var queueName = _environmentNamingConventionController.GetQueueName(subscriberName);
var queue = _bus.QueueDeclare(queueName, true, true, temporary);
var countOfMessages = _bus.MessageCount(queue);
return(new QueueInfoSnapshot {
CountOfMessages = countOfMessages
});
}
/// <summary>
/// Initializes a new instance of the <see cref="EasyNetQBroker"/> class.
/// </summary>
/// <param name="createBus">create bus method</param>
/// <param name="connectionString">rabbitmq connection string</param>
/// <param name="exchangeName">exchange name</param>
/// <param name="tombQueue">queue name</param>
/// <param name="environmentNamingConventionController">environment naming convention controller</param>
public EasyNetQBroker(
Func <string, EventHandler, EventHandler, Action <IServiceRegister>, IAdvancedBus> createBus,
string connectionString, string exchangeName, string tombQueue,
IEnvironmentNamingConventionController environmentNamingConventionController)
{
_disconnectedActions = new ConcurrentDictionary <Action, bool>();
Bus = createBus(
connectionString,
(s, e) =>
{
_logger.Information("Rabbitmq bus connected");
},
(s, e) =>
{
_logger.Information("Rabbitmq bus disconnected");
foreach (var record in _disconnectedActions.ToArray())
{
try
{
record.Key?.Invoke();
}
catch (Exception exp)
{
_logger.Error(exp, $"Failed to execute disconnect callback {exp.Message}");
}
finally
{
// call action only one time
_disconnectedActions.Remove(record.Key);
}
}
},
register => register.Register <IEventBus>(provider =>
{
var eventBus = new EventBus();
eventBus.Subscribe <StartConsumingFailedEvent>(
x =>
{
_logger.Error($"Failed to connect to queue {x.Queue.Name}");
});
return(eventBus);
}));
var conventions = Bus.Container.Resolve <IConventions>();
if (conventions != null)
{
conventions.ErrorQueueNamingConvention = () => environmentNamingConventionController.GetQueueName(tombQueue);
conventions.ErrorExchangeNamingConvention = messageReceivedInfo => exchangeName + "_error";
}
}
private async Task <ISubscriber> CreateSubscriberAsync(string name, bool temporary, Action temporaryQueueDisconnected,
IEnumerable <string> routings, int retrycount, int prefetchcount, bool explicitAcknowledgments, ISubscriptionSelector subscriptionSelector, bool storedeadletter)
{
if (string.IsNullOrEmpty(name))
{
throw new ArgumentException("name argument can not be null or empty");
}
if ((routings != null) && (routings.Any(routing => string.IsNullOrEmpty(routing)) || !routings.Any()))
{
throw new ArgumentException("routings argument can not be empty or contain empty strings");
}
if (retrycount < 0)
{
throw new ArgumentException("retrycount argument can not be less than zero");
}
if (temporaryQueueDisconnected != null)
{
_broker.RegisterDisconnectedAction(temporaryQueueDisconnected);
}
//Main subscriber queue and bindings
var queue = await _bus.QueueDeclareAsync(
_environmentNamingConventionController.GetQueueName(name), false, true, temporary);
if (routings != null)
{
foreach (var routing in routings)
{
await _bus.BindAsync(await _exchange, queue, routing);
}
}
//Retry subscriber queue and bindings
for (int i = 1; i <= retrycount; i++)
{
var retryqueueroutingkey = _environmentNamingConventionController.GetRetryRoutingKey(name, i);
var retryqueuequeuename = _environmentNamingConventionController.GetRetryQueueName(name, i);
var queueretrybinding = await _bus.BindAsync(await _exchange, queue,
retryqueueroutingkey);
var retryqueue = await _bus.QueueDeclareAsync(retryqueuequeuename,
false, true, temporary, false, _retryfactor *i, null, null, (await _exchange).Name);
var retryqueuebinding =
await _bus.BindAsync(_easyNetQPublisherToWaitExchange.Exchange,
retryqueue, retryqueueroutingkey);
}
//Dead letter subscriber queue and bindings
if (storedeadletter)
{
var deadletterqueueroutingkey = _environmentNamingConventionController
.GetDeadLetterQueueRoutingKey(name);
var deadletterqueuequeuename = _environmentNamingConventionController.
GetDeadLetterQueueName(name);
var deadletterqueue = await _bus.QueueDeclareAsync(deadletterqueuequeuename, false, true, temporary);
var deadletterqueuebinding = await
_bus.BindAsync(_easyNetQPublisherToWaitExchange.Exchange, deadletterqueue,
deadletterqueueroutingkey);
}
//Direct Routing Key binding
var directroutingkey = _environmentNamingConventionController.GetDirectRoutingKey(name);
var queuedirectroutingkeybinding = await _bus.BindAsync(await _exchange, queue,
directroutingkey);
if (_subscriberController.RegisterSubscriberName(name, out IDisposable nameHandle))
{
var executionHandler = new ExecutionHandlingStrategy(name, _easyNetQPublisherToWaitExchange,
retrycount, _environmentNamingConventionController, explicitAcknowledgments, _publisher, storedeadletter);
return(new EasyNetQSubscriber(executionHandler, _bus, queue, (ushort)prefetchcount,
subscriptionSelector, executionHandler, nameHandle));
}
else
{
throw new SubscriberAlreadyExistsException($"The subscriber " +
$"with name {name}" +
$" already exists");
}
}