void ConfigureConnectionInfrastructure(RabbitMqConnectionOptionsContainer optionsContainer) { Connection = _rabbitMqConnectionFactory.CreateRabbitMqConnection(optionsContainer?.Options?.ProducerOptions); if (Connection != null) { Connection.CallbackException += HandleConnectionCallbackException; if (Connection is IAutorecoveringConnection connection) { connection.ConnectionRecoveryError += HandleConnectionRecoveryError; } Channel = Connection.CreateModel(); Channel.CallbackException += HandleChannelCallbackException; Channel.BasicRecoverOk += HandleChannelBasicRecoverOk; } ConsumingConnection = _rabbitMqConnectionFactory.CreateRabbitMqConnection(optionsContainer?.Options?.ConsumerOptions); if (ConsumingConnection != null) { ConsumingConnection.CallbackException += HandleConnectionCallbackException; if (Connection is IAutorecoveringConnection connection) { connection.ConnectionRecoveryError += HandleConnectionRecoveryError; } ConsumingChannel = ConsumingConnection.CreateModel(); ConsumingChannel.CallbackException += HandleChannelCallbackException; ConsumingChannel.BasicRecoverOk += HandleChannelBasicRecoverOk; _consumer = _rabbitMqConnectionFactory.CreateConsumer(ConsumingChannel); } }
public Task StartAsync(CancellationToken cancellationToken) { ValidateProperties(); _logger.LogInformation($"Batch message handler {GetType()} has been started."); Connection = _rabbitMqConnectionFactory.CreateRabbitMqConnection(_clientOptions); Channel = Connection.CreateModel(); Channel.BasicQos(PrefetchSize, PrefetchCount, false); if (MessageHandlingPeriod != null) { _timer = new Timer(async _ => await ProcessBatchOfMessages(cancellationToken).ConfigureAwait(false), null, MessageHandlingPeriod.Value, MessageHandlingPeriod.Value); } var consumer = _rabbitMqConnectionFactory.CreateConsumer(Channel); consumer.Received += async(sender, eventArgs) => { lock (_lock) { _messages.Add(eventArgs); if (_messages.Count < PrefetchCount) { return; } } await ProcessBatchOfMessages(cancellationToken).ConfigureAwait(false); }; Channel.BasicConsume(queue: QueueName, autoAck: false, consumer: consumer); return(Task.CompletedTask); }
public Task StartAsync(CancellationToken cancellationToken) { ValidateProperties(); _logger.LogInformation($"Batch message handler {GetType()} has been started."); Connection = _rabbitMqConnectionFactory.CreateRabbitMqConnection(_clientOptions); Channel = Connection.CreateModel(); Channel.BasicQos(PrefetchSize, PrefetchCount, false); var messages = new ConcurrentBag <BasicDeliverEventArgs>(); var consumer = _rabbitMqConnectionFactory.CreateConsumer(Channel); consumer.Received += async(sender, eventArgs) => { messages.Add(eventArgs); if (messages.Count < PrefetchCount) { return; } var byteMessages = messages.Select(x => x.Body).ToList(); await HandleMessages(byteMessages, cancellationToken).ConfigureAwait(false); var latestDeliveryTag = messages.Max(x => x.DeliveryTag); messages.Clear(); Channel.BasicAck(latestDeliveryTag, true); }; Channel.BasicConsume(queue: QueueName, autoAck: false, consumer: consumer); return(Task.CompletedTask); }
/// <inheritdoc/> public void SetConnectionInfrastructureForRabbitMqServices() { if (_connectionOptions.ProducerOptions != null) { var connection = CreateConnection(_connectionOptions.ProducerOptions).EnsureIsNotNull(); var channel = CreateChannel(connection); StartClient(channel); _producingService.UseConnection(connection); _producingService.UseChannel(channel); } if (_connectionOptions.ConsumerOptions != null) { var connection = CreateConnection(_connectionOptions.ConsumerOptions).EnsureIsNotNull(); var channel = CreateChannel(connection); StartClient(channel); var consumer = _rabbitMqConnectionFactory.CreateConsumer(channel); _consumingService.UseConnection(connection); _consumingService.UseChannel(channel); _consumingService.UseConsumer(consumer); } }