public PostgreSqlTaskQueueConsumer(TaskQueueConsumerOptions options, ITimestampProvider timestampProvider)
        {
            if (options == null)
            {
                throw new ArgumentNullException(nameof(options));
            }
            if (timestampProvider == null)
            {
                throw new ArgumentNullException(nameof(timestampProvider));
            }

            mOptions           = options;
            mTimestampProvider = timestampProvider;

            mSignalingConnectionString = options.ConnectionOptions
                                         .ConnectionString
                                         .DeriveSignalingConnectionString(options);

            mNotificationListener = new PostgreSqlTaskQueueNotificationListener(mSignalingConnectionString,
                                                                                options.Mapping.NewTaskNotificationChannelName);

            mNotificationListener.ListenerConnectionRestored +=
                HandleListenerConnectionRestored;
            mNotificationListener.NewTaskPosted +=
                HandleNewTaskUpdateReceived;
            mNotificationListener.ListenerTimedOutWhileWaiting +=
                HandleListenerTimedOut;

            mTaskDequeueSql      = GetTaskDequeueSql(options.Mapping);
            mTaskAcquireSql      = GetTaskAcquireSql(options.Mapping);
            mTaskResultUpdateSql = GetTaskResultUpdateSql(options.Mapping);
        }
        public PostgreSqlTaskQueueConsumerTests()
        {
            mConsumerOptions = TestOptions
                               .GetDefaultTaskQueueConsumerOptions(ConnectionString);

            mDataSource = new PostgreSqlTaskQueueDataSource(mConsumerOptions.ConnectionOptions.ConnectionString,
                                                            TestOptions.DefaultMapping,
                                                            queueFaultErrorThrehsoldCount: 5);
        }
        public PostgreSqlTaskQueueOperationsConsistencyTests()
        {
            mInfoOptions = TestOptions
                           .GetDefaultTaskQueueInfoOptions(ConnectionString);
            mConsumerOptions = TestOptions
                               .GetDefaultTaskQueueConsumerOptions(ConnectionString);
            mProducerOptions = TestOptions
                               .GetDefaultTaskQueueProducerAndResultOptions(ConnectionString);

            mDataSource = new PostgreSqlTaskQueueDataSource(mInfoOptions.ConnectionOptions.ConnectionString,
                                                            TestOptions.DefaultMapping,
                                                            queueFaultErrorThrehsoldCount: 5);
        }
示例#4
0
        public StandardTaskEngine(TaskEngineOptions engineOptions,
                                  TaskQueueOptions producerAndResultOptions,
                                  TaskQueueConsumerOptions consumerOptions,
                                  ITaskExecutorRegistry executorRegistry,
                                  IExecutionPerformanceMonitorWriter executionPerfMonWriter,
                                  ITimestampProvider timestampProvider)
        {
            if (engineOptions == null)
            {
                throw new ArgumentNullException(nameof(engineOptions));
            }

            if (consumerOptions == null)
            {
                throw new ArgumentNullException(nameof(consumerOptions));
            }

            if (producerAndResultOptions == null)
            {
                throw new ArgumentNullException(nameof(producerAndResultOptions));
            }

            mExecutorRegistry = executorRegistry
                                ?? throw new ArgumentNullException(nameof(executorRegistry));

            mExecutionPerfMonWriter = executionPerfMonWriter
                                      ?? throw new ArgumentNullException(nameof(executionPerfMonWriter));

            mExecutionPerfMon  = new StandardExecutionPerformanceMonitor();
            mTaskQueueConsumer = new PostgreSqlTaskQueueConsumer(consumerOptions,
                                                                 timestampProvider);
            mTaskQueueProducer = new PostgreSqlTaskQueueProducer(producerAndResultOptions,
                                                                 timestampProvider);

            mTaskResultQueue = new PostgreSqlTaskResultQueue(producerAndResultOptions);

            mTaskBuffer = new StandardTaskBuffer(engineOptions.WorkerCount);
            mTaskPoller = new StandardTaskPoller(engineOptions.TaskProcessingOptions,
                                                 mTaskQueueConsumer,
                                                 mTaskBuffer);

            mOptions = engineOptions;
        }
示例#5
0
        public WorkingTests()
        {
            mTimestampProvider = new UtcNowTimestampProvider();

            mTaskProcessingOptions = TestOptions
                                     .GetDefaultTaskProcessingOptions();

            mProducerAndResultOptions = TestOptions
                                        .GetDefaultTaskQueueProducerAndResultOptions(CommonConnectionString);

            mTaskQueueConsumerOptions = TestOptions
                                        .GetDefaultTaskQueueConsumerOptions(BaseConsumerConnectionString);

            mPostgreSqlExecutionPerformanceMonitorWriterOptions = TestOptions
                                                                  .GetDefaultPostgreSqlExecutionPerformanceMonitorWriterOptions(CommonConnectionString);

            mOperations = new PostgreSqlTaskQueueDbOperations(CommonConnectionString,
                                                              TestOptions.DefaultMapping);
        }
示例#6
0
        public ITaskEngine BuildTaskEngine()
        {
            ITaskExecutorRegistry executorRegistry = mTaskExecutorRegistrySetup
                                                     .BuildTaskExecutorRegistry();

            IExecutionPerformanceMonitorWriter executionPerfMonWriter = mPerformanceMonitorWriterSetup
                                                                        .BuildWriter();

            ITimestampProvider timestampProvider =
                new UtcNowTimestampProvider();

            TaskQueueConsumerOptions consumerOptions = mTaskQueueConsumerSetup
                                                       .BuildOptions();

            TaskQueueOptions producerOptions = mTaskQueueProducerSetup
                                               .BuildOptions();

            StakhanoviseLogManager.Provider = mLoggingProvider
                                              ?? new NoOpLoggingProvider();

            ITaskQueueProducer taskQueueProducer = new PostgreSqlTaskQueueProducer(producerOptions,
                                                                                   timestampProvider);

            ITaskQueueInfo taskQueueInfo = new PostgreSqlTaskQueueInfo(mTaskQueueInfoSetup.BuildOptions(),
                                                                       timestampProvider);

            if (mRegisterOwnDependencies)
            {
                executorRegistry.LoadDependencies(new Dictionary <Type, object>()
                {
                    { typeof(ITaskQueueProducer),
                      taskQueueProducer },
                    { typeof(ITaskQueueInfo),
                      taskQueueInfo }
                });
            }

            return(mTaskEngineSetup.BuildTaskEngine(consumerOptions,
                                                    producerOptions,
                                                    executorRegistry,
                                                    executionPerfMonWriter,
                                                    timestampProvider));
        }
        public ITaskEngine BuildTaskEngine(TaskQueueConsumerOptions consumerOptions,
                                           TaskQueueOptions producerAndResultOptions,
                                           ITaskExecutorRegistry executorRegistry,
                                           IExecutionPerformanceMonitorWriter executionPerfMonWriter,
                                           ITimestampProvider timestampProvider)
        {
            if (consumerOptions == null)
            {
                throw new ArgumentNullException(nameof(consumerOptions));
            }

            if (producerAndResultOptions == null)
            {
                throw new ArgumentNullException(nameof(producerAndResultOptions));
            }

            if (executorRegistry == null)
            {
                throw new ArgumentNullException(nameof(executorRegistry));
            }

            if (executionPerfMonWriter == null)
            {
                throw new ArgumentNullException(nameof(executionPerfMonWriter));
            }

            StandardTaskEngine taskEngine = new StandardTaskEngine(BuildOptions(),
                                                                   producerAndResultOptions,
                                                                   consumerOptions,
                                                                   executorRegistry,
                                                                   executionPerfMonWriter,
                                                                   timestampProvider);

            taskEngine.ScanAssemblies(mExecutorAssemblies);
            return(taskEngine);
        }
        public static string DeriveSignalingConnectionString(this NpgsqlConnectionStringBuilder info, TaskQueueConsumerOptions options)
        {
            if (info == null)
            {
                throw new ArgumentNullException(nameof(info));
            }

            //The connection used for signaling will be
            //  the same as the one used for read-only queue operation
            //  with the notable exceptions that:
            //  a) we need  to activate the Npgsql keepalive mechanism (see: http://www.npgsql.org/doc/keepalive.html)
            //  b) we do not need a large pool - one connection will do

            NpgsqlConnectionStringBuilder signalingConnectionStringInfo = info.Copy();

            signalingConnectionStringInfo.Pooling     = true;
            signalingConnectionStringInfo.MinPoolSize = 1;
            signalingConnectionStringInfo.MaxPoolSize = 2;
            signalingConnectionStringInfo.KeepAlive   = options.ConnectionOptions.ConnectionKeepAliveSeconds;

            return(signalingConnectionStringInfo.ToString());
        }
        public static string DeriveSignalingConnectionString(this string connectionString, TaskQueueConsumerOptions options)
        {
            if (string.IsNullOrEmpty(connectionString))
            {
                throw new ArgumentNullException(nameof(connectionString));
            }

            if (options == null)
            {
                throw new ArgumentNullException(nameof(options));
            }

            NpgsqlConnectionStringBuilder builder = new NpgsqlConnectionStringBuilder(connectionString);

            return(builder.DeriveSignalingConnectionString(options));
        }