/// <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="connectionInformation">The connection information.</param> /// <param name="buildDequeueCommand">The build dequeue command.</param> /// <param name="messageDeQueue">The message de queue.</param> /// <param name="dbFactory">The transaction factory.</param> /// <param name="databaseExists">The database exists.</param> /// <param name="configuration">Queue configuration</param> public ReceiveMessageQueryHandler(ISqLiteMessageQueueTransportOptionsFactory optionsFactory, ITableNameHelper tableNameHelper, IConnectionInformation connectionInformation, BuildDequeueCommand buildDequeueCommand, MessageDeQueue messageDeQueue, IDbFactory dbFactory, DatabaseExists databaseExists, QueueConsumerConfiguration configuration) { Guard.NotNull(() => optionsFactory, optionsFactory); Guard.NotNull(() => tableNameHelper, tableNameHelper); Guard.NotNull(() => buildDequeueCommand, buildDequeueCommand); Guard.NotNull(() => messageDeQueue, messageDeQueue); Guard.NotNull(() => databaseExists, databaseExists); Guard.NotNull(() => dbFactory, dbFactory); Guard.NotNull(() => configuration, configuration); _options = new Lazy <SqLiteMessageQueueTransportOptions>(optionsFactory.Create); _tableNameHelper = tableNameHelper; _connectionInformation = connectionInformation; _buildDequeueCommand = buildDequeueCommand; _messageDeQueue = messageDeQueue; _dbFactory = dbFactory; _databaseExists = databaseExists; _configuration = configuration; }
private void SetQueueOptions(QueueConsumerConfiguration obj, int orderId) { var SqlParam = new Npgsql.NpgsqlParameter("@OrderID", orderId); obj.AddUserParameter(SqlParam); obj.SetUserWhereClause("(q.OrderID = @OrderID)"); }
public static void Main(string[] args = null) { try { var tokenSource = new CancellationTokenSource(); var config = QueueConsumerConfiguration.Create(); DisplayHeader(config); var processor = new QueueMessageProcessor(config); var task = new Task(() => { while (!processor.Execute()) { } }, tokenSource.Token); Console.CancelKeyPress += (sender, eventArgs) => { Console.WriteLine("Aborting Program..."); tokenSource.Cancel(); task.Dispose(); }; task.Start(); task.Wait(); } catch (Exception e) { Console.WriteLine("Program Exception:"); Console.WriteLine(" - {0}\n\n{1}", e.Message, e.StackTrace); } }
/// <summary> /// Initializes a new instance of the <see cref="MessageProcessingRpcReceive{TReceivedMessage}" /> class. /// </summary> /// <param name="configurationReceive">The configuration receive.</param> /// <param name="receiveMessagesFactory">The receive messages factory.</param> /// <param name="messageContextFactory">The message context factory.</param> /// <param name="messageHandler">The message handler.</param> /// <param name="rpcContextFactory">The RPC context factory.</param> /// <param name="commitMessage">The commit message.</param> public MessageProcessingRpcReceive( QueueConsumerConfiguration configurationReceive, IReceiveMessagesFactory receiveMessagesFactory, IMessageContextFactory messageContextFactory, IMessageHandlerRegistration messageHandler, IRpcContextFactory rpcContextFactory, ICommitMessage commitMessage) { Guard.NotNull(() => configurationReceive, configurationReceive); Guard.NotNull(() => receiveMessagesFactory, receiveMessagesFactory); Guard.NotNull(() => messageContextFactory, messageContextFactory); Guard.NotNull(() => messageHandler, messageHandler); Guard.NotNull(() => rpcContextFactory, rpcContextFactory); Guard.NotNull(() => commitMessage, commitMessage); _configurationReceive = configurationReceive; _receiveMessagesFactory = receiveMessagesFactory; _messageContextFactory = messageContextFactory; _messageHandler = messageHandler; _rpcContextFactory = rpcContextFactory; _commitMessage = commitMessage; void Action(IReceivedMessage <TReceivedMessage> message, IWorkerNotification worker) { } messageHandler.Set((Action <IReceivedMessage <TReceivedMessage>, IWorkerNotification>)Action); }
/// <summary> /// Initializes a new instance of the <see cref="RpcQueue{TReceivedMessage, TSendMessage}" /> class. /// </summary> /// <param name="configurationRpc">The configuration RPC.</param> /// <param name="configurationReceive">The configuration receive.</param> /// <param name="clearMessages">The clear messages factory.</param> /// <param name="log">The log.</param> /// <param name="messageProcessingRpcReceive">The message processing RPC receive.</param> /// <param name="messageProcessingRpcSend">The message processing RPC send.</param> /// <param name="queueWaitFactory">The queue wait factory.</param> public RpcQueue( QueueRpcConfiguration configurationRpc, QueueConsumerConfiguration configurationReceive, IClearExpiredMessagesRpcMonitor clearMessages, ILogFactory log, IMessageProcessingRpcReceive <TReceivedMessage> messageProcessingRpcReceive, IMessageProcessingRpcSend <TSendMessage> messageProcessingRpcSend, IQueueWaitFactory queueWaitFactory) : base(log) { Guard.NotNull(() => configurationRpc, configurationRpc); Guard.NotNull(() => configurationReceive, configurationReceive); Guard.NotNull(() => clearMessages, clearMessages); Guard.NotNull(() => log, log); Guard.NotNull(() => messageProcessingRpcReceive, messageProcessingRpcReceive); Guard.NotNull(() => messageProcessingRpcSend, messageProcessingRpcSend); Guard.NotNull(() => queueWaitFactory, queueWaitFactory); _configurationReceive = configurationReceive; _configurationRpc = configurationRpc; _messageProcessingRpcReceive = messageProcessingRpcReceive; _messageProcessingRpcSend = messageProcessingRpcSend; _queueWaitFactory = queueWaitFactory; _clearQueue = clearMessages; }
/// <summary> /// Initializes a new instance of the <see cref="ConsumerQueueAsync" /> class. /// </summary> /// <param name="configuration">The configuration.</param> /// <param name="workerFactory">The worker factory.</param> /// <param name="log">The log.</param> /// <param name="registerMessagesAsync">The register messages asynchronous.</param> /// <param name="stopWorker">The stop worker.</param> /// <param name="queueMonitor">The queue monitor.</param> public ConsumerQueueAsync( QueueConsumerConfiguration configuration, IPrimaryWorkerFactory workerFactory, ILogger log, IRegisterMessagesAsync registerMessagesAsync, StopWorker stopWorker, IQueueMonitor queueMonitor) : base(log) { Guard.NotNull(() => configuration, configuration); Guard.NotNull(() => workerFactory, workerFactory); Guard.NotNull(() => log, log); Guard.NotNull(() => registerMessagesAsync, registerMessagesAsync); Guard.NotNull(() => stopWorker, stopWorker); Guard.NotNull(() => queueMonitor, queueMonitor); _configuration = configuration; _primaryWorker = new Lazy <IPrimaryWorker>(() => { var worker = workerFactory.Create(); worker.UserException += LogUserException; worker.SystemException += LogSystemException; return(worker); }); _stopWorker = stopWorker; _queueMonitor = queueMonitor; _registerMessagesAsync = registerMessagesAsync; }
/// <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> /// <param name="configuration">Queue Configuration</param> public ReceiveMessageQueryHandler(IPostgreSqlMessageQueueTransportOptionsFactory optionsFactory, ITableNameHelper tableNameHelper, IReceivedMessageFactory receivedMessageFactory, PostgreSqlCommandStringCache commandCache, IMessageFactory messageFactory, IHeaders headers, ICompositeSerialization serialization, IGetTimeFactory getTimeFactory, QueueConsumerConfiguration configuration) { 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); Guard.NotNull(() => configuration, configuration); _options = new Lazy <PostgreSqlMessageQueueTransportOptions>(optionsFactory.Create); _tableNameHelper = tableNameHelper; _receivedMessageFactory = receivedMessageFactory; _commandCache = commandCache; _messageFactory = messageFactory; _headers = headers; _serialization = serialization; _getTime = getTimeFactory.Create(); _configuration = configuration; }
/// <summary> /// Initializes a new instance of the <see cref="QueueWaitFactory" /> class. /// </summary> /// <param name="configuration">The configuration.</param> /// <param name="cancelWork">The cancel work.</param> public QueueWaitFactory(QueueConsumerConfiguration configuration, IQueueCancelWork cancelWork) { Guard.NotNull(() => configuration, configuration); Guard.NotNull(() => cancelWork, cancelWork); _configuration = configuration; _cancelWork = cancelWork; }
/// <summary> /// Initializes a new instance of the <see cref="FindRecordsToResetByHeartBeatQueryPrepareHandler"/> class. /// </summary> /// <param name="commandCache">The command cache.</param> /// <param name="configuration">The configuration.</param> public FindRecordsToResetByHeartBeatQueryPrepareHandler(CommandStringCache commandCache, QueueConsumerConfiguration configuration) { Guard.NotNull(() => commandCache, commandCache); Guard.NotNull(() => configuration, configuration); _commandCache = commandCache; _configuration = configuration; }
public static void SetupDefaultConsumerQueueErrorPurge(QueueConsumerConfiguration configuration, bool actuallyPurge) { configuration.Worker.TimeToWaitForWorkersToStop = TimeSpan.FromSeconds(5); configuration.Worker.TimeToWaitForWorkersToCancel = TimeSpan.FromSeconds(10); configuration.Worker.SingleWorkerWhenNoWorkFound = true; configuration.MessageError.MessageAge = actuallyPurge ? TimeSpan.FromSeconds(0) : TimeSpan.FromDays(1); configuration.MessageError.Enabled = true; configuration.MessageError.MonitorTime = TimeSpan.FromSeconds(5); }
public static void SetupDefaultErrorRetry(QueueConsumerConfiguration configuration) { var times = new List <TimeSpan> { TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(2) }; configuration.TransportConfiguration.RetryDelayBehavior.Add(typeof(IndexOutOfRangeException), times); }
private void SetQueueOptions(QueueConsumerConfiguration obj, int orderId) { var SqlParam = new SqlParameter("@OrderID", SqlDbType.Int) { Value = orderId }; obj.AddUserParameter(SqlParam); obj.SetUserWhereClause("(OrderID = @OrderID)"); }
public static async Task <bool> SendNotification(QueueConsumerConfiguration configuration, string message) { RestRequest request = new RestRequest(Method.POST); request.AddParameter("application/json; charset=utf-8", message, ParameterType.RequestBody); var response = await GetRestClient(configuration).ExecuteTaskAsync(request); return(configuration.StatusCodeAcceptToSuccessList.Contains((int)response.StatusCode)); }
/// <summary> /// Sets the user parameters. The same collection will be used for every de-queue call. /// </summary> /// <param name="configuration">The configuration.</param> /// <param name="parameters">The parameters.</param> public static void SetUserParameters(this QueueConsumerConfiguration configuration, List <SQLiteParameter> parameters) { if (configuration.AdditionalSettings.ContainsKey("userdequeueparams")) { configuration.AdditionalSettings["userdequeueparams"] = parameters; } else { configuration.AdditionalSettings.Add("userdequeueparams", parameters); } }
/// <summary> /// Sets the user where clause for custom de-queue 'AND' operations. /// </summary> /// <param name="configuration">The configuration.</param> /// <param name="whereClause">The where clause.</param> public static void SetUserWhereClause(this QueueConsumerConfiguration configuration, string whereClause) { if (configuration.AdditionalSettings.ContainsKey("userdequeueparams")) { configuration.AdditionalSettings["userdequeue"] = whereClause; } else { configuration.AdditionalSettings.Add("userdequeue", whereClause); } }
/// <summary> /// Initializes a new instance of the <see cref="FindRecordsToResetByHeartBeatQueryPrepareHandler" /> class. /// </summary> /// <param name="commandCache">The command cache.</param> /// <param name="configuration">The configuration.</param> /// <param name="getTimeFactory">The get time factory.</param> public FindRecordsToResetByHeartBeatQueryPrepareHandler(CommandStringCache commandCache, QueueConsumerConfiguration configuration, IGetTimeFactory getTimeFactory) { Guard.NotNull(() => commandCache, commandCache); Guard.NotNull(() => configuration, configuration); Guard.NotNull(() => getTimeFactory, getTimeFactory); _commandCache = commandCache; _configuration = configuration; _getTime = getTimeFactory.Create(); }
/// <summary> /// Initializes a new instance of the <see cref="ResetHeartBeat"/> class. /// </summary> /// <param name="configuration">The configuration.</param> /// <param name="commandHandler">The command handler.</param> /// <param name="queryHandler">The query handler.</param> public ResetHeartBeat(QueueConsumerConfiguration configuration, ICommandHandlerWithOutput <ResetHeartBeatCommand, long> commandHandler, IQueryHandler <FindMessagesToResetByHeartBeatQuery, IEnumerable <MessageToReset> > queryHandler) { Guard.NotNull(() => configuration, configuration); Guard.NotNull(() => commandHandler, commandHandler); Guard.NotNull(() => queryHandler, queryHandler); _configuration = configuration; _commandHandler = commandHandler; _queryHandler = queryHandler; }
/// <summary> /// Initializes a new instance of the <see cref="ResetHeartBeatDecorator" /> class. /// </summary> /// <param name="log">The log.</param> /// <param name="handler">The handler.</param> /// <param name="configuration">The configuration.</param> public ResetHeartBeatDecorator(ILogger log, IResetHeartBeat handler, QueueConsumerConfiguration configuration) { Guard.NotNull(() => log, log); Guard.NotNull(() => handler, handler); Guard.NotNull(() => configuration, configuration); _log = log; _handler = handler; _configuration = configuration; }
/// <summary> /// Initializes a new instance of the <see cref="ReceiveMessage" /> class. /// </summary> /// <param name="configuration">The configuration.</param> /// <param name="receiveMessage">The receive message.</param> /// <param name="cancelToken">The cancel token.</param> public ReceiveMessage(QueueConsumerConfiguration configuration, IQueryHandler <ReceiveMessageQuery <IDbConnection, IDbTransaction>, IReceivedMessageInternal> receiveMessage, IQueueCancelWork cancelToken) { Guard.NotNull(() => configuration, configuration); Guard.NotNull(() => receiveMessage, receiveMessage); Guard.NotNull(() => cancelToken, cancelToken); _configuration = configuration; _receiveMessage = receiveMessage; _cancelToken = cancelToken; }
/// <summary> /// Gets the user where/and clause for de-queue /// </summary> /// <param name="configuration">The configuration.</param> /// <returns></returns> /// <remarks>The factory method will always be returned if set, even if the non-factory method is also set</remarks> public static string GetUserClause(this QueueConsumerConfiguration configuration) { if (configuration.AdditionalSettings.ContainsKey("userdequeuefactory")) { return(((Func <string>)configuration.AdditionalSettings["userdequeuefactory"]).Invoke()); } if (configuration.AdditionalSettings.ContainsKey("userdequeue")) { return((string)configuration.AdditionalSettings["userdequeue"]); } return(null); }
/// <summary> /// Gets the user parameters for de-queue /// </summary> /// <param name="configuration">The configuration.</param> /// <returns></returns> /// <remarks>The factory method will always be returned if set, even if the non-factory method is also set</remarks> public static List <SQLiteParameter> GetUserParameters(this QueueConsumerConfiguration configuration) { if (configuration.AdditionalSettings.ContainsKey("userdequeueparamsfactory")) { return(((Func <List <SQLiteParameter> >)configuration.AdditionalSettings["userdequeueparamsfactory"]).Invoke()); } if (configuration.AdditionalSettings.ContainsKey("userdequeueparams")) { return((List <SQLiteParameter>)configuration.AdditionalSettings["userdequeueparams"]); } return(null); }
/// <summary> /// Initializes a new instance of the <see cref="RollbackMessage"/> class. /// </summary> /// <param name="configuration">The configuration.</param> /// <param name="rollbackCommand">The rollback command.</param> /// <param name="headers">The headers.</param> public RollbackMessage(QueueConsumerConfiguration configuration, ICommandHandler <RollbackMessageCommand <long> > rollbackCommand, IIncreaseQueueDelay headers) { Guard.NotNull(() => configuration, configuration); Guard.NotNull(() => rollbackCommand, rollbackCommand); Guard.NotNull(() => headers, headers); _configuration = configuration; _rollbackCommand = rollbackCommand; _headers = headers; }
/// <summary> /// Initializes a new instance of the <see cref="ReceiveMessage" /> class. /// </summary> /// <param name="configuration">The configuration.</param> /// <param name="cancelToken">The cancel token.</param> /// <param name="dataStorage">The data storage.</param> public ReceiveMessage(QueueConsumerConfiguration configuration, IQueueCancelWork cancelToken, IDataStorage dataStorage) { Guard.NotNull(() => configuration, configuration); Guard.NotNull(() => dataStorage, dataStorage); Guard.NotNull(() => cancelToken, cancelToken); _configuration = configuration; _cancelToken = cancelToken; _dataStorage = dataStorage; }
public static async Task <bool> SendNotification(QueueConsumerConfiguration configuration, string message) { RestRequest request = new RestRequest(Method.POST); request.AddParameter("application/json; charset=utf-8", message, ParameterType.RequestBody); ; var response = await GetRestClient(configuration).ExecuteTaskAsync(request); return(response.StatusCode == HttpStatusCode.OK || response.StatusCode == HttpStatusCode.Created || response.StatusCode == HttpStatusCode.Accepted || response.StatusCode == HttpStatusCode.NoContent); }
/// <summary> /// Initializes a new instance of the <see cref="ResetHeartBeat{T}"/> class. /// </summary> /// <param name="configuration">The configuration.</param> /// <param name="commandHandler">The command handler.</param> /// <param name="queryHandler">The query handler.</param> /// <param name="getTime">The get time.</param> public ResetHeartBeat(QueueConsumerConfiguration configuration, ICommandHandlerWithOutput <ResetHeartBeatCommand <T>, long> commandHandler, IQueryHandler <FindMessagesToResetByHeartBeatQuery <T>, IEnumerable <MessageToReset <T> > > queryHandler, IGetTimeFactory getTime) { Guard.NotNull(() => configuration, configuration); Guard.NotNull(() => commandHandler, commandHandler); Guard.NotNull(() => queryHandler, queryHandler); _configuration = configuration; _commandHandler = commandHandler; _queryHandler = queryHandler; _getTime = getTime.Create(); }
/// <summary> /// Initializes a new instance of the <see cref="ReceiveMessage" /> class. /// </summary> /// <param name="configuration">The configuration.</param> /// <param name="receiveMessage">The receive message.</param> /// <param name="setStatusCommandHandler">The set status command handler.</param> /// <param name="cancelToken">The cancel token.</param> public ReceiveMessage(QueueConsumerConfiguration configuration, IQueryHandler <ReceiveMessageQuery <NpgsqlConnection, NpgsqlTransaction>, IReceivedMessageInternal> receiveMessage, ICommandHandler <SetStatusTableStatusCommand <long> > setStatusCommandHandler, IQueueCancelWork cancelToken) { Guard.NotNull(() => configuration, configuration); Guard.NotNull(() => receiveMessage, receiveMessage); Guard.NotNull(() => setStatusCommandHandler, setStatusCommandHandler); Guard.NotNull(() => cancelToken, cancelToken); _configuration = configuration; _receiveMessage = receiveMessage; _setStatusCommandHandler = setStatusCommandHandler; _cancelToken = cancelToken; }
/// <summary> /// Adds the user parameter. This same parameter will be used for every de-queue call /// </summary> /// <param name="configuration">The configuration.</param> /// <param name="parameter">The parameter.</param> public static void AddUserParameter(this QueueConsumerConfiguration configuration, SQLiteParameter parameter) { if (configuration.AdditionalSettings.ContainsKey("userdequeueparams")) { ((List <SQLiteParameter>)configuration.AdditionalSettings["userdequeueparams"]).Add(parameter); } else { var data = new List <SQLiteParameter> { parameter }; configuration.AdditionalSettings.Add("userdequeueparams", data); } }
/// <inheritdoc /> /// <summary> /// Initializes a new instance of the <see cref="DequeueRpcLua"/> class. /// </summary> /// <param name="connection">The connection.</param> /// <param name="redisNames">The redis names.</param> /// <param name="configuration">The configuration.</param> public DequeueRpcLua(IRedisConnection connection, RedisNames redisNames, QueueConsumerConfiguration configuration) : base(connection, redisNames) { _configuration = configuration; Script = @"local count = redis.call('LREM', @pendingkey, 1, @uuid) if (count==0) then return nil; end local expireScore = redis.call('zscore', @expirekey, @uuid) redis.call('zadd', @workingkey, @timestamp, @uuid) local message = redis.call('hget', @valueskey, @uuid) redis.call('hset', @StatusKey, @uuid, '1') local headers = redis.call('hget', @headerskey, @uuid) return {@uuid, message, headers, expireScore}"; }
public CreateDequeueStatement(ISqlServerMessageQueueTransportOptionsFactory optionsFactory, ITableNameHelper tableNameHelper, SqlServerCommandStringCache commandCache, QueueConsumerConfiguration configuration) { Guard.NotNull(() => optionsFactory, optionsFactory); Guard.NotNull(() => tableNameHelper, tableNameHelper); Guard.NotNull(() => commandCache, commandCache); Guard.NotNull(() => configuration, configuration); _options = new Lazy <SqlServerMessageQueueTransportOptions>(optionsFactory.Create); _tableNameHelper = tableNameHelper; _commandCache = commandCache; _configuration = configuration; }
/// <summary> /// Initializes a new instance of the <see cref="ReceiveMessage" /> class. /// </summary> /// <param name="configuration">The configuration.</param> /// <param name="receiveMessage">The receive message.</param> /// <param name="setStatusCommandHandler">The set status command handler.</param> /// <param name="cancelToken">The cancel token.</param> /// <param name="receiveMessageAsync">The receive message asynchronous.</param> public ReceiveMessage(QueueConsumerConfiguration configuration, RelationalDatabase.IQueryHandler <ReceiveMessageQuery <SqlConnection, SqlTransaction>, IReceivedMessageInternal> receiveMessage, ICommandHandler <SetStatusTableStatusCommand> setStatusCommandHandler, IQueueCancelWork cancelToken, RelationalDatabase.IQueryHandler <ReceiveMessageQueryAsync <SqlConnection, SqlTransaction>, Task <IReceivedMessageInternal> > receiveMessageAsync) { Guard.NotNull(() => configuration, configuration); Guard.NotNull(() => receiveMessage, receiveMessage); Guard.NotNull(() => setStatusCommandHandler, setStatusCommandHandler); Guard.NotNull(() => cancelToken, cancelToken); Guard.NotNull(() => receiveMessageAsync, receiveMessageAsync); _configuration = configuration; _receiveMessage = receiveMessage; _setStatusCommandHandler = setStatusCommandHandler; _cancelToken = cancelToken; _receiveMessageAsync = receiveMessageAsync; }