/// <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; }
/// <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; }