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"); } }