/// <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;
}
/// <inheritdoc />
public ResetHeartbeatLua(IRedisConnection connection, RedisNames redisNames, IGetTimeFactory getTime, ICompositeSerialization serialization)
: base(connection, redisNames)
{
_getTime = getTime.Create();
_serialization = serialization;
Script = @"local returnData = {}
local uuids = redis.call('zrangebyscore', @workingkey, 0, @heartbeattime, 'LIMIT', 0, @limit)
if #uuids == 0 then
return nil
end
local index = 1
for k, v in pairs(uuids) do
redis.call('zrem', @workingkey, v)
local routeName = redis.call('hget', @RouteIDKey, v)
if(routeName) then
local routePending = @pendingkey .. '_}' .. routeName
redis.call('rpush', routePending, v)
else
redis.call('rpush', @pendingkey, v)
end
redis.call('hset', @StatusKey, v, '0')
returnData[index] = {v, redis.call('hget', @headerskey, v)}
index = index + 1
end
redis.call('publish', @channel, '')
return returnData";
}
/// <summary>
/// Initializes a new instance of the <see cref="ReceiveMessageQueryHandler" /> class.
/// </summary>
/// <param name="optionsFactory">The options factory.</param>
/// <param name="tableNameHelper">The table name helper.</param>
/// <param name="receivedMessageFactory">The received message factory.</param>
/// <param name="commandCache">The command cache.</param>
/// <param name="messageFactory">The message factory.</param>
/// <param name="headers">The headers.</param>
/// <param name="serialization">The serialization.</param>
/// <param name="getTimeFactory">The get time factory.</param>
public ReceiveMessageQueryHandler(IPostgreSqlMessageQueueTransportOptionsFactory optionsFactory,
ITableNameHelper tableNameHelper,
IReceivedMessageFactory receivedMessageFactory,
PostgreSqlCommandStringCache commandCache,
IMessageFactory messageFactory,
IHeaders headers,
ICompositeSerialization serialization,
IGetTimeFactory getTimeFactory)
{
Guard.NotNull(() => optionsFactory, optionsFactory);
Guard.NotNull(() => tableNameHelper, tableNameHelper);
Guard.NotNull(() => receivedMessageFactory, receivedMessageFactory);
Guard.NotNull(() => commandCache, commandCache);
Guard.NotNull(() => messageFactory, messageFactory);
Guard.NotNull(() => serialization, serialization);
Guard.NotNull(() => headers, headers);
Guard.NotNull(() => getTimeFactory, getTimeFactory);
_options = new Lazy <PostgreSqlMessageQueueTransportOptions>(optionsFactory.Create);
_tableNameHelper = tableNameHelper;
_receivedMessageFactory = receivedMessageFactory;
_commandCache = commandCache;
_messageFactory = messageFactory;
_headers = headers;
_serialization = serialization;
_getTime = getTimeFactory.Create();
}
/// <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="SendMessageCommandHandler" /> class.
/// </summary>
/// <param name="tableNameHelper">The table name helper.</param>
/// <param name="serializer">The serializer.</param>
/// <param name="optionsFactory">The options factory.</param>
/// <param name="headers">The headers.</param>
/// <param name="commandCache">The command cache.</param>
/// <param name="configurationSend">The configuration send.</param>
/// <param name="sendJobStatus">The send job status.</param>
/// <param name="jobExistsHandler">The job exists handler.</param>
/// <param name="jobSchedulerMetaData">The job scheduler meta data.</param>
/// <param name="getTimeFactory">The get time factory.</param>
public SendMessageCommandHandlerAsync(TableNameHelper tableNameHelper,
ICompositeSerialization serializer,
IPostgreSqlMessageQueueTransportOptionsFactory optionsFactory,
IHeaders headers,
PostgreSqlCommandStringCache commandCache,
TransportConfigurationSend configurationSend,
ICommandHandler <SetJobLastKnownEventCommand <NpgsqlConnection, NpgsqlTransaction> > sendJobStatus, RelationalDatabase.IQueryHandler <DoesJobExistQuery <NpgsqlConnection, NpgsqlTransaction>, QueueStatuses> jobExistsHandler,
IJobSchedulerMetaData jobSchedulerMetaData,
IGetTimeFactory getTimeFactory)
{
Guard.NotNull(() => tableNameHelper, tableNameHelper);
Guard.NotNull(() => serializer, serializer);
Guard.NotNull(() => optionsFactory, optionsFactory);
Guard.NotNull(() => headers, headers);
Guard.NotNull(() => commandCache, commandCache);
Guard.NotNull(() => configurationSend, configurationSend);
Guard.NotNull(() => sendJobStatus, sendJobStatus);
Guard.NotNull(() => jobExistsHandler, jobExistsHandler);
Guard.NotNull(() => jobSchedulerMetaData, jobSchedulerMetaData);
Guard.NotNull(() => getTimeFactory, getTimeFactory);
_tableNameHelper = tableNameHelper;
_serializer = serializer;
_options = new Lazy <PostgreSqlMessageQueueTransportOptions>(optionsFactory.Create);
_headers = headers;
_commandCache = commandCache;
_configurationSend = configurationSend;
_sendJobStatus = sendJobStatus;
_jobExistsHandler = jobExistsHandler;
_jobSchedulerMetaData = jobSchedulerMetaData;
_getTime = getTimeFactory.Create();
}
internal static IDbCommand GetMainCommand(SendMessageCommand commandSend,
IDbConnection connection,
IDbCommandStringCache commandCache,
IHeaders headers,
ICompositeSerialization serializer)
{
var command = connection.CreateCommand();
command.CommandText = commandCache.GetCommand(CommandStringTypes.InsertMessageBody);
var serialization =
serializer.Serializer.MessageToBytes(new MessageBody {
Body = commandSend.MessageToSend.Body
}, commandSend.MessageToSend.Headers);
var param = command.CreateParameter();
param.ParameterName = "@Body";
param.DbType = DbType.Binary;
param.Value = serialization.Output;
command.Parameters.Add(param);
commandSend.MessageToSend.SetHeader(headers.StandardHeaders.MessageInterceptorGraph,
serialization.Graph);
param = command.CreateParameter();
param.ParameterName = "@Headers";
param.DbType = DbType.Binary;
param.Value = serializer.InternalSerializer.ConvertToBytes(commandSend.MessageToSend.Headers);
command.Parameters.Add(param);
return(command);
}
/// <summary>
/// Initializes a new instance of the <see cref="SendMessageCommandHandler" /> class.
/// </summary>
/// <param name="tableNameHelper">The table name helper.</param>
/// <param name="serializer">The serializer.</param>
/// <param name="optionsFactory">The options factory.</param>
/// <param name="headers">The headers.</param>
/// <param name="commandCache">The command cache.</param>
/// <param name="configurationSend">The configuration send.</param>
/// <param name="sendJobStatus">The send job status.</param>
/// <param name="jobExistsHandler">The job exists handler.</param>
/// <param name="jobSchedulerMetaData">The job scheduler meta data.</param>
public SendMessageCommandHandler(ITableNameHelper tableNameHelper,
ICompositeSerialization serializer,
ISqlServerMessageQueueTransportOptionsFactory optionsFactory,
IHeaders headers,
SqlServerCommandStringCache commandCache,
TransportConfigurationSend configurationSend,
ICommandHandler <SetJobLastKnownEventCommand <SqlConnection, SqlTransaction> > sendJobStatus, IQueryHandler <DoesJobExistQuery <SqlConnection, SqlTransaction>, QueueStatuses> jobExistsHandler,
IJobSchedulerMetaData jobSchedulerMetaData)
{
Guard.NotNull(() => tableNameHelper, tableNameHelper);
Guard.NotNull(() => serializer, serializer);
Guard.NotNull(() => optionsFactory, optionsFactory);
Guard.NotNull(() => headers, headers);
Guard.NotNull(() => commandCache, commandCache);
Guard.NotNull(() => configurationSend, configurationSend);
Guard.NotNull(() => sendJobStatus, sendJobStatus);
Guard.NotNull(() => jobExistsHandler, jobExistsHandler);
Guard.NotNull(() => jobSchedulerMetaData, jobSchedulerMetaData);
_tableNameHelper = tableNameHelper;
_serializer = serializer;
_options = new Lazy <SqlServerMessageQueueTransportOptions>(optionsFactory.Create);
_headers = headers;
_commandCache = commandCache;
_configurationSend = configurationSend;
_sendJobStatus = sendJobStatus;
_jobExistsHandler = jobExistsHandler;
_jobSchedulerMetaData = jobSchedulerMetaData;
}
/// <summary>
/// Initializes a new instance of the <see cref="SendMessageCommandHandlerAsync"/> class.
/// </summary>
/// <param name="connectionInformation">The connection information.</param>
/// <param name="tableNameHelper">The table name helper.</param>
/// <param name="serializer">The serializer.</param>
/// <param name="optionsFactory">The options factory.</param>
/// <param name="headers">The headers.</param>
/// <param name="configurationSend">The configuration send.</param>
/// <param name="sendJobStatus">The send job status.</param>
/// <param name="jobExistsHandler">The job exists handler.</param>
/// <param name="jobSchedulerMetaData">The job scheduler meta data.</param>
/// <param name="databaseExists">The database exists.</param>
public SendMessageCommandHandlerAsync(
LiteDbConnectionManager connectionInformation,
TableNameHelper tableNameHelper,
ICompositeSerialization serializer,
ILiteDbMessageQueueTransportOptionsFactory optionsFactory,
IHeaders headers,
TransportConfigurationSend configurationSend,
ICommandHandler <SetJobLastKnownEventCommand> sendJobStatus, IQueryHandler <DoesJobExistQuery, QueueStatuses> jobExistsHandler,
IJobSchedulerMetaData jobSchedulerMetaData,
DatabaseExists databaseExists)
{
Guard.NotNull(() => connectionInformation, connectionInformation);
Guard.NotNull(() => tableNameHelper, tableNameHelper);
Guard.NotNull(() => serializer, serializer);
Guard.NotNull(() => optionsFactory, optionsFactory);
Guard.NotNull(() => headers, headers);
Guard.NotNull(() => configurationSend, configurationSend);
Guard.NotNull(() => sendJobStatus, sendJobStatus);
Guard.NotNull(() => jobExistsHandler, jobExistsHandler);
Guard.NotNull(() => jobSchedulerMetaData, jobSchedulerMetaData);
Guard.NotNull(() => databaseExists, databaseExists);
_connectionInformation = connectionInformation;
_tableNameHelper = tableNameHelper;
_serializer = serializer;
_options = new Lazy <LiteDbMessageQueueTransportOptions>(optionsFactory.Create);
_headers = headers;
_configurationSend = configurationSend;
_sendJobStatus = sendJobStatus;
_jobExistsHandler = jobExistsHandler;
_jobSchedulerMetaData = jobSchedulerMetaData;
_databaseExists = databaseExists;
}
/// <summary>
/// Initializes a new instance of the <see cref="SendMessageCommandHandler" /> class.
/// </summary>
/// <param name="serializer">The serializer.</param>
/// <param name="headers">The headers.</param>
/// <param name="enqueueLua">The enqueue.</param>
/// <param name="enqueueDelayedLua">The enqueue delayed.</param>
/// <param name="enqueueExpirationLua">The enqueue expiration.</param>
/// <param name="enqueueDelayedAndExpirationLua">The enqueue delayed and expiration.</param>
/// <param name="unixTimeFactory">The unix time factory.</param>
/// <param name="messageIdFactory">The message identifier factory.</param>
/// <param name="jobSchedulerMetaData">The job scheduler meta data.</param>
public SendMessageCommandHandlerAsync(
ICompositeSerialization serializer,
IHeaders headers,
EnqueueLua enqueueLua,
EnqueueDelayedLua enqueueDelayedLua,
EnqueueExpirationLua enqueueExpirationLua,
EnqueueDelayedAndExpirationLua enqueueDelayedAndExpirationLua,
IUnixTimeFactory unixTimeFactory,
IGetMessageIdFactory messageIdFactory,
IJobSchedulerMetaData jobSchedulerMetaData)
{
Guard.NotNull(() => serializer, serializer);
Guard.NotNull(() => headers, headers);
Guard.NotNull(() => enqueueLua, enqueueLua);
Guard.NotNull(() => enqueueDelayedLua, enqueueDelayedLua);
Guard.NotNull(() => enqueueExpirationLua, enqueueExpirationLua);
Guard.NotNull(() => enqueueDelayedAndExpirationLua, enqueueDelayedAndExpirationLua);
Guard.NotNull(() => unixTimeFactory, unixTimeFactory);
Guard.NotNull(() => messageIdFactory, messageIdFactory);
_serializer = serializer;
_headers = headers;
_enqueueLua = enqueueLua;
_messageIdFactory = messageIdFactory;
_jobSchedulerMetaData = jobSchedulerMetaData;
_enqueueDelayedLua = enqueueDelayedLua;
_enqueueDelayedAndExpirationLua = enqueueDelayedAndExpirationLua;
_unixTimeFactory = unixTimeFactory;
_enqueueExpirationLua = enqueueExpirationLua;
}
/// <summary>
/// Initializes a new instance of the <see cref="RpcMethodQueue" /> class.
/// </summary>
/// <param name="queue">The queue.</param>
/// <param name="serializer">The serializer.</param>
/// <param name="compositeSerialization">The composite serialization.</param>
public RpcMethodQueue(IRpcQueue<object, MessageExpression> queue,
IExpressionSerializer serializer,
ICompositeSerialization compositeSerialization)
{
Guard.NotNull(() => queue, queue);
Guard.NotNull(() => serializer, serializer);
Guard.NotNull(() => compositeSerialization, compositeSerialization);
_queue = queue;
_serializer = serializer;
_compositeSerialization = compositeSerialization;
}
/// <summary>
/// Initializes a new instance of the <see cref="ProducerMethodQueue" /> class.
/// </summary>
/// <param name="queue">The queue.</param>
/// <param name="serializer">The serializer.</param>
/// <param name="compositeSerialization">The composite serialization.</param>
public ProducerMethodQueue(IProducerQueue <MessageExpression> queue,
IExpressionSerializer serializer,
ICompositeSerialization compositeSerialization)
{
Guard.NotNull(() => queue, queue);
Guard.NotNull(() => serializer, serializer);
Guard.NotNull(() => compositeSerialization, compositeSerialization);
_queue = queue;
_serializer = serializer;
_compositeSerialization = compositeSerialization;
}
/// <summary>
/// Initializes a new instance of the <see cref="GetHeaderQueryHandler"/> class.
/// </summary>
/// <param name="serialization">The serialization.</param>
/// <param name="connectionInformation">The connection information.</param>
/// <param name="tableNameHelper">The table name helper.</param>
public GetHeaderQueryHandler(ICompositeSerialization serialization,
LiteDbConnectionManager connectionInformation,
TableNameHelper tableNameHelper)
{
Guard.NotNull(() => connectionInformation, connectionInformation);
Guard.NotNull(() => tableNameHelper, tableNameHelper);
Guard.NotNull(() => serialization, serialization);
_connectionInformation = connectionInformation;
_tableNameHelper = tableNameHelper;
_serialization = serialization;
}
/// <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>
/// Initializes a new instance of the <see cref="RpcMethodQueue" /> class.
/// </summary>
/// <param name="queue">The queue.</param>
/// <param name="serializer">The serializer.</param>
/// <param name="compositeSerialization">The composite serialization.</param>
public RpcMethodQueue(IRpcQueue <object, MessageExpression> queue,
IExpressionSerializer serializer,
ICompositeSerialization compositeSerialization)
{
Guard.NotNull(() => queue, queue);
Guard.NotNull(() => serializer, serializer);
Guard.NotNull(() => compositeSerialization, compositeSerialization);
_queue = queue;
_serializer = serializer;
_compositeSerialization = compositeSerialization;
}
/// <summary>
/// Initializes a new instance of the <see cref="MessageMethodHandling" /> class.
/// </summary>
/// <param name="serializer">The serializer.</param>
/// <param name="linqCompiler">The method compiler.</param>
/// <param name="compositeSerialization">The composite serialization.</param>
public MessageMethodHandling(IExpressionSerializer serializer,
ILinqCompiler linqCompiler,
ICompositeSerialization compositeSerialization)
{
Guard.NotNull(() => serializer, serializer);
Guard.NotNull(() => linqCompiler, linqCompiler);
Guard.NotNull(() => compositeSerialization, compositeSerialization);
_serializer = serializer;
_linqCompiler = linqCompiler;
_compositeSerialization = compositeSerialization;
}
/// <summary>
/// Initializes a new instance of the <see cref="ProducerMethodQueue" /> class.
/// </summary>
/// <param name="queue">The queue.</param>
/// <param name="serializer">The serializer.</param>
/// <param name="compositeSerialization">The composite serialization.</param>
public ProducerMethodQueue(IProducerQueue<MessageExpression> queue,
IExpressionSerializer serializer,
ICompositeSerialization compositeSerialization)
{
Guard.NotNull(() => queue, queue);
Guard.NotNull(() => serializer, serializer);
Guard.NotNull(() => compositeSerialization, compositeSerialization);
_queue = queue;
_serializer = serializer;
_compositeSerialization = compositeSerialization;
}
/// <summary>
/// Initializes a new instance of the <see cref="GetHeaderQueryHandler"/> class.
/// </summary>
/// <param name="connectionFactory">The connection factory.</param>
/// <param name="prepareQuery">The prepare query.</param>
/// <param name="readColumn">The read column.</param>
/// <param name="serialization">The serialization.</param>
public GetHeaderQueryHandler(IDbConnectionFactory connectionFactory,
IPrepareQueryHandler <GetHeaderQuery, IDictionary <string, object> > prepareQuery,
IReadColumn readColumn, ICompositeSerialization serialization)
{
Guard.NotNull(() => connectionFactory, connectionFactory);
Guard.NotNull(() => prepareQuery, prepareQuery);
Guard.NotNull(() => readColumn, readColumn);
Guard.NotNull(() => serialization, serialization);
_connectionFactory = connectionFactory;
_prepareQuery = prepareQuery;
_readColumn = readColumn;
_serialization = serialization;
}
/// <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="FindRecordsToResetByHeartBeatQueryHandler"/> class.
/// </summary>
/// <param name="connectionInformation">The connection information.</param>
/// <param name="tableNameHelper">The table name helper.</param>
/// <param name="configuration">The configuration.</param>
/// <param name="serialization">The serialization.</param>
public FindRecordsToResetByHeartBeatQueryHandler(LiteDbConnectionManager connectionInformation,
TableNameHelper tableNameHelper,
IHeartBeatConfiguration configuration,
ICompositeSerialization serialization)
{
Guard.NotNull(() => connectionInformation, connectionInformation);
Guard.NotNull(() => tableNameHelper, tableNameHelper);
Guard.NotNull(() => configuration, configuration);
Guard.NotNull(() => serialization, serialization);
_connectionInformation = connectionInformation;
_tableNameHelper = tableNameHelper;
_configuration = configuration;
_serialization = serialization;
}
/// <summary>
/// Initializes a new instance of the <see cref="FindRecordsToResetByHeartBeatQueryHandler{T}"/> class.
/// </summary>
/// <param name="dbConnectionFactory">The database connection factory.</param>
/// <param name="prepareQuery">The prepare query.</param>
/// <param name="readColumn">The read column.</param>
/// <param name="serialization">The serialization.</param>
public FindRecordsToResetByHeartBeatQueryHandler(
IDbConnectionFactory dbConnectionFactory,
IPrepareQueryHandler <FindMessagesToResetByHeartBeatQuery <T>, IEnumerable <MessageToReset <T> > > prepareQuery,
IReadColumn readColumn, ICompositeSerialization serialization)
{
Guard.NotNull(() => dbConnectionFactory, dbConnectionFactory);
Guard.NotNull(() => prepareQuery, prepareQuery);
Guard.NotNull(() => readColumn, readColumn);
Guard.NotNull(() => serialization, serialization);
_dbConnectionFactory = dbConnectionFactory;
_prepareQuery = prepareQuery;
_readColumn = readColumn;
_serialization = serialization;
}
public MessageDeQueue(IHeaders headers,
IMessageFactory messageFactory,
IReceivedMessageFactory receivedMessageFactory,
ICompositeSerialization serialization)
{
Guard.NotNull(() => serialization, serialization);
Guard.NotNull(() => headers, headers);
Guard.NotNull(() => messageFactory, messageFactory);
Guard.NotNull(() => receivedMessageFactory, receivedMessageFactory);
_messageFactory = messageFactory;
_headers = headers;
_serialization = serialization;
_receivedMessageFactory = receivedMessageFactory;
}
public MessageDeQueue(IHeaders headers,
IMessageFactory messageFactory,
IReceivedMessageFactory receivedMessageFactory,
ICompositeSerialization serialization)
{
Guard.NotNull(() => serialization, serialization);
Guard.NotNull(() => headers, headers);
Guard.NotNull(() => messageFactory, messageFactory);
Guard.NotNull(() => receivedMessageFactory, receivedMessageFactory);
_messageFactory = messageFactory;
_headers = headers;
_serialization = serialization;
_receivedMessageFactory = receivedMessageFactory;
}
/// <summary>
/// Initializes a new instance of the <see cref="MessageMethodHandling" /> class.
/// </summary>
/// <param name="serializer">The serializer.</param>
/// <param name="queueContainer">The queue container.</param>
/// <param name="log">The log.</param>
/// <param name="linqCompiler">The method compiler.</param>
/// <param name="compositeSerialization">The composite serialization.</param>
public MessageMethodHandling(IExpressionSerializer serializer,
IQueueContainer queueContainer,
ILogFactory log,
ILinqCompiler linqCompiler,
ICompositeSerialization compositeSerialization)
{
Guard.NotNull(() => serializer, serializer);
Guard.NotNull(() => queueContainer, queueContainer);
Guard.NotNull(() => log, log);
Guard.NotNull(() => linqCompiler, linqCompiler);
Guard.NotNull(() => compositeSerialization, compositeSerialization);
_serializer = serializer;
_queueContainer = queueContainer;
_linqCompiler = linqCompiler;
_compositeSerialization = compositeSerialization;
_log = log.Create();
_rpcQueues = new Dictionary<IConnectionInformation, IProducerQueueRpc<object>>();
}
/// <summary>
/// Initializes a new instance of the <see cref="MessageMethodHandling" /> class.
/// </summary>
/// <param name="serializer">The serializer.</param>
/// <param name="queueContainer">The queue container.</param>
/// <param name="log">The log.</param>
/// <param name="linqCompiler">The method compiler.</param>
/// <param name="compositeSerialization">The composite serialization.</param>
public MessageMethodHandling(IExpressionSerializer serializer,
IQueueContainer queueContainer,
ILogFactory log,
ILinqCompiler linqCompiler,
ICompositeSerialization compositeSerialization)
{
Guard.NotNull(() => serializer, serializer);
Guard.NotNull(() => queueContainer, queueContainer);
Guard.NotNull(() => log, log);
Guard.NotNull(() => linqCompiler, linqCompiler);
Guard.NotNull(() => compositeSerialization, compositeSerialization);
_serializer = serializer;
_queueContainer = queueContainer;
_linqCompiler = linqCompiler;
_compositeSerialization = compositeSerialization;
_log = log.Create();
_rpcQueues = new Dictionary <IConnectionInformation, IProducerQueueRpc <object> >();
}
/// <summary>
/// Initializes a new instance of the <see cref="SendMessageCommandHandler" /> class.
/// </summary>
/// <param name="tableNameHelper">The table name helper.</param>
/// <param name="serializer">The serializer.</param>
/// <param name="optionsFactory">The options factory.</param>
/// <param name="headers">The headers.</param>
/// <param name="commandCache">The command cache.</param>
/// <param name="configurationSend">The configuration send.</param>
/// <param name="getTimeFactory">The get time factory.</param>
/// <param name="dbFactory">The database factory.</param>
/// <param name="sendJobStatus">The send job status.</param>
/// <param name="jobExistsHandler">The job exists handler.</param>
/// <param name="jobSchedulerMetaData">The job scheduler meta data.</param>
/// <param name="databaseExists">The database exists.</param>
/// <param name="readerAsync">The reader asynchronous.</param>
public SendMessageCommandHandlerAsync(TableNameHelper tableNameHelper,
ICompositeSerialization serializer,
ISqLiteMessageQueueTransportOptionsFactory optionsFactory,
IHeaders headers,
IDbCommandStringCache commandCache,
TransportConfigurationSend configurationSend,
IGetTimeFactory getTimeFactory,
IDbFactory dbFactory,
ICommandHandler <SetJobLastKnownEventCommand <IDbConnection, IDbTransaction> > sendJobStatus,
IQueryHandler <DoesJobExistQuery <IDbConnection, IDbTransaction>, QueueStatuses> jobExistsHandler,
IJobSchedulerMetaData jobSchedulerMetaData,
DatabaseExists databaseExists,
IReaderAsync readerAsync)
{
Guard.NotNull(() => tableNameHelper, tableNameHelper);
Guard.NotNull(() => serializer, serializer);
Guard.NotNull(() => optionsFactory, optionsFactory);
Guard.NotNull(() => headers, headers);
Guard.NotNull(() => commandCache, commandCache);
Guard.NotNull(() => configurationSend, configurationSend);
Guard.NotNull(() => getTimeFactory, getTimeFactory);
Guard.NotNull(() => sendJobStatus, sendJobStatus);
Guard.NotNull(() => jobExistsHandler, jobExistsHandler);
Guard.NotNull(() => jobSchedulerMetaData, jobSchedulerMetaData);
Guard.NotNull(() => databaseExists, databaseExists);
Guard.NotNull(() => readerAsync, readerAsync);
_tableNameHelper = tableNameHelper;
_serializer = serializer;
_options = new Lazy <SqLiteMessageQueueTransportOptions>(optionsFactory.Create);
_headers = headers;
_commandCache = commandCache;
_configurationSend = configurationSend;
_getTime = getTimeFactory.Create();
_dbFactory = dbFactory;
_sendJobStatus = sendJobStatus;
_jobExistsHandler = jobExistsHandler;
_jobSchedulerMetaData = jobSchedulerMetaData;
_databaseExists = databaseExists;
_readerAsync = readerAsync;
}
internal static SQLiteCommand GetMainCommand(SendMessageCommand commandSend,
SQLiteConnection connection,
SqLiteCommandStringCache commandCache,
IHeaders headers,
ICompositeSerialization serializer)
{
var command = connection.CreateCommand();
command.CommandText = commandCache.GetCommand(SqLiteCommandStringTypes.InsertMessageBody);
var serialization =
serializer.Serializer.MessageToBytes(new MessageBody { Body = commandSend.MessageToSend.Body });
command.Parameters.Add("@body", DbType.Binary, -1);
command.Parameters["@body"].Value = serialization.Output;
commandSend.MessageToSend.SetHeader(headers.StandardHeaders.MessageInterceptorGraph,
serialization.Graph);
command.Parameters.Add("@headers", DbType.Binary, -1);
command.Parameters["@headers"].Value =
serializer.InternalSerializer.ConvertToBytes(commandSend.MessageToSend.Headers);
return command;
}
/// <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;
}
public GetHeaderQueryHandler(GetHeaderLua lua,
ICompositeSerialization serialization)
{
_lua = lua;
_serialization = serialization;
}
