public Uri GetDestinationAddress(string exchangeName, Action <IExchangeConfigurator> configure = null)
{
var sendSettings = new RabbitMqSendSettings(exchangeName, _exchangeTypeSelector.DefaultExchangeType, true, false);
configure?.Invoke(sendSettings);
return(sendSettings.GetSendAddress(_hostAddress));
}
public Uri GetSendAddress(string exchangeName, Action <IExchangeConfigurator> configure = null)
{
var sendSettings = new RabbitMqSendSettings(exchangeName, ExchangeType.Fanout, true, false);
configure?.Invoke(sendSettings);
return(sendSettings.GetSendAddress(_settings.HostAddress));
}
Uri GetQueueAddress(QueueConfigurator configurator, Uri hostAddress, string suffix)
{
var queueName = configurator.QueueName + suffix;
var sendSettings = new RabbitMqSendSettings(queueName, ExchangeTypeSelector.DefaultExchangeType, configurator.Durable, configurator.AutoDelete);
sendSettings.BindToQueue(queueName);
return(sendSettings.GetSendAddress(hostAddress));
}
public SendSettings GetSendSettings(Uri address)
{
var name = address.AbsolutePath.Substring(1);
string[] pathSegments = name.Split('/');
if (pathSegments.Length == 2)
{
name = pathSegments[1];
}
if (name == "*")
{
throw new ArgumentException("Cannot send to a dynamic address");
}
EntityNameValidator.ThrowIfInvalidEntityName(name);
var isTemporary = address.Query.GetValueFromQueryString("temporary", false);
var durable = address.Query.GetValueFromQueryString("durable", !isTemporary);
var autoDelete = address.Query.GetValueFromQueryString("autodelete", isTemporary);
var exchangeType = address.Query.GetValueFromQueryString("type") ?? ExchangeTypeSelector.DefaultExchangeType;
var settings = new RabbitMqSendSettings(name, exchangeType, durable, autoDelete);
var bindToQueue = address.Query.GetValueFromQueryString("bind", false);
if (bindToQueue)
{
var queueName = WebUtility.UrlDecode(address.Query.GetValueFromQueryString("queue"));
settings.BindToQueue(queueName);
}
var delayedType = address.Query.GetValueFromQueryString("delayedType");
if (!string.IsNullOrWhiteSpace(delayedType))
{
settings.SetExchangeArgument("x-delayed-type", delayedType);
}
var bindExchange = address.Query.GetValueFromQueryString("bindexchange");
if (!string.IsNullOrWhiteSpace(bindExchange))
{
settings.BindToExchange(bindExchange);
}
var alternateExchange = address.Query.GetValueFromQueryString("alternateexchange");
if (!string.IsNullOrWhiteSpace(alternateExchange))
{
settings.SetExchangeArgument("alternate-exchange", alternateExchange);
}
return(settings);
}
/// <summary>
/// Return the send settings for the address
/// </summary>
/// <param name="address"></param>
/// <returns></returns>
public static SendSettings GetSendSettings(this Uri address)
{
if (string.Compare("rabbitmq", address.Scheme, StringComparison.OrdinalIgnoreCase) != 0)
{
throw new RabbitMqAddressException("The invalid scheme was specified: " + address.Scheme);
}
string name = address.AbsolutePath.Substring(1);
string[] pathSegments = name.Split('/');
if (pathSegments.Length == 2)
{
name = pathSegments[1];
}
if (name == "*")
{
throw new ArgumentException("Cannot send to a dynamic address");
}
VerifyQueueOrExchangeNameIsLegal(name);
bool isTemporary = address.Query.GetValueFromQueryString("temporary", false);
bool durable = address.Query.GetValueFromQueryString("durable", !isTemporary);
bool autoDelete = address.Query.GetValueFromQueryString("autodelete", isTemporary);
string exchangeType = address.Query.GetValueFromQueryString("type") ?? ExchangeType.Fanout;
var settings = new RabbitMqSendSettings(name, exchangeType, durable, autoDelete);
bool bindToQueue = address.Query.GetValueFromQueryString("bind", false);
if (bindToQueue)
{
string queueName = WebUtility.UrlDecode(address.Query.GetValueFromQueryString("queue"));
settings.BindToQueue(queueName);
}
string delayedType = address.Query.GetValueFromQueryString("delayedType");
if (!string.IsNullOrWhiteSpace(delayedType))
{
settings.SetExchangeArgument("x-delayed-type", delayedType);
}
string bindExchange = address.Query.GetValueFromQueryString("bindexchange");
if (!string.IsNullOrWhiteSpace(bindExchange))
{
settings.BindToExchange(bindExchange);
}
return(settings);
}
protected override Uri GetErrorAddress()
{
string errorQueueName = _settings.QueueName + "_error";
var sendSettings = new RabbitMqSendSettings(errorQueueName, RabbitMQ.Client.ExchangeType.Fanout, true,
false);
sendSettings.BindToQueue(errorQueueName);
return(_host.Settings.GetSendAddress(sendSettings));
}
protected override Uri GetErrorAddress()
{
var errorQueueName = _settings.QueueName + "_error";
var sendSettings = new RabbitMqSendSettings(errorQueueName, RabbitMQ.Client.ExchangeType.Fanout, _settings.Durable,
_settings.AutoDelete);
sendSettings.BindToQueue(errorQueueName);
return(sendSettings.GetSendAddress(_host.Settings.HostAddress));
}
protected override Uri GetDeadLetterAddress()
{
string errorQueueName = _settings.QueueName + "_skipped";
var sendSettings = new RabbitMqSendSettings(errorQueueName, RabbitMQ.Client.ExchangeType.Fanout, _settings.Durable,
_settings.AutoDelete);
sendSettings.BindToQueue(errorQueueName);
return(_host.Settings.GetSendAddress(sendSettings));
}
public Uri GetDestinationAddress(string exchangeName, Action <IExchangeConfigurator> configure = null)
{
var address = new RabbitMqEndpointAddress(_hostAddress, new Uri($"exchange:{exchangeName}"));
var sendSettings = new RabbitMqSendSettings(address);
configure?.Invoke(sendSettings);
return(sendSettings.GetSendAddress(_hostAddress));
}
public Uri GetDelayedExchangeDestinationAddress(Uri address)
{
var endpointAddress = new RabbitMqEndpointAddress(_hostAddress, address);
var delayedExchangeAddress = endpointAddress.GetDelayAddress();
var settings = new RabbitMqSendSettings(delayedExchangeAddress);
settings.BindToExchange(endpointAddress.Name);
return(settings.GetSendAddress(_hostAddress));
}
public Uri GetDestinationAddress(Type messageType, Action <IExchangeConfigurator> configure = null)
{
var exchangeName = _messageNameFormatter.GetMessageName(messageType).ToString();
var isTemporary = TypeMetadataCache.IsTemporaryMessageType(messageType);
var address = new RabbitMqEndpointAddress(_hostAddress, new Uri($"exchange:{exchangeName}?temporary={isTemporary}"));
var settings = new RabbitMqSendSettings(address);
configure?.Invoke(settings);
return(settings.GetSendAddress(_hostAddress));
}
/// <summary>
/// Return a send address for the exchange
/// </summary>
/// <param name="host">The RabbitMQ host</param>
/// <param name="exchangeName">The exchange name</param>
/// <param name="configure">An optional configuration for the exchange to set type, durable, etc.</param>
/// <returns></returns>
public static Uri GetSendAddress(this IRabbitMqHost host, string exchangeName, Action <IExchangeConfigurator> configure = null)
{
var builder = GetHostUriBuilder(host.Settings, exchangeName);
var sendSettings = new RabbitMqSendSettings(exchangeName, ExchangeType.Fanout, true, false);
configure?.Invoke(sendSettings);
builder.Query += string.Join("&", GetQueryStringOptions(sendSettings));
return(builder.Uri);
}
Uri GetDelayExchangeAddress(ReceiveSettings receiveSettings)
{
string delayExchangeName = receiveSettings.QueueName + "_delay";
var sendSettings = new RabbitMqSendSettings(delayExchangeName, "x-delayed-message", receiveSettings.Durable, receiveSettings.AutoDelete);
sendSettings.SetExchangeArgument("x-delayed-type", receiveSettings.ExchangeType);
sendSettings.BindToQueue(receiveSettings.QueueName);
var modelContext = _context.ReceiveContext.GetPayload <ModelContext>();
return(modelContext.ConnectionContext.HostSettings.GetSendAddress(sendSettings));
}
public static SendSettings GetSendSettings(this IRabbitMqHost host, Type messageType, IMessageNameFormatter messageNameFormatter)
{
bool isTemporary = messageType.IsTemporaryMessageType();
bool durable = !isTemporary;
bool autoDelete = isTemporary;
string name = messageNameFormatter.GetMessageName(messageType).ToString();
SendSettings settings = new RabbitMqSendSettings(name, ExchangeType.Fanout, durable, autoDelete);
return(settings);
}
Task <ISendEndpoint> GetSchedulerEndpoint(Uri destinationAddress)
{
var destinationSettings = _topology.GetSendSettings(destinationAddress);
var sendSettings = new RabbitMqSendSettings(destinationSettings.ExchangeName + "_delay", "x-delayed-message", destinationSettings.Durable,
destinationSettings.AutoDelete);
sendSettings.SetExchangeArgument("x-delayed-type", destinationSettings.ExchangeType);
sendSettings.BindToExchange(destinationSettings.ExchangeName);
var delayExchangeAddress = sendSettings.GetSendAddress(_hostAddress);
return(_sendEndpointProvider.GetSendEndpoint(delayExchangeAddress));
}
public Uri GetDestinationAddress(Type messageType, Action <IExchangeConfigurator> configure = null)
{
var isTemporary = TypeMetadataCache.IsTemporaryMessageType(messageType);
var durable = !isTemporary;
var autoDelete = isTemporary;
var name = _messageNameFormatter.GetMessageName(messageType).ToString();
var settings = new RabbitMqSendSettings(name, _exchangeTypeSelector.DefaultExchangeType, durable, autoDelete);
configure?.Invoke(settings);
return(settings.GetSendAddress(_hostAddress));
}
async Task MessageRedeliveryContext.ScheduleRedelivery(TimeSpan delay)
{
var receiveSettings = _context.ReceiveContext.GetPayload <ReceiveSettings>();
string delayExchangeName = receiveSettings.QueueName + "_delay";
var sendSettings = new RabbitMqSendSettings(delayExchangeName, "x-delayed-message", receiveSettings.Durable, receiveSettings.AutoDelete);
sendSettings.SetExchangeArgument("x-delayed-type", receiveSettings.ExchangeType);
sendSettings.BindToQueue(receiveSettings.QueueName);
var modelContext = _context.ReceiveContext.GetPayload <ModelContext>();
Uri delayExchangeAddress = modelContext.ConnectionContext.HostSettings.GetSendAddress(sendSettings);
ISendEndpoint delayEndpoint = await _context.GetSendEndpoint(delayExchangeAddress);
await delayEndpoint.Send(_context.Message, _context.CreateCopyContextPipe((x, y) => UpdateDeliveryContext(x, y, delay)));
}
async Task <ScheduledMessage <T> > ScheduleSend <T>(Uri destinationAddress, DateTime scheduledTime, T message, IPipe <SendContext <T> > pipe, CancellationToken cancellationToken)
where T : class
{
var destinationSettings = _topology.GetSendSettings(destinationAddress);
var sendSettings = new RabbitMqSendSettings(destinationSettings.ExchangeName + "_delay", "x-delayed-message", destinationSettings.Durable,
destinationSettings.AutoDelete);
sendSettings.SetExchangeArgument("x-delayed-type", destinationSettings.ExchangeType);
sendSettings.BindToExchange(destinationSettings.ExchangeName);
var delayExchangeAddress = sendSettings.GetSendAddress(_hostAddress);
var delayEndpoint = await _sendEndpointProvider.GetSendEndpoint(delayExchangeAddress).ConfigureAwait(false);
var messageId = NewId.NextGuid();
IPipe <SendContext <T> > delayPipe = Pipe.ExecuteAsync <SendContext <T> >(async context =>
{
context.MessageId = messageId;
var rabbitSendContext = context.GetPayload <RabbitMqSendContext>();
var delay = Math.Max(0,
(scheduledTime.Kind == DateTimeKind.Local ? (scheduledTime - DateTime.Now) : (scheduledTime - DateTime.UtcNow)).TotalMilliseconds);
if (delay > 0)
{
rabbitSendContext.SetTransportHeader("x-delay", (long)delay);
}
await pipe.Send(context).ConfigureAwait(false);
});
await delayEndpoint.Send(message, delayPipe, cancellationToken).ConfigureAwait(false);
return(new ScheduledMessageHandle <T>(messageId, scheduledTime, destinationAddress, message));
}
public static SendSettings GetSendSettings(this IRabbitMqHost host, Type messageType, IMessageNameFormatter messageNameFormatter)
{
bool isTemporary = messageType.IsTemporaryMessageType();
bool durable = !isTemporary;
bool autoDelete = isTemporary;
string name = messageNameFormatter.GetMessageName(messageType).ToString();
SendSettings settings = new RabbitMqSendSettings(name, ExchangeType.Fanout, durable, autoDelete);
return settings;
}
protected override Uri GetErrorAddress()
{
string errorQueueName = _settings.QueueName + "_error";
var sendSettings = new RabbitMqSendSettings(errorQueueName, RabbitMQ.Client.ExchangeType.Fanout, true,
false);
sendSettings.BindToQueue(errorQueueName);
return _host.Settings.GetSendAddress(sendSettings);
}
/// <summary>
/// Return a send address for the exchange
/// </summary>
/// <param name="host">The RabbitMQ host</param>
/// <param name="exchangeName">The exchange name</param>
/// <param name="configure">An optional configuration for the exchange to set type, durable, etc.</param>
/// <returns></returns>
public static Uri GetSendAddress(this IRabbitMqHost host, string exchangeName, Action<IExchangeConfigurator> configure = null)
{
var builder = GetHostUriBuilder(host.Settings, exchangeName);
var sendSettings = new RabbitMqSendSettings(exchangeName, ExchangeType.Fanout, true, false);
configure?.Invoke(sendSettings);
builder.Query += string.Join("&", GetQueryStringOptions(sendSettings));
return builder.Uri;
}
private void OrderSend <T>(T message, CancellationToken cancelSend, Uri destination = null)
where T : class
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
var factory = new ConnectionFactory
{
HostName = Configurations.Configuration.Instance.Setting.TransportIp.Split(',')[0],
UserName = Configurations.Configuration.Instance.Setting.TransportUserName,
Password = Configurations.Configuration.Instance.Setting.TransportPassword,
};
if (!string.IsNullOrEmpty(Configurations.Configuration.Instance.Setting.TransportVirtualHost))
{
factory.VirtualHost = Configurations.Configuration.Instance.Setting.TransportVirtualHost;
}
factory.AutomaticRecoveryEnabled = true;
using (var connection = factory.CreateConnection(Configurations.Configuration.Instance.Setting.TransportIp.Split(',')))
{
using (var channel = connection.CreateModel())
{
var properties = channel.CreateBasicProperties();
var setting =
new RabbitMqSendSettings(
destination == null ? (typeof(T).Namespace + ":" + typeof(T).Name) : destination.AbsolutePath.Replace("/", ""),
"", true, false);
var exchange = Configurations.Configuration.Instance.Setting.TransportExchange;
var context = new BasicPublishRabbitMqSendContext <T>(properties, exchange, message, cancelSend);
properties.ContentType = "application/vnd.masstransit+json";
try
{
var headers = context.Headers.GetAll()
.Where(x => (x.Value != null) && (x.Value is string || x.Value.GetType().IsValueType))
.ToArray();
if (properties.Headers == null)
{
properties.Headers = new Dictionary <string, object>(headers.Length);
}
foreach (var header in headers)
{
if (properties.Headers.ContainsKey(header.Key))
{
continue;
}
properties.SetHeader(header.Key, header.Value);
}
properties.Headers["Content-Type"] = "application/vnd.masstransit+json";
properties.Persistent = context.Durable;
if (context.MessageId.HasValue)
{
properties.MessageId = context.MessageId.ToString();
}
if (context.CorrelationId.HasValue)
{
properties.CorrelationId = context.CorrelationId.ToString();
}
if (context.TimeToLive.HasValue)
{
properties.Expiration = context.TimeToLive.Value.TotalMilliseconds.ToString("F0",
CultureInfo.InvariantCulture);
}
channel.BasicPublish(context.Exchange, context.RoutingKey, context.Mandatory,
context.BasicProperties, context.Body);
}
catch (Exception ex)
{
}
}
}
}
/// <summary>
/// Return the send settings for the address
/// </summary>
/// <param name="address"></param>
/// <returns></returns>
public static SendSettings GetSendSettings(this Uri address)
{
if (string.Compare("rabbitmq", address.Scheme, StringComparison.OrdinalIgnoreCase) != 0)
throw new RabbitMqAddressException("The invalid scheme was specified: " + address.Scheme);
string name = address.AbsolutePath.Substring(1);
string[] pathSegments = name.Split('/');
if (pathSegments.Length == 2)
name = pathSegments[1];
if (name == "*")
throw new ArgumentException("Cannot send to a dynamic address");
VerifyQueueOrExchangeNameIsLegal(name);
bool isTemporary = address.Query.GetValueFromQueryString("temporary", false);
bool durable = address.Query.GetValueFromQueryString("durable", !isTemporary);
bool autoDelete = address.Query.GetValueFromQueryString("autodelete", isTemporary);
string exchangeType = address.Query.GetValueFromQueryString("type") ?? ExchangeType.Fanout;
var settings = new RabbitMqSendSettings(name, exchangeType, durable, autoDelete);
bool bindToQueue = address.Query.GetValueFromQueryString("bind", false);
if (bindToQueue)
{
string queueName = WebUtility.UrlDecode(address.Query.GetValueFromQueryString("queue"));
settings.BindToQueue(queueName);
}
string delayedType = address.Query.GetValueFromQueryString("delayedType");
if (!string.IsNullOrWhiteSpace(delayedType))
settings.SetExchangeArgument("x-delayed-type", delayedType);
string bindExchange = address.Query.GetValueFromQueryString("bindexchange");
if (!string.IsNullOrWhiteSpace(bindExchange))
settings.BindToExchange(bindExchange);
return settings;
}
protected override Uri GetDeadLetterAddress()
{
string errorQueueName = _settings.QueueName + "_skipped";
var sendSettings = new RabbitMqSendSettings(errorQueueName, RabbitMQ.Client.ExchangeType.Fanout, _settings.Durable,
_settings.AutoDelete);
sendSettings.BindToQueue(errorQueueName);
return _host.Settings.GetSendAddress(sendSettings);
}
