/// <summary>
/// Registers the task queue used by this application or module.
/// </summary>
public void RegisterTaskQueues()
{
// Create the cancellation token source.
if (this.TokenSource == null)
{
this.TokenSource = new CancellationTokenSource();
}
// Create the task processor.
if (this.TaskProcessor == null)
{
// Initialize the task processor.
this.TaskProcessor = new AppTaskBatchProcessor
(
new AppTaskBatchProcessorSettings
{
QueueDef = new TaskQueueDef
{
TaskType = TaskQueueManager.TaskType.Both,
Id = VaultApplication.BackgroundOperationTaskQueueId,
ProcessingBehavior = MFTaskQueueProcessingBehavior.MFProcessingBehaviorConcurrent,
MaximumPollingIntervalInSeconds = this.Configuration.MaxPollingIntervalInSeconds,
LastBroadcastId = ""
},
PermanentVault = this.PermanentVault,
MaxConcurrentBatches = this.Configuration.MaxConcurrentBatches,
MaxConcurrentJobs = this.Configuration.MaxConcurrentJobs,
TaskHandlers = new Dictionary <string, TaskProcessorJobHandler>
{
{ VaultApplication.TaskTypeHourlyRecurringTask, ProcessHourlyTask }
},
TaskQueueManager = this.TaskQueueManager,
EnableAutomaticTaskUpdates = true,
DisableAutomaticProgressUpdates = false,
PollTasksOnJobCompletion = true
},
this.TokenSource.Token
);
// Schedule the hourly task.
ScheduleHourlyTask();
}
// Register the task queue.
this.TaskProcessor.RegisterTaskQueues();
// Ensure that the configuration broadcast queue is initialized.
this.InitializeConfigurationBroadcastProcessor();
}
/// <summary>
/// Initializes the configuration broadcast task processor.
/// - This processor also handles the rebroadcast messages from the SaveCommand from the MFAdmin.
/// </summary>
private void InitializeConfigurationBroadcastProcessor()
{
// Verify the broadcast task processor token source has been created.
if (this.ConfigurationBroadcastTokenSource == null)
{
this.ConfigurationBroadcastTokenSource = new CancellationTokenSource();
}
// Initialize the batch task processor.
if (this.ConfigurationBroadcastProcessor == null)
{
this.ConfigurationBroadcastProcessor = new AppTaskBatchProcessor(
new AppTaskBatchProcessorSettings
{
QueueDef = new TaskQueueDef
{
TaskType = TaskQueueManager.TaskType.BroadcastMessages,
Id = ConfigurationBroadcastTaskQueueId,
ProcessingBehavior = MFTaskQueueProcessingBehavior.MFProcessingBehaviorConcurrent,
MaximumPollingIntervalInSeconds = this.Configuration.MaxPollingIntervalInSeconds,
LastBroadcastId = ""
},
PermanentVault = this.PermanentVault,
MaxConcurrentBatches = 5,
MaxConcurrentJobs = 5,
// This does not require any task handlers, but if other broadcast tasks are used then they could be added here.
TaskHandlers = new Dictionary <string, TaskProcessorJobHandler>()
{
// Note that we have to provide at least one task handler or the underlying call excepts.
{ Guid.NewGuid().ToString(), (j) => { } }
},
TaskQueueManager = this.TaskQueueManager,
EnableAutomaticTaskUpdates = true,
DisableAutomaticProgressUpdates = false,
PollTasksOnJobCompletion = true,
VaultExtensionMethodProxyId = this.GetVaultExtensionMethodEventHandlerProxyName()
},
this.ConfigurationBroadcastTokenSource.Token);
}
// Register the task queues.
this.ConfigurationBroadcastProcessor.RegisterTaskQueues();
}
/// <inheritdoc />
public override string GetRebroadcastQueueId()
{
// If we do not have a rebroadcast queue for the configuration data
// then create one.
if (null == this.ConfigurationRebroadcastTaskProcessor)
{
// Enable the configuration rebroadcasting.
this.EnableConfigurationRebroadcasting
(
out AppTaskBatchProcessor processor,
out string queueId
);
// Populate references to the task processor and queue Id.
this.ConfigurationRebroadcastQueueId = queueId;
this.ConfigurationRebroadcastTaskProcessor = processor;
}
// Return the broadcast queue Id.
return(this.ConfigurationRebroadcastQueueId);
}
/// <summary>
/// Creates a background operation manager for a given queue.
/// </summary>
/// <param name="vaultApplication">The vault application that contains this background operation manager.</param>
/// <param name="queueId">The queue Id.</param>
/// <param name="cancellationTokenSource">The cancellation token source, if cancellation should be supported.</param>
public TaskQueueBackgroundOperationManager
(
VaultApplicationBase vaultApplication,
string queueId,
CancellationTokenSource cancellationTokenSource = default
)
{
// Sanity.
if (string.IsNullOrWhiteSpace(queueId))
{
throw new ArgumentException("The queue id cannot be null or whitespace.", nameof(queueId));
}
// Assign.
this.CancellationTokenSource = cancellationTokenSource;
this.VaultApplication = vaultApplication ?? throw new ArgumentNullException(nameof(vaultApplication));
this.QueueId = queueId;
// Set up the task processor
this.TaskProcessor = this
.VaultApplication
.CreateConcurrentTaskProcessor
(
this.QueueId,
new Dictionary <string, TaskProcessorJobHandler>
{
{ TaskQueueBackgroundOperation.TaskTypeId, this.ProcessJobHandler }
},
cancellationTokenSource: cancellationTokenSource == null
? new CancellationTokenSource()
: CancellationTokenSource.CreateLinkedTokenSource(cancellationTokenSource.Token)
);
// Ensure we have a current server.
TaskQueueBackgroundOperationManager.SetCurrentServer(vaultApplication);
// Register the task queues.
this.TaskProcessor.RegisterTaskQueues();
}
/// <summary>
/// Enables rebroadcasting of the configuration data to all servers.
/// </summary>
/// <typeparam name="TSecureConfiguration">The configuration type.</typeparam>
/// <param name="vaultApplication">The vault application to enable rebroadcasting for.</param>
/// <param name="broadcastTaskProcessor">The processor used to process the configuration rebroadcasting queue.</param>
/// <param name="broadcastTaskQueueId">The queue Id used for the configuration rebroadcasting.</param>
/// <param name="taskHandlers">Handlers for any additional tasks that the queue should handle.</param>
/// <param name="maxConcurrentBatches">The maximum number of concurrent batches.</param>
/// <param name="maxConcurrentJobs">The maximum number of concurrent jobs.</param>
/// <param name="maxPollingInterval">The maximum polling interval.</param>
/// <param name="cancellationTokenSource">The token source for cancellation.</param>
public static void EnableConfigurationRebroadcasting <TSecureConfiguration>
(
this ConfigurableVaultApplicationBase <TSecureConfiguration> vaultApplication,
out AppTaskBatchProcessor broadcastTaskProcessor,
out string broadcastTaskQueueId,
Dictionary <string, TaskProcessorJobHandler> taskHandlers = null,
int maxConcurrentBatches = 5,
int maxConcurrentJobs = 5,
int maxPollingInterval = 10,
CancellationTokenSource cancellationTokenSource = default
)
where TSecureConfiguration : class, new()
{
// Sanity.
if (null == vaultApplication)
{
throw new ArgumentNullException(nameof(vaultApplication));
}
// We must have at least one task handler or the underlying implementation throws.
taskHandlers = taskHandlers ?? new Dictionary <string, TaskProcessorJobHandler>();
if (taskHandlers.Count == 0)
{
taskHandlers.Add(Guid.NewGuid().ToString(), (j) => { });
}
// Set up the broadcast task queue ID. This is specific for this application.
broadcastTaskQueueId = $"{vaultApplication.GetType().FullName.Replace(".", "-")}-ConfigurationRebroadcastQueue";
// Create the settings instance.
var processorSettings = new AppTaskBatchProcessorSettings
{
QueueDef = new TaskQueueDef
{
TaskType = TaskQueueManager.TaskType.BroadcastMessages,
Id = broadcastTaskQueueId,
ProcessingBehavior = MFTaskQueueProcessingBehavior.MFProcessingBehaviorConcurrent,
MaximumPollingIntervalInSeconds = maxPollingInterval,
LastBroadcastId = ""
},
PermanentVault = vaultApplication.PermanentVault,
MaxConcurrentBatches = maxConcurrentBatches,
MaxConcurrentJobs = maxConcurrentJobs,
TaskHandlers = taskHandlers,
TaskQueueManager = vaultApplication.TaskQueueManager,
EnableAutomaticTaskUpdates = true,
DisableAutomaticProgressUpdates = false,
PollTasksOnJobCompletion = true,
VaultExtensionMethodProxyId = vaultApplication.GetVaultExtensionMethodEventHandlerProxyName()
};
// Set up the cancellation token source.
cancellationTokenSource = cancellationTokenSource == null
? new CancellationTokenSource()
: CancellationTokenSource.CreateLinkedTokenSource(cancellationTokenSource.Token);
// Create the broadcast processor using the vault extension method.
broadcastTaskProcessor = vaultApplication.CreateBroadcastTaskProcessor
(
processorSettings,
cancellationTokenSource: cancellationTokenSource
);
}
