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);
}
private IConnection?CreateConnection(RabbitMqServiceOptions options) => _rabbitMqConnectionFactory.CreateRabbitMqConnection(options);
