/// <summary>
/// Initializes a new instance of the <see cref="SendMessageCommandBatchHandler" /> class.
/// </summary>
/// <param name="serializer">The serializer.</param>
/// <param name="enqueue">The enqueue.</param>
/// <param name="unixTimeFactory">The unix time factory.</param>
/// <param name="messageIdFactory">The message identifier factory.</param>
/// <param name="sentMessageFactory">The sent message factory.</param>
/// <param name="redisHeaders">The redis headers.</param>
/// <param name="sendBatchSize">Size of the send batch.</param>
public SendMessageCommandBatchHandler(
ICompositeSerialization serializer,
EnqueueBatchLua enqueue,
IUnixTimeFactory unixTimeFactory,
IGetMessageIdFactory messageIdFactory,
ISentMessageFactory sentMessageFactory,
RedisHeaders redisHeaders,
ISendBatchSize sendBatchSize)
{
Guard.NotNull(() => serializer, serializer);
Guard.NotNull(() => enqueue, enqueue);
Guard.NotNull(() => unixTimeFactory, unixTimeFactory);
Guard.NotNull(() => messageIdFactory, messageIdFactory);
Guard.NotNull(() => sentMessageFactory, sentMessageFactory);
Guard.NotNull(() => redisHeaders, redisHeaders);
Guard.NotNull(() => sendBatchSize, sendBatchSize);
_serializer = serializer;
_enqueue = enqueue;
_messageIdFactory = messageIdFactory;
_sentMessageFactory = sentMessageFactory;
_redisHeaders = redisHeaders;
_sendBatchSize = sendBatchSize;
_unixTimeFactory = unixTimeFactory;
}
/// <summary>
/// Initializes a new instance of the <see cref="ReceiveMessageQueryHandler" /> class.
/// </summary>
/// <param name="serializer">The serializer.</param>
/// <param name="receivedMessageFactory">The received message factory.</param>
/// <param name="deleteMessage">The delete message.</param>
/// <param name="redisHeaders">The redisHeaders.</param>
/// <param name="dequeueLua">The dequeue.</param>
/// <param name="dequeueRpcLua">The dequeue RPC.</param>
/// <param name="unixTimeFactory">The unix time factory.</param>
/// <param name="messageFactory">The message factory.</param>
public ReceiveMessageQueryHandler(
ICompositeSerialization serializer,
IReceivedMessageFactory receivedMessageFactory,
ICommandHandlerWithOutput <DeleteMessageCommand, bool> deleteMessage,
RedisHeaders redisHeaders,
DequeueLua dequeueLua,
DequeueRpcLua dequeueRpcLua,
IUnixTimeFactory unixTimeFactory,
IMessageFactory messageFactory)
{
Guard.NotNull(() => serializer, serializer);
Guard.NotNull(() => receivedMessageFactory, receivedMessageFactory);
Guard.NotNull(() => deleteMessage, deleteMessage);
Guard.NotNull(() => redisHeaders, redisHeaders);
Guard.NotNull(() => dequeueLua, dequeueLua);
Guard.NotNull(() => dequeueRpcLua, dequeueRpcLua);
Guard.NotNull(() => unixTimeFactory, unixTimeFactory);
_serializer = serializer;
_receivedMessageFactory = receivedMessageFactory;
_deleteMessage = deleteMessage;
_redisHeaders = redisHeaders;
_dequeueLua = dequeueLua;
_dequeueRpcLua = dequeueRpcLua;
_unixTimeFactory = unixTimeFactory;
_messageFactory = messageFactory;
}
/// <summary>
/// Initializes a new instance of the <see cref="RollbackMessage" /> class.
/// </summary>
/// <param name="command">The command handler factory.</param>
/// <param name="headers">The headers.</param>
public RollbackMessage(ICommandHandler <RollbackMessageCommand <string> > command, RedisHeaders headers)
{
Guard.NotNull(() => command, command);
Guard.NotNull(() => headers, headers);
_command = command;
_headers = headers;
}
/// <summary>
/// Creates the messages to send.
/// </summary>
/// <param name="redisHeaders">The redis headers.</param>
/// <param name="messages">The messages.</param>
/// <param name="meta">The meta data, already serialized.</param>
/// <param name="unixTimeFactory">The unix time factory.</param>
/// <param name="messageIdFactory">The message identifier factory.</param>
/// <param name="serializer">The composite serializer.</param>
/// <returns></returns>
public static List <EnqueueBatchLua.MessageToSend> CreateMessagesToSend(RedisHeaders redisHeaders,
IReadOnlyCollection <QueueMessage <IMessage, IAdditionalMessageData> > messages,
byte[] meta,
IUnixTimeFactory unixTimeFactory,
IGetMessageIdFactory messageIdFactory,
ICompositeSerialization serializer)
{
var messagesToSend = new ConcurrentBag <EnqueueBatchLua.MessageToSend>();
Parallel.ForEach(messages, m =>
{
//the correlation ID must be saved as a message header
m.Message.SetHeader(redisHeaders.CorrelationId, new RedisQueueCorrelationIdSerialized((Guid)m.MessageData.CorrelationId.Id.Value));
//check for delay and expiration
long unixTimeStampDelay = 0;
long unixTimeStampExpiration = 0;
if (m.MessageData.GetDelay().HasValue)
{
// ReSharper disable once PossibleInvalidOperationException
unixTimeStampDelay = unixTimeFactory.Create().GetAddDifferenceMilliseconds(m.MessageData.GetDelay().Value);
}
// ReSharper disable once PossibleInvalidOperationException
if (m.MessageData.GetExpiration().HasValue&& m.MessageData.GetExpiration().Value != TimeSpan.Zero)
{
var unixTime = unixTimeFactory.Create();
var timeSpan = m.MessageData.GetExpiration();
if (timeSpan != null)
{
var timespan = timeSpan.Value;
unixTimeStampExpiration = unixTime.GetAddDifferenceMilliseconds(timespan);
}
}
var serialized = serializer.Serializer.MessageToBytes(new MessageBody {
Body = m.Message.Body
}, m.Message.Headers);
m.Message.SetHeader(redisHeaders.Headers.StandardHeaders.MessageInterceptorGraph, serialized.Graph);
messagesToSend.Add(new EnqueueBatchLua.MessageToSend
{
Message = serialized.Output,
Headers = serializer.InternalSerializer.ConvertToBytes(m.Message.Headers),
MessageId = messageIdFactory.Create().Create().ToString(),
MetaData = meta,
CorrelationId = m.MessageData.CorrelationId.ToString(),
TimeStamp = unixTimeStampDelay,
ExpireTimeStamp = unixTimeStampExpiration,
Route = m.MessageData.Route
});
});
return(messagesToSend.ToList());
}
/// <summary>
/// Creates the messages to send.
/// </summary>
/// <param name="redisHeaders">The redis headers.</param>
/// <param name="messages">The messages.</param>
/// <param name="meta">The meta data, already serialized.</param>
/// <param name="unixTimeFactory">The unix time factory.</param>
/// <param name="messageIdFactory">The message identifier factory.</param>
/// <param name="serializer">The composite serializer.</param>
/// <returns></returns>
public static List<EnqueueBatchLua.MessageToSend> CreateMessagesToSend(RedisHeaders redisHeaders,
IReadOnlyCollection<QueueMessage<IMessage, IAdditionalMessageData>> messages,
byte[] meta,
IUnixTimeFactory unixTimeFactory,
IGetMessageIdFactory messageIdFactory,
ICompositeSerialization serializer)
{
var messagesToSend = new ConcurrentBag<EnqueueBatchLua.MessageToSend>();
Parallel.ForEach(messages, m =>
{
//the correlation ID must be saved as a message header
m.Message.SetHeader(redisHeaders.CorelationId, new RedisQueueCorrelationIdSerialized((Guid)m.MessageData.CorrelationId.Id.Value));
//check for delay and expiration
long unixTimeStampDelay = 0;
long unixTimeStampExpiration = 0;
if (m.MessageData.GetDelay().HasValue)
{
// ReSharper disable once PossibleInvalidOperationException
unixTimeStampDelay = unixTimeFactory.Create().GetAddDifferenceMilliseconds(m.MessageData.GetDelay().Value);
}
// ReSharper disable once PossibleInvalidOperationException
if (m.MessageData.GetExpiration().HasValue && m.MessageData.GetExpiration().Value != TimeSpan.Zero)
{
var unixTime = unixTimeFactory.Create();
var timeSpan = m.MessageData.GetExpiration();
if (timeSpan != null)
{
var timespan = timeSpan.Value;
unixTimeStampExpiration = unixTime.GetAddDifferenceMilliseconds(timespan);
}
}
var serialized = serializer.Serializer.MessageToBytes(new MessageBody { Body = m.Message.Body });
m.Message.SetHeader(redisHeaders.Headers.StandardHeaders.MessageInterceptorGraph, serialized.Graph);
messagesToSend.Add(new EnqueueBatchLua.MessageToSend()
{
Message = serialized.Output,
Headers = serializer.InternalSerializer.ConvertToBytes(m.Message.Headers),
MessageId = messageIdFactory.Create().Create().ToString(),
MetaData = meta,
CorrelationId = m.MessageData.CorrelationId.ToString(),
TimeStamp = unixTimeStampDelay,
ExpireTimeStamp = unixTimeStampExpiration
});
});
return messagesToSend.ToList();
}
/// <summary>Initializes a new instance of the <see cref="ReceiveMessageQueryHandler"/> class.</summary>
/// <param name="serializer">The serializer.</param>
/// <param name="receivedMessageFactory">The received message factory.</param>
/// <param name="removeMessage">removes a message from the queue</param>
/// <param name="redisHeaders">The redisHeaders.</param>
/// <param name="dequeueLua">The dequeue.</param>
/// <param name="unixTimeFactory">The unix time factory.</param>
/// <param name="messageFactory">The message factory.</param>
public ReceiveMessageQueryHandlerAsync(
ICompositeSerialization serializer,
IReceivedMessageFactory receivedMessageFactory,
IRemoveMessage removeMessage,
RedisHeaders redisHeaders,
DequeueLua dequeueLua,
IUnixTimeFactory unixTimeFactory,
IMessageFactory messageFactory)
{
Guard.NotNull(() => serializer, serializer);
Guard.NotNull(() => receivedMessageFactory, receivedMessageFactory);
Guard.NotNull(() => removeMessage, removeMessage);
Guard.NotNull(() => redisHeaders, redisHeaders);
Guard.NotNull(() => dequeueLua, dequeueLua);
Guard.NotNull(() => unixTimeFactory, unixTimeFactory);
_serializer = serializer;
_receivedMessageFactory = receivedMessageFactory;
_removeMessage = removeMessage;
_redisHeaders = redisHeaders;
_dequeueLua = dequeueLua;
_unixTimeFactory = unixTimeFactory;
_messageFactory = messageFactory;
}
