bool CheckQueueExistence(FullyQualifiedRoutingKey routingKey, IModel model)
{
var queueName = routingKey.RoutingKey;
try
{
// Checks if queue exists, throws if the queue doesn't exist
model.QueueDeclarePassive(queueName);
}
catch (Exception e)
{
throw new RebusApplicationException(e, $"Queue '{queueName}' does not exist");
}
var exchange = routingKey.ExchangeName ?? _directExchangeName;
try
{
model.ExchangeDeclarePassive(exchange);
}
catch (Exception e)
{
throw new RebusApplicationException(e, $"Exchange '{exchange}' does not exist");
}
// since we can't check whether a binding exists, we need
// to proactively declare it, so we don't risk sending a message
// "into the void":
model.QueueBind(queueName, exchange, routingKey.RoutingKey);
return(true);
}
async Task SendOutgoingMessages(ITransactionContext context, ConcurrentQueue <OutgoingMessage> outgoingMessages)
{
var model = GetModel(context);
foreach (var outgoingMessage in outgoingMessages)
{
var destinationAddress = outgoingMessage.DestinationAddress;
var message = outgoingMessage.TransportMessage;
var props = CreateBasicProperties(model, message.Headers);
var mandatory = message.Headers.ContainsKey(RabbitMqHeaders.Mandatory);
if (mandatory && !_callbackOptions.HasMandatoryCallback)
{
throw new MandatoryDeliveryException("Mandatory delivery is not allowed without registrering a handler for BasicReturn in RabbitMqOptions.");
}
var routingKey = new FullyQualifiedRoutingKey(destinationAddress);
var exchange = routingKey.ExchangeName ?? _directExchangeName;
// when we're sending point-to-point, we want to be sure that we are never sending the message out into nowhere
if (exchange == _directExchangeName && !_callbackOptions.HasMandatoryCallback)
{
try
{
EnsureQueueExists(destinationAddress, model);
}
catch (Exception e)
{
throw new RebusApplicationException(e, $"Queue '{destinationAddress}' does not exists.");
}
}
model.BasicPublish(exchange, routingKey.RoutingKey, mandatory, props, message.Body);
}
}
async Task SendOutgoingMessages(ITransactionContext context, ConcurrentQueue <OutgoingMessage> outgoingMessages)
{
var model = GetModel(context);
foreach (var outgoingMessage in outgoingMessages)
{
var destinationAddress = outgoingMessage.DestinationAddress;
var message = outgoingMessage.TransportMessage;
var props = model.CreateBasicProperties();
var headers = message.Headers;
var timeToBeDelivered = GetTimeToBeReceivedOrNull(message);
props.Headers = headers
.ToDictionary(kvp => kvp.Key, kvp => (object)HeaderValueEncoding.GetBytes(kvp.Value));
if (timeToBeDelivered.HasValue)
{
props.Expiration = timeToBeDelivered.Value.TotalMilliseconds.ToString("0");
}
var express = headers.ContainsKey(Headers.Express);
props.Persistent = !express;
var routingKey = new FullyQualifiedRoutingKey(destinationAddress);
model.BasicPublish(routingKey.ExchangeName, routingKey.RoutingKey, props, message.Body);
}
}
public void CanDetermineEquality()
{
const string destinationAddress = "wherever@whatever";
var routingKey1 = new FullyQualifiedRoutingKey(destinationAddress);
var routingKey2 = new FullyQualifiedRoutingKey(destinationAddress);
Assert.That(routingKey1, Is.EqualTo(routingKey2));
}
async Task SendOutgoingMessages(ITransactionContext context, ConcurrentQueue <OutgoingMessage> outgoingMessages)
{
var model = GetModel(context);
if (_publisherConfirmsEnabled)
{
model.ConfirmSelect();
}
foreach (var outgoingMessage in outgoingMessages)
{
var destinationAddress = outgoingMessage.DestinationAddress;
var message = outgoingMessage.TransportMessage;
var props = CreateBasicProperties(model, message.Headers);
var mandatory = message.Headers.ContainsKey(RabbitMqHeaders.Mandatory);
if (mandatory && !_callbackOptions.HasMandatoryCallback)
{
throw new MandatoryDeliveryException("Mandatory delivery is not allowed without registering a handler for BasicReturn in RabbitMqOptions.");
}
var routingKey = new FullyQualifiedRoutingKey(destinationAddress);
var exchange = routingKey.ExchangeName ?? _directExchangeName;
var isPointToPoint = message.Headers.TryGetValue(Headers.Intent, out var intent) &&
intent == Headers.IntentOptions.PointToPoint;
// when we're sending point-to-point, we want to be sure that we are never sending the message out into nowhere
if (isPointToPoint && !_callbackOptions.HasMandatoryCallback)
{
EnsureQueueExists(routingKey, model);
}
model.BasicPublish(
exchange: exchange,
routingKey: routingKey.RoutingKey,
mandatory: mandatory,
basicProperties: props,
body: message.Body
);
}
if (_publisherConfirmsEnabled)
{
model.WaitForConfirmsOrDie();
}
}
async Task SendOutgoingMessages(ITransactionContext context, ConcurrentQueue <OutgoingMessage> outgoingMessages)
{
var model = GetModel(context);
foreach (var outgoingMessage in outgoingMessages)
{
var destinationAddress = outgoingMessage.DestinationAddress;
var message = outgoingMessage.TransportMessage;
var props = model.CreateBasicProperties();
var headers = message.Headers;
var timeToBeDelivered = GetTimeToBeReceivedOrNull(message);
props.Headers = headers
.ToDictionary(kvp => kvp.Key, kvp => (object)HeaderValueEncoding.GetBytes(kvp.Value));
if (timeToBeDelivered.HasValue)
{
props.Expiration = timeToBeDelivered.Value.TotalMilliseconds.ToString("0");
}
var express = headers.ContainsKey(Headers.Express);
props.Persistent = !express;
var routingKey = new FullyQualifiedRoutingKey(destinationAddress);
var exchange = routingKey.ExchangeName ?? _directExchangeName;
// when we're sending point-to-point, we want to be sure that we are never sending the message out into nowhere
if (exchange == _directExchangeName)
{
EnsureQueueIsInitialized(destinationAddress, model);
}
model.BasicPublish(exchange, routingKey.RoutingKey, props, message.Body);
}
}
void EnsureQueueExists(FullyQualifiedRoutingKey routingKey, IModel model)
{
_verifiedQueues
.GetOrAdd(routingKey, _ => CheckQueueExistence(routingKey, model));
}
async Task SendOutgoingMessages(ITransactionContext context, ConcurrentQueue<OutgoingMessage> outgoingMessages)
{
var model = GetModel(context);
foreach (var outgoingMessage in outgoingMessages)
{
var destinationAddress = outgoingMessage.DestinationAddress;
var message = outgoingMessage.TransportMessage;
var props = model.CreateBasicProperties();
var headers = message.Headers;
var timeToBeDelivered = GetTimeToBeReceivedOrNull(message);
props.Headers = headers
.ToDictionary(kvp => kvp.Key, kvp => (object)HeaderValueEncoding.GetBytes(kvp.Value));
if (timeToBeDelivered.HasValue)
{
props.Expiration = timeToBeDelivered.Value.TotalMilliseconds.ToString("0");
}
var express = headers.ContainsKey(Headers.Express);
props.Persistent = !express;
var routingKey = new FullyQualifiedRoutingKey(destinationAddress);
var exchange = routingKey.ExchangeName ?? _directExchangeName;
// when we're sending point-to-point, we want to be sure that we are never sending the message out into nowhere
if (exchange == _directExchangeName)
{
EnsureQueueIsInitialized(destinationAddress, model);
}
model.BasicPublish(exchange, routingKey.RoutingKey, props, message.Body);
}
}
async Task SendOutgoingMessages(ITransactionContext context, ConcurrentQueue<OutgoingMessage> outgoingMessages)
{
var model = GetModel(context);
foreach (var outgoingMessage in outgoingMessages)
{
var destinationAddress = outgoingMessage.DestinationAddress;
var message = outgoingMessage.TransportMessage;
var props = model.CreateBasicProperties();
var headers = message.Headers;
var timeToBeDelivered = GetTimeToBeReceivedOrNull(message);
props.Headers = headers
.ToDictionary(kvp => kvp.Key, kvp => (object)HeaderValueEncoding.GetBytes(kvp.Value));
if (timeToBeDelivered.HasValue)
{
props.Expiration = timeToBeDelivered.Value.TotalMilliseconds.ToString("0");
}
var express = headers.ContainsKey(Headers.Express);
props.Persistent = !express;
var routingKey = new FullyQualifiedRoutingKey(destinationAddress);
model.BasicPublish(routingKey.ExchangeName, routingKey.RoutingKey, props, message.Body);
}
}