public void Append(IBasicPublishBatch batch, ulong publishTag)
{
batch.Add(_exchange, _routingKey, false, _properties, _body);
_body = null;
PublishTag = publishTag;
}
public async Task <SendQueueResult> SendToQueueBatch(QueueName queueName, List <ReadOnlyMemory <byte> > dataList)
{
try
{
var connection = await GetConnection();
using (var rabbitMQChannel = connection.CreateModel())
{
var queueResult = rabbitMQChannel.QueueDeclare(queue: queueName.ToString(), durable: true, exclusive: false, autoDelete: false, arguments: null);
IBasicPublishBatch publishBatch = rabbitMQChannel.CreateBasicPublishBatch();
foreach (var data in dataList)
{
publishBatch.Add(exchange: "", routingKey: queueName.ToString(), mandatory: true, null, body: data);
}
publishBatch.Publish();
}
return(new SendQueueResult {
IsSuccess = true, ErrorMessage = ""
});
}
catch (Exception ex)
{
return(new SendQueueResult {
IsSuccess = false, ErrorMessage = ex.Message
});
}
}
public RabbitMQService(string connectionString, string hostName, string queueName, string userName, string password, int port, string deadLetterExchangeName)
: this(connectionString, hostName, userName, password, port)
{
_rabbitMQModel = new RabbitMQModel(_model);
_deadLetterExchangeName = deadLetterExchangeName;
_queueName = queueName ?? throw new ArgumentNullException(nameof(queueName));
Dictionary <string, object> args = new Dictionary <string, object>();
// Create dead letter queue
if (!string.IsNullOrEmpty(_deadLetterExchangeName))
{
string deadLetterQueueName = string.Format("{0}-poison", _queueName);
_model.QueueDeclare(queue: deadLetterQueueName, durable: false, exclusive: false, autoDelete: false, arguments: null);
_model.ExchangeDeclare(_deadLetterExchangeName, Constants.DefaultDLXSetting);
_model.QueueBind(deadLetterQueueName, _deadLetterExchangeName, Constants.DeadLetterRoutingKeyValue, null);
args[Constants.DeadLetterExchangeKey] = _deadLetterExchangeName;
args[Constants.DeadLetterRoutingKey] = Constants.DeadLetterRoutingKeyValue;
}
_model.QueueDeclare(queue: _queueName, durable: false, exclusive: false, autoDelete: false, arguments: args);
_batch = _model.CreateBasicPublishBatch();
}
public RabbitMQService(string connectionString, string hostName, string queueName, string userName, string password, int port)
: this(connectionString, hostName, userName, password, port)
{
_rabbitMQModel = new RabbitMQModel(_model);
_queueName = queueName ?? throw new ArgumentNullException(nameof(queueName));
_model.QueueDeclarePassive(_queueName); // Throws exception if queue doesn't exist
_batch = _model.CreateBasicPublishBatch();
}
public RabbitMQAsyncCollector(RabbitMQContext context, ILogger logger)
{
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_context = context ?? throw new ArgumentNullException(nameof(context));
if (_context.Service == null)
{
throw new ArgumentNullException("context.service");
}
_batch = _context.Service.GetBatch();
}
public static void Add(this IBasicPublishBatch batch, string exchange, string routingKey, bool mandatory, IBasicProperties properties, ReadOnlyMemory <byte> body)
{
if (batch is BasicPublishBatch batchInternal)
{
batchInternal.Add(exchange, routingKey, mandatory, properties, body);
return;
}
#pragma warning disable 618
batch.Add(exchange, routingKey, mandatory, properties, body.ToArray());
#pragma warning restore 618
}
public RabbitMQService(string hostName, string queueName)
{
_hostName = hostName ?? throw new ArgumentNullException(nameof(hostName));
_queueName = queueName ?? throw new ArgumentNullException(nameof(queueName));
ConnectionFactory connectionFactory = new ConnectionFactory()
{
HostName = _hostName
};
_channel = connectionFactory.CreateConnection().CreateModel();
_channel.QueueDeclare(queue: _queueName, durable: false, exclusive: false, autoDelete: false, arguments: null);
_batch = _channel.CreateBasicPublishBatch();
}
public RabbitMQService(string connectionString, string hostName, string queueName, string userName, string password, int port)
{
_connectionString = connectionString;
_hostName = hostName;
_queueName = queueName ?? throw new ArgumentNullException(nameof(queueName));
_userName = userName;
_password = password;
_port = port;
ConnectionFactory connectionFactory = GetConnectionFactory(_connectionString, _hostName, _userName, _password, _port);
_model = connectionFactory.CreateConnection().CreateModel();
_model.QueueDeclare(queue: _queueName, durable: false, exclusive: false, autoDelete: false, arguments: null);
_batch = _model.CreateBasicPublishBatch();
}
public (ITargetBlock <MessageItem> writer, IDataflowBlock finalBlock) GetWriter(ISource acknowledgeSource)
{
BatchBlock <MessageItem> batcher = new BatchBlock <MessageItem>(_model.BatchSize);
ActionBlock <MessageItem[]> writer = new ActionBlock <MessageItem[]>(items =>
{
IBasicPublishBatch batch = _channel.CreateBasicPublishBatch();
foreach (MessageItem item in items)
{
string exchange = _model.Exchange ?? item.Exchange;
string routingKey = _model.RoutingKey ?? item.RoutingKey;
BasicProperties basicProperties = new BasicProperties
{
Headers = new Dictionary <string, object>(),
Persistent = item.Persistent
};
if (item.Created.HasValue)
{
basicProperties.Timestamp = new AmqpTimestamp(((DateTimeOffset)item.Created).ToUnixTimeSeconds());
}
if (item.Properties != null)
{
foreach ((string key, object value) in item.Properties)
{
basicProperties.Headers.Add(key, value);
}
}
batch.Add(exchange, routingKey, true, basicProperties, item.Data);
}
_logger.LogDebug("Writing {Count} messages to AMQP", items.Length);
batch.Publish();
acknowledgeSource.Acknowledge(items);
});
batcher.LinkTo(writer, new DataflowLinkOptions
{
PropagateCompletion = true
});
return(batcher, writer);
}
/// <summary>
/// Sends many messages to the broker.
/// </summary>
/// <param name="messages">The messages.</param>
/// <returns></returns>
public Task SendAsync(IEnumerable <OutboundMessage> messages)
{
// get message array
OutboundMessage[] messageArr = messages.ToArray();
if (messageArr.Length == 0)
{
return(Task.FromResult(true));
}
else if (messageArr.Length == 1)
{
return(SendAsync(messageArr[0]));
}
else
{
// create batch
IBasicPublishBatch batch = _channel.CreateBasicPublishBatch();
// add all the messages
foreach (OutboundMessage message in messageArr)
{
IBasicProperties properties = _channel.CreateBasicProperties();
if (message.ReplyTo != null)
{
properties.ReplyTo = message.ReplyTo;
}
if (message.Headers != null)
{
properties.Headers = message.Headers;
}
if (message.ReplyID != null)
{
properties.CorrelationId = message.ReplyID.ToString();
}
batch.Add(message.Exchange, message.RoutingKey, message.Mandatory, properties, message.Body);
}
return(_ctx.AskWork(delegate() {
batch.Publish();
return null;
}));
}
}
public void TestBasicPublishBatchSend()
{
Model.ConfirmSelect();
Model.QueueDeclare(queue: "test-message-batch-a", durable: false);
Model.QueueDeclare(queue: "test-message-batch-b", durable: false);
IBasicPublishBatch batch = Model.CreateBasicPublishBatch();
batch.Add("", "test-message-batch-a", false, null, new ReadOnlyMemory <byte>());
batch.Add("", "test-message-batch-b", false, null, new ReadOnlyMemory <byte>());
batch.Publish();
Model.WaitForConfirmsOrDie(TimeSpan.FromSeconds(15));
BasicGetResult resultA = Model.BasicGet("test-message-batch-a", true);
Assert.NotNull(resultA);
BasicGetResult resultB = Model.BasicGet("test-message-batch-b", true);
Assert.NotNull(resultB);
}
public void TestBasicPublishBatchSendWithWrongSizeHint()
{
_model.ConfirmSelect();
_model.QueueDeclare(queue: "test-message-batch-a", durable: false);
_model.QueueDeclare(queue: "test-message-batch-b", durable: false);
IBasicPublishBatch batch = _model.CreateBasicPublishBatch(1);
ReadOnlyMemory <byte> bodyAsMemory = new byte [] {};
batch.Add("", "test-message-batch-a", false, null, bodyAsMemory);
batch.Add("", "test-message-batch-b", false, null, bodyAsMemory);
batch.Publish();
_model.WaitForConfirmsOrDie(TimeSpan.FromSeconds(15));
BasicGetResult resultA = _model.BasicGet("test-message-batch-a", true);
Assert.NotNull(resultA);
BasicGetResult resultB = _model.BasicGet("test-message-batch-b", true);
Assert.NotNull(resultB);
}
public async Task TestBasicPublishBatchSend()
{
_model.ConfirmSelect();
_model.QueueDeclare(queue: "test-message-batch-a", durable: false);
_model.QueueDeclare(queue: "test-message-batch-b", durable: false);
IBasicPublishBatch batch = _model.CreateBasicPublishBatch();
batch.Add("", "test-message-batch-a", false, null, new ReadOnlyMemory <byte>());
batch.Add("", "test-message-batch-b", false, null, new ReadOnlyMemory <byte>());
batch.Publish();
using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(15));
await _model.WaitForConfirmsOrDieAsync(cts.Token).ConfigureAwait(false);
BasicGetResult resultA = _model.BasicGet("test-message-batch-a", true);
Assert.NotNull(resultA);
BasicGetResult resultB = _model.BasicGet("test-message-batch-b", true);
Assert.NotNull(resultB);
}
internal static bool Add(this IBasicPublishBatch batch, IModel model, IPublisherMessage publisherMessage)
{
if (publisherMessage.CancellationToken.IsCancellationRequested)
{
return(false);
}
publisherMessage.Routing.Verify(model);
publisherMessage.MarkAsPublished();
var basicProperties = model.CreateBasicProperties();
basicProperties.AddMessageProperties(publisherMessage);
batch.Add(publisherMessage.Routing.ExchangeName, publisherMessage.Routing.RoutingKey, false,
basicProperties,
publisherMessage.Serialize());
return(true);
}
public RabbitMQService(string connectionString, string hostName, string exchangeName, string routingKey, string userName, string password, int port)
: this(connectionString, hostName, userName, password, port)
{
_rabbitMQModel = new RabbitMQModel(_model);
_routingKey = routingKey ?? throw new ArgumentNullException(nameof(routingKey));
_exchangeName = exchangeName ?? throw new ArgumentNullException(nameof(exchangeName));
if (!string.IsNullOrEmpty(_exchangeName))
{
_model.ExchangeDeclarePassive(_exchangeName);
}
else
{
// Should only declare queue if using default exchange
if (!string.IsNullOrEmpty(_routingKey))
{
_model.QueueDeclarePassive(_routingKey);
}
}
_batch = _model.CreateBasicPublishBatch();
}
