private IModel CreateChannel(IQueue queue) { var channel = connection.CreateModel(); channel.ModelShutdown += (model, reason) => logger.DebugWrite("Model Shutdown for queue: '{0}'", queue.Name); return(channel); }
private void Publish <T>(T @event) { var policy = Policy.Handle <BrokerUnreachableException>() .Or <SocketException>() .WaitAndRetry(_retryCount, retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)), (ex, time) => { _logger.LogWarning(ex.ToString()); }); using (var channel = _persistentConnection.CreateModel()) { var eventName = @event.GetType().Name; channel.ExchangeDeclare(exchange: BROKER_NAME, type: "direct"); var message = JsonConvert.SerializeObject(@event); var body = Encoding.UTF8.GetBytes(message); policy.Execute(() => { channel.BasicPublish(exchange: BROKER_NAME, routingKey: eventName, basicProperties: null, body: body); }); } }
public async void Publish(IntegrationEvent @event) { ConnectToBroker(); var policy = CreateRetryPolicy(@event); var eventName = @event.GetType().Name; using (var channel = PersistentConnection.CreateModel()) { var message = JsonConvert.SerializeObject(@event); var body = Encoding.UTF8.GetBytes(message); await policy.ExecuteAsync(() => { var properties = channel.CreateBasicProperties(); properties.DeliveryMode = PERSISTENT_MODE; Logger.LogTrace("Publicando evento no RabbitMQ: {EventId}", @event.Id); channel.BasicPublish( exchange: CENSUS_EXCHANGE, routingKey: eventName, mandatory: true, basicProperties: properties, body: body); return(Task.CompletedTask); }); } }
public void Publish(IntegrationEvent @event) { if (!_persistentConnection.IsConnected) { _persistentConnection.TryConnect(); } var policy = Policy.Handle <Exception>() .WaitAndRetry(_retryCount, retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)), (ex, time) => { Log.ForContext <QueueProvider>().Warning(ex, "{@ex}"); }); using (var channel = _persistentConnection.CreateModel()) { var eventName = @event.GetType() .Name; channel.ExchangeDeclare(BROKER_NAME, "direct"); var message = JsonConvert.SerializeObject(@event); var body = Encoding.UTF8.GetBytes(message); policy.Execute(() => { var properties = channel.CreateBasicProperties(); properties.DeliveryMode = 2; channel.BasicPublish(BROKER_NAME, eventName, true, properties, body); }); } }
public When_an_action_is_performed_on_a_closed_channel_that_then_opens() { persistentConnection = Substitute.For <IPersistentConnection>(); channel = Substitute.For <IModel>(); var eventBus = new EventBus(); var configuration = new ConnectionConfiguration(); var shutdownArgs = new ShutdownEventArgs( ShutdownInitiator.Peer, AmqpException.ConnectionClosed, "connection closed by peer"); var exception = new OperationInterruptedException(shutdownArgs); persistentConnection.CreateModel().Returns(x => { throw exception; }, x => channel, x => channel); var logger = Substitute.For <IEasyNetQLogger>(); persistentChannel = new PersistentChannel(persistentConnection, logger, configuration, eventBus); new Timer(_ => eventBus.Publish(new ConnectionCreatedEvent()), null, 10, Timeout.Infinite); persistentChannel.InvokeChannelAction(x => x.ExchangeDeclare("MyExchange", "direct")); }
public StartConsumingStatus StartConsuming(IPersistentConnection connection, ICollection <Tuple <IQueue, Func <byte[], MessageProperties, MessageReceivedInfo, Task> > > queueConsumerPairs, IConsumerConfiguration configuration) { Preconditions.CheckNotNull(connection, nameof(connection)); Preconditions.CheckNotNull(queueConsumerPairs, nameof(queueConsumerPairs)); Preconditions.CheckNotNull(configuration, nameof(configuration)); IDictionary <string, object> arguments = new Dictionary <string, object> { { "x-priority", configuration.Priority }, { "x-cancel-on-ha-failover", configuration.CancelOnHaFailover || connectionConfiguration.CancelOnHaFailover } }; try { Model = connection.CreateModel(); Model.BasicQos(0, configuration.PrefetchCount, true); basicConsumers = new List <BasicConsumer>(); foreach (var p in queueConsumerPairs) { var queue = p.Item1; var onMessage = p.Item2; var consumerTag = conventions.ConsumerTagConvention(); try { var basicConsumers = new BasicConsumer(SingleBasicConsumerCancelled, consumerDispatcher, queue, eventBus, handlerRunner, onMessage, logger, Model); Model.BasicConsume( queue.Name, // queue false, // noAck consumerTag, // consumerTag true, configuration.IsExclusive, arguments, // arguments basicConsumers); // consumer this.basicConsumers.Add(basicConsumers); logger.InfoWrite("Declared Consumer. queue='{0}', consumer tag='{1}' prefetchcount={2} priority={3} x-cancel-on-ha-failover={4}", queue.Name, consumerTag, configuration.PrefetchCount, configuration.Priority, configuration.CancelOnHaFailover); } catch (Exception ex) { logger.ErrorWrite("Consume failed. queue='{0}', consumer tag='{1}', message='{2}'", queue.Name, consumerTag, ex.Message); return(StartConsumingStatus.Failed); } } } catch (Exception exception) { logger.ErrorWrite("Consume failed. queue='{0}', message='{1}'", string.Join(";", queueConsumerPairs.Select(x => x.Item1.Name)), exception.Message); return(StartConsumingStatus.Failed); } return(StartConsumingStatus.Succeed); }
public void StartConsuming( IPersistentConnection connection, IQueue queue, Func <byte[], MessageProperties, MessageReceivedInfo, Task> onMessage) { Preconditions.CheckNotNull(connection, "connection"); Preconditions.CheckNotNull(queue, "queue"); Preconditions.CheckNotNull(onMessage, "onMessage"); this.queue = queue; this.onMessage = onMessage; var consumerTag = conventions.ConsumerTagConvention(); try { Model = connection.CreateModel(); Model.BasicQos(0, connectionConfiguration.PrefetchCount, false); Model.BasicConsume( queue.Name, // queue false, // noAck consumerTag, // consumerTag this); // consumer logger.InfoWrite("Declared Consumer. queue='{0}', consumer tag='{1}' prefetchcount={2}", queue.Name, consumerTag, connectionConfiguration.PrefetchCount); } catch (Exception exception) { logger.InfoWrite("Consume failed. queue='{0}', consumer tag='{1}', message='{2}'", queue.Name, consumerTag, exception.Message); } }
private void OpenChannel() { channel = connection.CreateModel(); disconnected = false; eventBus.Publish(new PublishChannelCreatedEvent(channel)); logger.DebugWrite("Persistent channel connected."); }
private IModel CreateChannel() { var channel = connection.CreateModel(); AttachChannelEvents(channel); return(channel); }
public IBasicGetResult Get(IQueue queue) { Preconditions.CheckNotNull(queue, "queue"); //var result = clientCommandDispatcher.Invoke(x => x.BasicGet(queue.Name, false)); RabbitMQ.Client.IModel model = connection.CreateModel(); model.ContinuationTimeout = connectionConfiguration.ContinuationTimeout; var result = model.BasicGet(queue.Name, false); if (result == null) { return(null); } else { model.BasicAck(result.DeliveryTag, false); } var getResult = new BasicGetResult( result.Body, new MessageProperties(result.BasicProperties), new MessageReceivedInfo( "", result.DeliveryTag, result.Redelivered, result.Exchange, result.RoutingKey, queue.Name ) ); logger.DebugWrite("Message Get from queue '{0}'", queue.Name); return(getResult); }
public StartConsumingStatus StartConsuming( IPersistentConnection connection, IQueue queue, Func <byte[], MessageProperties, MessageReceivedInfo, Task> onMessage, IConsumerConfiguration configuration ) { Preconditions.CheckNotNull(connection, "connection"); Preconditions.CheckNotNull(queue, "queue"); Preconditions.CheckNotNull(onMessage, "onMessage"); Preconditions.CheckNotNull(configuration, "configuration"); var consumerTag = conventions.ConsumerTagConvention(); IDictionary <string, object> arguments = new Dictionary <string, object> { { "x-priority", configuration.Priority } }; try { Model = connection.CreateModel(); var basicConsumer = new BasicConsumer(SingleBasicConsumerCancelled, consumerDispatcher, queue, eventBus, handlerRunner, onMessage, Model); basicConsumers = new[] { basicConsumer }; Model.BasicQos(0, configuration.PrefetchCount, false); Model.BasicConsume( queue.Name, // queue false, // noAck consumerTag, // consumerTag true, configuration.IsExclusive, arguments, // arguments basicConsumer); // consumer logger.InfoFormat( "Declared consumer with consumerTag {consumerTag} on queue {queue} and configuration {configuration}", consumerTag, queue.Name, configuration ); return(StartConsumingStatus.Succeed); } catch (Exception exception) { logger.Error( exception, "Consume with consumerTag {consumerTag} from queue {queue} has failed", consumerTag, queue.Name ); return(StartConsumingStatus.Failed); } }
public void Publish(IntegrationEvent @event) { if (!_connection.IsConnected) { if (!_connection.Connect()) { _logger.LogWarning($"Couldn't publish event {@event.Id}. No available connection was found."); return; } } using (var ch = _connection.CreateModel()) { DeclareExchange(ch); var msg = JsonSerializer.SerializeToUtf8Bytes(@event, @event.GetType()); ch.BasicPublish(_exchangeName, routingKey: _subscriptionManager.GetEventKey(@event.GetType()), body: msg); } }
private void SubsManager_OnEventRemoved(object sender, string eventName) { if (!_persistentConnection.IsConnected) { _persistentConnection.TryConnect(); } using (var channel = _persistentConnection.CreateModel()) { channel.QueueUnbind(queue: _queueName, exchange: BROKER_NAME, routingKey: eventName); if (_subscriptionsManager.IsEmpty) { _queueName = string.Empty; _consumerChannel.Close(); } } }
public virtual void Subscribe(IQueue queue, Func <Byte[], MessageProperties, MessageReceivedInfo, Task> onMessage) { if (queue == null) { throw new ArgumentNullException("queue"); } if (onMessage == null) { throw new ArgumentNullException("onMessage"); } if (disposed) { throw new EasyNetQException("This bus has been disposed"); } var subscriptionAction = new SubscriptionAction(queue.IsSingleUse); subscriptionAction.Action = () => { var channel = connection.CreateModel(); channel.ModelShutdown += (model, reason) => logger.DebugWrite("Model Shutdown for queue: '{0}'", queue.Name); queue.Visit(new TopologyBuilder(channel)); channel.BasicQos(0, connectionConfiguration.PrefetchCount, false); var consumer = consumerFactory.CreateConsumer(subscriptionAction, channel, queue.IsSingleUse, (consumerTag, deliveryTag, redelivered, exchange, routingKey, properties, body) => { var messageRecievedInfo = new MessageReceivedInfo { ConsumerTag = consumerTag, DeliverTag = deliveryTag, Redelivered = redelivered, Exchange = exchange, RoutingKey = routingKey }; var messsageProperties = new MessageProperties(properties); return(onMessage(body, messsageProperties, messageRecievedInfo)); }); channel.BasicConsume( queue.Name, // queue NoAck, // noAck consumer.ConsumerTag, // consumerTag consumer); // consumer logger.DebugWrite("Declared Consumer. queue='{0}', prefetchcount={1}", queue.Name, connectionConfiguration.PrefetchCount); }; AddSubscriptionAction(subscriptionAction); }
public StartConsumingStatus StartConsuming( IPersistentConnection connection, IQueue queue, Func <byte[], MessageProperties, MessageReceivedInfo, Task> onMessage, IConsumerConfiguration configuration ) { Preconditions.CheckNotNull(connection, "connection"); Preconditions.CheckNotNull(queue, "queue"); Preconditions.CheckNotNull(onMessage, "onMessage"); Preconditions.CheckNotNull(configuration, "configuration"); var consumerTag = conventions.ConsumerTagConvention(); IDictionary <string, object> arguments = new Dictionary <string, object> { { "x-priority", configuration.Priority }, { "x-cancel-on-ha-failover", configuration.CancelOnHaFailover || connectionConfiguration.CancelOnHaFailover } }; try { Model = connection.CreateModel(); var basicConsumers = new BasicConsumer(SingleBasicConsumerCancelled, consumerDispatcher, queue, eventBus, handlerRunner, onMessage, logger, Model); this.basicConsumers = new[] { new BasicConsumer(SingleBasicConsumerCancelled, consumerDispatcher, queue, eventBus, handlerRunner, onMessage, logger, Model) }; Model.BasicQos(0, configuration.PrefetchCount, false); //// if configured, re-establish the consumer on a ConsumerCancelled event. //if (queue.IsConsumerRepairable) // ConsumerCancelled += (sender, args) => ConsumerReConnect(sender, consumerTag, configuration.IsExclusive, arguments,queue); Model.BasicConsume( queue.Name, // queue false, // noAck consumerTag, // consumerTag true, configuration.IsExclusive, arguments, // arguments basicConsumers); // consumer logger.InfoWrite("Declared Consumer. queue='{0}', consumer tag='{1}' prefetchcount={2} priority={3} x-cancel-on-ha-failover={4}", queue.Name, consumerTag, configuration.PrefetchCount, configuration.Priority, configuration.CancelOnHaFailover); } catch (Exception exception) { logger.ErrorWrite("Consume failed. queue='{0}', consumer tag='{1}', message='{2}'", queue.Name, consumerTag, exception.Message); return(StartConsumingStatus.Failed); } return(StartConsumingStatus.Succeed); }
public void Publish(EventBase @event) { if (!_persistentConnection.IsConnected) { _persistentConnection.TryConnect(); } var model = JsonConvert.SerializeObject(@event); using (var channel = _persistentConnection.CreateModel()) { channel.ExchangeDeclare(_exchangeName, ExchangeType.Fanout); var body = Encoding.UTF8.GetBytes(model); channel.BasicPublish(_exchangeName, routingKey: @event.GetType().Name, basicProperties: null, body: body); _logger.LogDebug("[x] Sent {0}", model); } }
private void InitModel(ushort prefetchCount, bool globalQos) { if (Model == null) { lock (modelLock) { if (Model == null) { Model = connection.CreateModel(); Model.BasicQos(0, prefetchCount, globalQos); } } } }
public When_a_channel_action_is_invoked() { persistentConnection = Substitute.For <IPersistentConnection>(); channel = Substitute.For <IModel>(); var configuration = new ConnectionConfiguration(); eventBus = Substitute.For <IEventBus>(); persistentConnection.CreateModel().Returns(channel); persistentChannel = new PersistentChannel(persistentConnection, configuration, eventBus); persistentChannel.InvokeChannelAction(x => x.ExchangeDeclare("MyExchange", "direct")); }
public void Publish(IEvent @event) { if (!_persistentConnection.IsConnected) { _persistentConnection.TryConnect(); } var policy = RetryPolicy.Handle <BrokerUnreachableException>() .Or <SocketException>() .WaitAndRetry(_retryCount, retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)), (ex, time) => { _logger.LogWarning(ex.ToString()); }); using (var channel = _persistentConnection.CreateModel()) { var eventName = @event.GetType().Name; channel.ExchangeDeclare(exchange: BROKER_NAME, type: "direct"); var message = JsonConvert.SerializeObject(@event); var body = Encoding.UTF8.GetBytes(message); policy.Execute(() => { var properties = channel.CreateBasicProperties(); properties.DeliveryMode = 2; // persistent channel.BasicPublish(exchange: BROKER_NAME, routingKey: eventName, mandatory: true, basicProperties: properties, body: body); }); } }
public StartConsumingStatus StartConsuming( IPersistentConnection connection, IQueue queue, Func <byte[], MessageProperties, MessageReceivedInfo, Task> onMessage, IConsumerConfiguration configuration ) { Preconditions.CheckNotNull(connection, "connection"); Preconditions.CheckNotNull(queue, "queue"); Preconditions.CheckNotNull(onMessage, "onMessage"); Preconditions.CheckNotNull(configuration, "configuration"); this.queue = queue; this.onMessage = onMessage; this.configuration = configuration; var consumerTag = conventions.ConsumerTagConvention(); IDictionary <string, object> arguments = new Dictionary <string, object> { { "x-priority", configuration.Priority }, { "x-cancel-on-ha-failover", configuration.CancelOnHaFailover || connectionConfiguration.CancelOnHaFailover } }; try { Model = connection.CreateModel(); Model.BasicQos(0, configuration.PrefetchCount, false); Model.BasicConsume( queue.Name, // queue false, // noAck consumerTag, // consumerTag true, configuration.IsExclusive, arguments, // arguments this); // consumer logger.InfoWrite("Declared Consumer. queue='{0}', consumer tag='{1}' prefetchcount={2} priority={3} x-cancel-on-ha-failover={4}", queue.Name, consumerTag, configuration.PrefetchCount, configuration.Priority, configuration.CancelOnHaFailover); } catch (Exception exception) { logger.ErrorWrite("Consume failed. queue='{0}', consumer tag='{1}', message='{2}'", queue.Name, consumerTag, exception.Message); return(StartConsumingStatus.Failed); } return(StartConsumingStatus.Succeed); }
// ---------------------------------- Exchange / Queue / Binding ----------------------------------- public IQueue QueueDeclare( string name, bool passive = false, bool durable = true, bool exclusive = false, bool autoDelete = false, uint perQueueTtl = UInt32.MaxValue, uint expires = UInt32.MaxValue) { Preconditions.CheckNotNull(name, "name"); using (var model = connection.CreateModel()) { IDictionary <string, object> arguments = new Dictionary <string, object>(); if (passive) { model.QueueDeclarePassive(name); } else { if (perQueueTtl != uint.MaxValue) { arguments.Add("x-message-ttl", perQueueTtl); } if (expires != uint.MaxValue) { arguments.Add("x-expires", expires); } model.QueueDeclare(name, durable, exclusive, autoDelete, (IDictionary)arguments); logger.DebugWrite("Declared Queue: '{0}' durable:{1}, exclusive:{2}, autoDelte:{3}, args:{4}", name, durable, exclusive, autoDelete, WriteArguments(arguments)); } return(new Topology.Queue(name, exclusive)); } }
public StartConsumingStatus StartConsuming( IPersistentConnection connection, IQueue queue, Func<byte[], MessageProperties, MessageReceivedInfo, Task> onMessage, IConsumerConfiguration configuration ) { Preconditions.CheckNotNull(connection, "connection"); Preconditions.CheckNotNull(queue, "queue"); Preconditions.CheckNotNull(onMessage, "onMessage"); Preconditions.CheckNotNull(configuration, "configuration"); this.queue = queue; this.onMessage = onMessage; var consumerTag = conventions.ConsumerTagConvention(); IDictionary<string, object> arguments = new Dictionary<string, object> { {"x-priority", configuration.Priority}, {"x-cancel-on-ha-failover", configuration.CancelOnHaFailover || connectionConfiguration.CancelOnHaFailover} }; try { Model = connection.CreateModel(); Model.BasicQos(0, configuration.PrefetchCount, false); Model.BasicConsume( queue.Name, // queue false, // noAck consumerTag, // consumerTag true, configuration.IsExclusive, arguments, // arguments this); // consumer logger.InfoWrite("Declared Consumer. queue='{0}', consumer tag='{1}' prefetchcount={2} priority={3} x-cancel-on-ha-failover={4}", queue.Name, consumerTag, configuration.PrefetchCount, configuration.Priority, configuration.CancelOnHaFailover); } catch (Exception exception) { logger.ErrorWrite("Consume failed. queue='{0}', consumer tag='{1}', message='{2}'", queue.Name, consumerTag, exception.Message); return StartConsumingStatus.Failed; } return StartConsumingStatus.Succeed; }
public void Publish(Event @event) { var eventName = @event.GetType().Name; var jsonMessage = JsonConvert.SerializeObject(@event); var body = Encoding.UTF8.GetBytes(jsonMessage); var message = new Message { MessageId = Guid.NewGuid().ToString(), Body = body, Label = eventName, }; var topicClient = _persistentConnection.CreateModel(); _logger.LogInformation($"Sending message to {topicClient.TopicName} topic"); topicClient.SendAsync(message) .GetAwaiter() .GetResult(); }
private IModel OpenChannel() { IModel channel; lock (this) { if (internalChannel != null) { return(internalChannel); } channel = connection.CreateModel(); WireUpChannelEvents(channel); eventBus.Publish(new PublishChannelCreatedEvent(channel)); internalChannel = channel; } logger.Debug("Persistent channel connected"); return(channel); }
private IModel CreateBasicChannel() { if (!_persistentConnection.IsConnected) { _persistentConnection.TryConnect(); } var channel = _persistentConnection.CreateModel(); channel.ExchangeDeclare( Settings.ExchangeName, Settings.ExchangeType, true, false, Settings.WithDelay ? new Dictionary <string, object> { { "x-delayed-type", "direct" } } : null ); return(channel); }
public void RawPublish(string exchangeName, string topic, string typeName, byte[] messageBody, byte priority) { if (!connection.IsConnected) { throw new EasyNetQException("Publish failed. No rabbit server connected."); } try { if (!threadLocalPublishChannel.IsValueCreated) { threadLocalPublishChannel.Value = connection.CreateModel(); modelList.Add(threadLocalPublishChannel.Value); } DeclarePublishExchange(threadLocalPublishChannel.Value, exchangeName); var defaultProperties = threadLocalPublishChannel.Value.CreateBasicProperties(); defaultProperties.SetPersistent(false); defaultProperties.Type = typeName; defaultProperties.CorrelationId = getCorrelationId(); defaultProperties.Priority = priority; threadLocalPublishChannel.Value.BasicPublish( exchangeName, // exchange topic, // routingKey defaultProperties, // basicProperties messageBody); // body logger.DebugWrite("Published {0}, CorrelationId {1}", exchangeName, defaultProperties.CorrelationId); } catch (OperationInterruptedException exception) { throw new EasyNetQException("Publish Failed: '{0}'", exception.Message); } catch (System.IO.IOException exception) { throw new EasyNetQException("Publish Failed: '{0}'", exception.Message); } }
public StartConsumingStatus StartConsuming(IPersistentConnection connection, ICollection <Tuple <IQueue, Func <byte[], MessageProperties, MessageReceivedInfo, Task> > > queueConsumerPairs, IConsumerConfiguration configuration) { Preconditions.CheckNotNull(connection, nameof(connection)); Preconditions.CheckNotNull(queueConsumerPairs, nameof(queueConsumerPairs)); Preconditions.CheckNotNull(configuration, nameof(configuration)); IDictionary <string, object> arguments = new Dictionary <string, object> { { "x-priority", configuration.Priority } }; try { Model = connection.CreateModel(); Model.BasicQos(0, configuration.PrefetchCount, true); basicConsumers = new List <BasicConsumer>(); foreach (var p in queueConsumerPairs) { var queue = p.Item1; var onMessage = p.Item2; var consumerTag = conventions.ConsumerTagConvention(); try { var basicConsumer = new BasicConsumer(SingleBasicConsumerCancelled, consumerDispatcher, queue, eventBus, handlerRunner, onMessage, Model); Model.BasicConsume( queue.Name, // queue false, // noAck consumerTag, // consumerTag true, configuration.IsExclusive, arguments, // arguments basicConsumer // consumer ); basicConsumers.Add(basicConsumer); logger.InfoFormat( "Declared consumer with consumerTag {consumerTag} on queue={queue} and configuration {configuration}", queue.Name, consumerTag, configuration ); } catch (Exception exception) { logger.Error( exception, "Consume with consumerTag {consumerTag} on queue {queue} failed", queue.Name, consumerTag ); return(StartConsumingStatus.Failed); } } return(StartConsumingStatus.Succeed); } catch (Exception exception) { logger.Error( exception, "Consume on queue {queue} failed", string.Join(";", queueConsumerPairs.Select(x => x.Item1.Name)) ); return(StartConsumingStatus.Failed); } }
public void StartConsuming( IPersistentConnection connection, IQueue queue, Func<byte[], MessageProperties, MessageReceivedInfo, Task> onMessage, IConsumerConfiguration configuration ) { Preconditions.CheckNotNull(connection, "connection"); Preconditions.CheckNotNull(queue, "queue"); Preconditions.CheckNotNull(onMessage, "onMessage"); Preconditions.CheckNotNull(configuration, "configuration"); this.queue = queue; this.onMessage = onMessage; var consumerTag = conventions.ConsumerTagConvention(); IDictionary<string, object> arguments = new Dictionary<string, object> { {"x-priority", configuration.Priority} }; try { Model = connection.CreateModel(); Model.BasicQos(0, connectionConfiguration.PrefetchCount, false); Model.BasicConsume( queue.Name, // queue false, // noAck consumerTag, // consumerTag arguments, // arguments this); // consumer logger.InfoWrite("Declared Consumer. queue='{0}', consumer tag='{1}' prefetchcount={2} priority={3}", queue.Name, consumerTag, connectionConfiguration.PrefetchCount, configuration.Priority); } catch (Exception exception) { logger.InfoWrite("Consume failed. queue='{0}', consumer tag='{1}', message='{2}'", queue.Name, consumerTag, exception.Message); } }
/// <inheritdoc /> public virtual AckStrategy HandleConsumerError(ConsumerExecutionContext context, Exception exception) { Preconditions.CheckNotNull(context, "context"); Preconditions.CheckNotNull(exception, "exception"); if (disposed || disposing) { logger.ErrorFormat( "ErrorStrategy was already disposed, when attempting to handle consumer error. Error message will not be published and message with receivedInfo={receivedInfo} will be requeued", context.ReceivedInfo ); return(AckStrategies.NackWithRequeue); } logger.Error( exception, "Exception thrown by subscription callback, receivedInfo={receivedInfo}, properties={properties}, message={message}", context.ReceivedInfo, context.Properties, Convert.ToBase64String(context.Body) ); try { using var model = connection.CreateModel(); if (configuration.PublisherConfirms) { model.ConfirmSelect(); } var errorExchange = DeclareErrorExchangeWithQueue(model, context); var messageBody = CreateErrorMessage(context, exception); var properties = model.CreateBasicProperties(); properties.Persistent = true; properties.Type = typeNameSerializer.Serialize(typeof(Error)); model.BasicPublish(errorExchange, context.ReceivedInfo.RoutingKey, properties, messageBody); if (!configuration.PublisherConfirms) { return(AckStrategies.Ack); } return(model.WaitForConfirms(configuration.Timeout) ? AckStrategies.Ack : AckStrategies.NackWithRequeue); } catch (BrokerUnreachableException unreachableException) { // thrown if the broker is unreachable during initial creation. logger.Error( unreachableException, "Cannot connect to broker while attempting to publish error message" ); } catch (OperationInterruptedException interruptedException) { // thrown if the broker connection is broken during declare or publish. logger.Error( interruptedException, "Broker connection was closed while attempting to publish error message" ); } catch (Exception unexpectedException) { // Something else unexpected has gone wrong :( logger.Error(unexpectedException, "Failed to publish error message"); } return(AckStrategies.NackWithRequeue); }