/// <summary> /// Creates an instance of <see cref="SequentialTaskProcessor"/> for /// sequential task processing, using common configuration settings. /// </summary> /// <param name="vaultApplication">The vault application this task processor is associated with.</param> /// <param name="queueId">The queue Id (must be unique in the vault) that this application is processing.</param> /// <param name="taskHandlers">The task Ids and handlers that this processor can handle.</param> /// <param name="cancellationTokenSource">The cancellation token source.</param> /// <param name="maxPollingInterval">The maximum interval (in seconds) between polling.</param> /// <param name="automaticallyRegisterQueues">If true, automatically calls <see cref="AppTaskBatchProcessor.RegisterTaskQueues"/>.</param> /// <param name="automaticallyStartPolling">If true, automatically calls <see cref="TaskQueueManager.EnableTaskPolling"/>.</param> /// <returns>The sequential batch processor.</returns> internal static SequentialTaskProcessor CreateSequentialTaskProcessor ( this VaultApplicationBase vaultApplication, AppTaskProcessorSettings processorSettings, bool automaticallyRegisterQueues = true, bool automaticallyStartPolling = true, CancellationTokenSource cancellationTokenSource = default ) { // Sanity. if (null == vaultApplication) { throw new ArgumentNullException(nameof(vaultApplication)); } if (null == processorSettings) { throw new ArgumentNullException(nameof(processorSettings)); } if (processorSettings.QueueDef.TaskType != TaskQueueManager.TaskType.ApplicationTasks) { throw new ArgumentException("The processor settings queue definition task type must be ApplicationTasks.", nameof(processorSettings)); } if (processorSettings.QueueDef.ProcessingBehavior != MFTaskQueueProcessingBehavior.MFProcessingBehaviorSequential) { throw new ArgumentException("The processor settings queue definition processing behaviour must be MFProcessingBehaviorSequential.", nameof(processorSettings)); } if (null == processorSettings.TaskHandlers) { throw new ArgumentException("The processor settings must have at least one task handler defined.", nameof(processorSettings)); } if (processorSettings.TaskHandlers.Count == 0) { throw new ArgumentException("The processor settings must have at least one task handler defined.", nameof(processorSettings)); } if (processorSettings.TaskHandlers.Any(kvp => kvp.Value == null)) { throw new ArgumentException("Task handlers cannot be null.", nameof(processorSettings)); } // Ensure the integer values are valid. if (processorSettings.MaxConcurrentJobs <= 0) { SysUtils.ReportToEventLog ( "The maximum concurrent jobs must be a positive integer; using default.", System.Diagnostics.EventLogEntryType.Warning ); processorSettings.MaxConcurrentJobs = 5; } if (processorSettings.QueueDef.MaximumPollingIntervalInSeconds <= 0) { SysUtils.ReportToEventLog ( "The maximum polling interval must be a positive integer; using default.", System.Diagnostics.EventLogEntryType.Warning ); processorSettings.QueueDef.MaximumPollingIntervalInSeconds = 10; } // Create the processor. var processor = new SequentialTaskProcessor ( processorSettings, cancellationTokenSource?.Token ?? default ); // Should we automatically register the task queues? if (automaticallyRegisterQueues) { processor.RegisterTaskQueues(); } // Enable polling/processing of the queue. if (automaticallyStartPolling) { vaultApplication.TaskQueueManager.EnableTaskPolling(true); } // Return the processor. return(processor); }
/// <summary> /// Creates an instance of <see cref="SequentialTaskProcessor"/> for /// sequential task processing, using common configuration settings. /// </summary> /// <param name="vaultApplication">The vault application this task processor is associated with.</param> /// <param name="queueId">The queue Id (must be unique in the vault) that this application is processing.</param> /// <param name="taskHandlers">The task Ids and handlers that this processor can handle.</param> /// <param name="cancellationTokenSource">The cancellation token source.</param> /// <param name="maxPollingInterval">The maximum interval (in seconds) between polling.</param> /// <param name="automaticallyRegisterQueues">If true, automatically calls <see cref="AppTaskBatchProcessor.RegisterTaskQueues"/>.</param> /// <param name="automaticallyStartPolling">If true, automatically calls <see cref="TaskQueueManager.EnableTaskPolling"/>.</param> /// <returns>The sequential batch processor.</returns> public static SequentialTaskProcessor CreateSequentialTaskProcessor ( this VaultApplicationBase vaultApplication, string queueId, Dictionary <string, TaskProcessorJobHandler> taskHandlers, int maxPollingInterval = 10, bool automaticallyRegisterQueues = true, bool automaticallyStartPolling = true, string vaultExtensionProxyMethodId = null, CancellationTokenSource cancellationTokenSource = default ) { // Sanity. if (null == vaultApplication) { throw new ArgumentNullException(nameof(vaultApplication)); } if (string.IsNullOrWhiteSpace(queueId)) { throw new ArgumentException("A queue Id must be provided.", nameof(queueId)); } if (null == taskHandlers) { throw new ArgumentNullException(nameof(taskHandlers)); } if (taskHandlers.Count == 0) { throw new ArgumentException("No task handlers were registered.", nameof(taskHandlers)); } if (taskHandlers.Count == 0) { throw new ArgumentException("No task handlers were registered.", nameof(taskHandlers)); } if (taskHandlers.Any(kvp => kvp.Value == null)) { throw new ArgumentException("Task handlers cannot be null.", nameof(taskHandlers)); } // Ensure the integer values are valid. if (maxPollingInterval <= 0) { SysUtils.ReportToEventLog ( "The maximum polling interval must be a positive integer; using default.", System.Diagnostics.EventLogEntryType.Warning ); maxPollingInterval = 10; } // Create the processor settings. var processorSettings = new AppTaskProcessorSettings { PollTasksOnJobCompletion = true, MaxConcurrentJobs = 1, // Always 1 for a sequential task processor. PermanentVault = vaultApplication.PermanentVault, EnableAutomaticTaskUpdates = true, QueueDef = new TaskQueueDef { TaskType = TaskQueueManager.TaskType.ApplicationTasks, Id = queueId, ProcessingBehavior = MFTaskQueueProcessingBehavior.MFProcessingBehaviorSequential, MaximumPollingIntervalInSeconds = maxPollingInterval, LastBroadcastId = "" }, TaskHandlers = taskHandlers, TaskQueueManager = vaultApplication.TaskQueueManager, VaultExtensionMethodProxyId = vaultExtensionProxyMethodId }; // Use the other overload. return(vaultApplication.CreateSequentialTaskProcessor ( processorSettings, automaticallyRegisterQueues, automaticallyStartPolling, cancellationTokenSource )); }