private async Task FuturePublishInternalAsync <T>(TimeSpan messageDelay, T message, string cancellationKey) where T : class
{
Preconditions.CheckNotNull(message, "message");
Preconditions.CheckLess(messageDelay, MaxMessageDelay, "messageDelay");
Preconditions.CheckNull(cancellationKey, "cancellationKey");
var delay = Round(messageDelay);
var delayString = delay.ToString(@"dd\_hh\_mm\_ss");
var exchangeName = conventions.ExchangeNamingConvention(typeof(T));
var futureExchangeName = exchangeName + "_" + delayString;
var futureQueueName = conventions.QueueNamingConvention(typeof(T), delayString);
var futureExchange = await advancedBus.ExchangeDeclareAsync(futureExchangeName, ExchangeType.Topic).ConfigureAwait(false);
var futureQueue = await advancedBus.QueueDeclareAsync(futureQueueName, perQueueMessageTtl : (int)delay.TotalMilliseconds, deadLetterExchange : exchangeName).ConfigureAwait(false);
await advancedBus.BindAsync(futureExchange, futureQueue, "#").ConfigureAwait(false);
var easyNetQMessage = new Message <T>(message)
{
Properties =
{
DeliveryMode = messageDeliveryModeStrategy.GetDeliveryMode(typeof(T))
}
};
await advancedBus.PublishAsync(futureExchange, "#", false, false, easyNetQMessage).ConfigureAwait(false);
}
private async Task FuturePublishInternalAsync <T>(TimeSpan messageDelay, T message, string cancellationKey = null) where T : class
{
Preconditions.CheckNotNull(message, "message");
Preconditions.CheckLess(messageDelay, MaxMessageDelay, "messageDelay");
Preconditions.CheckNull(cancellationKey, "cancellationKey");
var exchangeName = conventions.ExchangeNamingConvention(typeof(T));
var futureExchangeName = exchangeName + "_delayed";
var queueName = conventions.QueueNamingConvention(typeof(T), null);
var futureExchange = await advancedBus.ExchangeDeclareAsync(futureExchangeName, ExchangeType.Direct, delayed : true).ConfigureAwait(false);
var exchange = await advancedBus.ExchangeDeclareAsync(exchangeName, ExchangeType.Topic).ConfigureAwait(false);
await advancedBus.BindAsync(futureExchange, exchange, "#").ConfigureAwait(false);
var queue = await advancedBus.QueueDeclareAsync(queueName).ConfigureAwait(false);
await advancedBus.BindAsync(exchange, queue, "#").ConfigureAwait(false);
var easyNetQMessage = new Message <T>(message)
{
Properties =
{
DeliveryMode = messageDeliveryModeStrategy.GetDeliveryMode(typeof(T)),
Headers = new Dictionary <string, object>{
{ "x-delay", (int)messageDelay.TotalMilliseconds }
}
}
};
await advancedBus.PublishAsync(futureExchange, "#", false, false, easyNetQMessage).ConfigureAwait(false);
}
public Task FuturePublishAsync <T>(DateTime futurePublishDate, string cancellationKey, T message) where T : class
{
Preconditions.CheckNotNull(message, "message");
var messageType = typeof(ScheduleMe);
return(publishExchangeDeclareStrategy.DeclareExchangeAsync(advancedBus, messageType, ExchangeType.Topic).Then(exchange =>
{
var typeName = typeNameSerializer.Serialize(typeof(T));
var messageBody = serializer.MessageToBytes(message);
var scheduleMe = new ScheduleMe
{
WakeTime = futurePublishDate,
BindingKey = typeName,
CancellationKey = cancellationKey,
InnerMessage = messageBody
};
var easyNetQMessage = new Message <ScheduleMe>(scheduleMe)
{
Properties =
{
DeliveryMode = messageDeliveryModeStrategy.GetDeliveryMode(messageType)
}
};
return advancedBus.PublishAsync(exchange, conventions.TopicNamingConvention(messageType), false, false, easyNetQMessage);
}));
}
public virtual void Publish <T>(T message, Action <IPublishConfiguration> configure) where T : class
{
Preconditions.CheckNotNull(message, "message");
Preconditions.CheckNotNull(configure, "configure");
var configuration = new PublishConfiguration(conventions.TopicNamingConvention(typeof(T)));
configure(configuration);
var messageType = typeof(T);
var easyNetQMessage = new Message <T>(message)
{
Properties =
{
DeliveryMode = messageDeliveryModeStrategy.GetDeliveryMode(messageType)
}
};
if (configuration.Priority != null)
{
easyNetQMessage.Properties.Priority = configuration.Priority.Value;
}
if (configuration.Expires != null)
{
easyNetQMessage.Properties.Expiration = configuration.Expires.ToString();
}
var exchange = publishExchangeDeclareStrategy.DeclareExchange(advancedBus, messageType, ExchangeType.Topic);
advancedBus.Publish(exchange, configuration.Topic, false, easyNetQMessage);
}
public virtual void Publish <T>(T message, string topic) where T : class
{
Preconditions.CheckNotNull(message, "message");
Preconditions.CheckNotNull(topic, "topic");
var messageType = typeof(T);
var easyNetQMessage = new Message <T>(message)
{
Properties =
{
DeliveryMode = messageDeliveryModeStrategy.GetDeliveryMode(messageType)
}
};
var exchange = publishExchangeDeclareStrategy.DeclareExchange(advancedBus, messageType, ExchangeType.Topic);
advancedBus.Publish(exchange, topic, false, easyNetQMessage);
}
/// <inheritdoc />
public virtual async Task PublishAsync <T>(T message, Action <IPublishConfiguration> configure, CancellationToken cancellationToken)
{
Preconditions.CheckNotNull(message, "message");
Preconditions.CheckNotNull(configure, "configure");
using var cts = cancellationToken.WithTimeout(configuration.Timeout);
var publishConfiguration = new PublishConfiguration(conventions.TopicNamingConvention(typeof(T)));
configure(publishConfiguration);
var messageType = typeof(T);
var advancedMessageProperties = new MessageProperties();
if (publishConfiguration.Priority != null)
{
advancedMessageProperties.Priority = publishConfiguration.Priority.Value;
}
if (publishConfiguration.Expires != null)
{
advancedMessageProperties.Expiration = publishConfiguration.Expires.ToString();
}
advancedMessageProperties.DeliveryMode = messageDeliveryModeStrategy.GetDeliveryMode(messageType);
var advancedMessage = new Message <T>(message, advancedMessageProperties);
var exchange = await exchangeDeclareStrategy.DeclareExchangeAsync(
messageType, ExchangeType.Topic, cts.Token
).ConfigureAwait(false);
await advancedBus.PublishAsync(
exchange, publishConfiguration.Topic, false, advancedMessage, cts.Token
).ConfigureAwait(false);
}
/// <inheritdoc />
public async Task FuturePublishAsync <T>(
T message,
TimeSpan delay,
Action <IFuturePublishConfiguration> configure,
CancellationToken cancellationToken = default
)
{
Preconditions.CheckNotNull(message, "message");
Preconditions.CheckNotNull(configure, "configure");
using var cts = cancellationToken.WithTimeout(configuration.Timeout);
var publishConfiguration = new FuturePublishConfiguration(conventions.TopicNamingConvention(typeof(T)));
configure(publishConfiguration);
var topic = publishConfiguration.Topic;
var exchange = await exchangeDeclareStrategy.DeclareExchangeAsync(
conventions.ExchangeNamingConvention(typeof(T)),
ExchangeType.Topic,
cts.Token
).ConfigureAwait(false);
var delayString = delay.ToString(@"dd\_hh\_mm\_ss");
var futureExchange = await exchangeDeclareStrategy.DeclareExchangeAsync(
$"{conventions.ExchangeNamingConvention(typeof(T))}_{delayString}",
ExchangeType.Topic,
cts.Token
).ConfigureAwait(false);
var futureQueue = await advancedBus.QueueDeclareAsync(
conventions.QueueNamingConvention(typeof(T), delayString),
c =>
{
c.WithMessageTtl(delay);
c.WithDeadLetterExchange(exchange);
if (setDeadLetterRoutingKey)
{
c.WithDeadLetterRoutingKey(topic);
}
},
cts.Token
).ConfigureAwait(false);
await advancedBus.BindAsync(futureExchange, futureQueue, topic, cts.Token).ConfigureAwait(false);
var properties = new MessageProperties();
if (publishConfiguration.Priority != null)
{
properties.Priority = publishConfiguration.Priority.Value;
}
properties.DeliveryMode = messageDeliveryModeStrategy.GetDeliveryMode(typeof(T));
var advancedMessage = new Message <T>(message, properties);
await advancedBus.PublishAsync(
futureExchange, topic, configuration.MandatoryPublish, advancedMessage, cts.Token
).ConfigureAwait(false);
}
private Message <T> GetRabbitMessage <T>(T message, Type messageType) where T : class
{
return(new Message <T>(message)
{
Properties =
{
DeliveryMode = messageDeliveryModeStrategy.GetDeliveryMode(messageType)
}
});
}
public async Task FuturePublishAsync <T>(DateTime futurePublishDate, T message, string cancellationKey = null) where T : class
{
Preconditions.CheckNotNull(message, "message");
var scheduleMeType = typeof(ScheduleMe);
var scheduleMeExchange = await publishExchangeDeclareStrategy.DeclareExchangeAsync(advancedBus, scheduleMeType, ExchangeType.Topic).ConfigureAwait(false);
var baseMessageType = typeof(T);
var concreteMessageType = message.GetType();
var serializedMessage = messageSerializationStrategy.SerializeMessage(new Message <T>(message)
{
Properties =
{
DeliveryMode = messageDeliveryModeStrategy.GetDeliveryMode(concreteMessageType)
}
});
var scheduleMe = new ScheduleMe
{
WakeTime = futurePublishDate,
CancellationKey = cancellationKey,
InnerMessage = serializedMessage.Body,
MessageProperties = serializedMessage.Properties,
BindingKey = typeNameSerializer.Serialize(typeof(T)),
ExchangeType = ExchangeType.Topic,
Exchange = conventions.ExchangeNamingConvention(baseMessageType),
RoutingKey = "#"
};
var easyNetQMessage = new Message <ScheduleMe>(scheduleMe)
{
Properties =
{
DeliveryMode = messageDeliveryModeStrategy.GetDeliveryMode(scheduleMeType)
}
};
await advancedBus.PublishAsync(scheduleMeExchange, conventions.TopicNamingConvention(scheduleMeType), false, easyNetQMessage).ConfigureAwait(false);
}
private Message <T> PrepareSend <T>(string queue, T message) where T : class
{
GuardHelper.ArgumentNotEmpty(() => queue);
GuardHelper.ArgumentNotNull(() => message);
DeclareQueue(queue);
var wrappedMessage = new Message <T>(message)
{
Properties =
{
DeliveryMode = messageDeliveryModeStrategy.GetDeliveryMode(typeof(T))
}
};
return(wrappedMessage);
}
/// <inheritdoc />
public async Task FuturePublishAsync <T>(
T message,
TimeSpan delay,
Action <IFuturePublishConfiguration> configure,
CancellationToken cancellationToken = default
)
{
Preconditions.CheckNotNull(message, "message");
Preconditions.CheckNotNull(configure, "configure");
using var cts = cancellationToken.WithTimeout(configuration.Timeout);
var publishConfiguration = new FuturePublishConfiguration(conventions.TopicNamingConvention(typeof(T)));
configure(publishConfiguration);
var topic = publishConfiguration.Topic;
var exchangeName = conventions.ExchangeNamingConvention(typeof(T));
var futureExchangeName = exchangeName + "_delayed";
var futureExchange = await advancedBus.ExchangeDeclareAsync(
futureExchangeName,
c => c.AsDelayedExchange(ExchangeType.Topic),
cts.Token
).ConfigureAwait(false);
var exchange = await advancedBus.ExchangeDeclareAsync(
exchangeName,
c => c.WithType(ExchangeType.Topic),
cts.Token
).ConfigureAwait(false);
await advancedBus.BindAsync(futureExchange, exchange, topic, cts.Token).ConfigureAwait(false);
var properties = new MessageProperties();
if (publishConfiguration.Priority != null)
{
properties.Priority = publishConfiguration.Priority.Value;
}
properties.DeliveryMode = messageDeliveryModeStrategy.GetDeliveryMode(typeof(T));
await advancedBus.PublishAsync(
futureExchange, topic, false, new Message <T>(message, properties).WithDelay(delay), cts.Token
).ConfigureAwait(false);
}
protected virtual void RequestPublish <TRequest>(TRequest request, string routingKey, string returnQueueName, Guid correlationId)
where TRequest : class
{
var exchange = publishExchangeDeclareStrategy.DeclareExchange(advancedBus, conventions.RpcExchangeNamingConvention(), ExchangeType.Direct);
var requestType = typeof(TRequest);
var requestMessage = new Message <TRequest>(request)
{
Properties =
{
ReplyTo = returnQueueName,
CorrelationId = correlationId.ToString(),
Expiration = (timeoutStrategy.GetTimeoutSeconds(requestType) * 1000).ToString(),
DeliveryMode = messageDeliveryModeStrategy.GetDeliveryMode(requestType)
}
};
advancedBus.Publish(exchange, routingKey, false, requestMessage);
}
public virtual Task PublishAsync <T>(T message, string topic) where T : class
{
Preconditions.CheckNotNull(message, "message");
Preconditions.CheckNotNull(topic, "topic");
var messageType = typeof(T);
return(publishExchangeDeclareStrategy.DeclareExchangeAsync(advancedBus, messageType, ExchangeType.Topic).Then(exchange =>
{
var easyNetQMessage = new Message <T>(message)
{
Properties =
{
DeliveryMode = messageDeliveryModeStrategy.GetDeliveryMode(messageType)
}
};
return advancedBus.PublishAsync(exchange, topic, false, false, easyNetQMessage);
}));
}