public TaskAllocator(ITaskMetadataManager metadataManager, ITaskRepository taskRepository, IOptions <TaskAllocatorOptions> options, ILogger <TaskAllocator> logger)
{
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
if (string.IsNullOrEmpty(options.Value.Name))
{
throw new ArgumentNullException(nameof(TaskAllocatorOptions.Name));
}
var optionsValue = options.Value;
Name = options.Value.Name;
if (optionsValue.TimeoutWaitingTasksPerExecutor > TimeSpan.Zero)
{
timeoutWaitingTasksPerExecutor = optionsValue.TimeoutWaitingTasksPerExecutor;
}
if (optionsValue.MaxTasksPerExecutor > 0)
{
maxTasksPerExecutor = optionsValue.MaxTasksPerExecutor;
}
MetadataManager = metadataManager ?? throw new ArgumentNullException(nameof(metadataManager));
this.taskRepository = taskRepository ?? throw new ArgumentNullException(nameof(taskRepository));
commandQueue = new TaskQueue(metadataManager.Tasks.Select(it => it.TaskType).ToArray());
this.logger = logger;
}
public static bool HasTaskType <TTask>(this ITaskMetadataManager taskMetadataManager)
{
if (taskMetadataManager == null)
{
throw new ArgumentNullException(nameof(taskMetadataManager));
}
return(taskMetadataManager.HasTaskType(typeof(TTask)));
}
public TaskMetadataManagerTests()
{
var services = new ServiceCollection();
services.AddWorkerCore()
.AddTaskType(typeof(TestTask));
serviceProvider = services.BuildServiceProvider();
serviceScope = serviceProvider.CreateScope();
metadataManager = serviceScope.ServiceProvider.GetService <ITaskMetadataManager>();
}
public TaskAllocatorTests()
{
host = new HostBuilder()
.ConfigureServices((hostContext, services) =>
{
services
.AddWorkerAllocator(options =>
{
options.TimeoutWaitingTasksPerExecutor = TimeSpan.FromSeconds(2);
options.MaxTasksPerExecutor = 2;
})
.AddTaskType <TestTask>();
services.AddSingleton <TaskAllocator>();
})
.Build();
metadataManager = host.Services.GetRequiredService <ITaskMetadataManager>();
allocator = (TaskAllocator)host.Services.GetRequiredService <ITaskAllocator>();
}
public ITaskRepositoryTests()
{
host = new HostBuilder()
.ConfigureServices((hostContext, services) =>
{
services
.AddWorkerAllocator(options =>
{
options.TimeoutWaitingTasksPerExecutor = TimeSpan.FromSeconds(2);
})
.AddTaskRepository <MemoryTaskRepository>()
.AddTaskType(typeof(TestTask));
services.AddSingleton <TaskAllocator>();
})
.Build();
metadataManager = host.Services.GetRequiredService <ITaskMetadataManager>();
allocator = host.Services.GetRequiredService <ITaskAllocator>();
taskRepository = (MemoryTaskRepository)host.Services.GetRequiredService <ITaskRepository>();
}
public HandlerTest()
{
var services = new ServiceCollection();
services.AddLogging();
var workerBuilder = services.AddWorkerAllocator(OnConfigureAllocator);
workerBuilder.AddTaskType <TCommand>();
var executorBuilder = workerBuilder.AddExecutor();
executorBuilder.MapTaskHandler <TCommand, THandler>();
OnConfigureServices(services);
ServiceProvider = services.BuildServiceProvider();
ServiceScope = ServiceProvider.CreateScope();
Allocator = ServiceScope.ServiceProvider.GetRequiredService <ITaskAllocator>();
Executor = ServiceScope.ServiceProvider.GetRequiredService <TaskExecutor>();
TaskService = ServiceScope.ServiceProvider.GetRequiredService <ITaskService>();
TaskMetadataManager = ServiceScope.ServiceProvider.GetRequiredService <ITaskMetadataManager>();
}
public LocalTaskAllocator(ITaskMetadataManager metadataManager, ITaskRepository taskRepository, IOptions <TaskAllocatorOptions> options, IServiceProvider serviceProvider, ILogger <TaskAllocator> logger) : base(metadataManager, taskRepository, options, logger)
{
this.serviceProvider = serviceProvider ?? throw new ArgumentNullException(nameof(serviceProvider));
}
public MongoDbTaskRepository(MongoDB.IWorkerMongoDbContext dbContext, ITaskMetadataManager taskMetadataManager)
{
this.taskMetadataManager = taskMetadataManager ?? throw new ArgumentNullException(nameof(taskMetadataManager));
this.dbContext = dbContext ?? throw new ArgumentNullException(nameof(dbContext));
}
public RemoteTaskAllocator(WorkerServiceClient workerClient, ITaskMetadataManager metadataManager, IServiceProvider serviceProvider, ILogger <RemoteTaskAllocator> logger)
{
this.workerClient = workerClient ?? throw new ArgumentNullException(nameof(workerClient));
this.serviceProvider = serviceProvider ?? throw new ArgumentNullException(nameof(serviceProvider));
this.logger = logger ?? throw new ArgumentNullException(nameof(logger));
}
public TaskExecutor(ITaskAllocator taskAllocator, ITaskHandlerLocator handlerLocator, ITaskMetadataManager metadataManager, IServiceProvider serviceProvider, ILogger <TaskExecutor> logger)
{
this.taskAllocator = taskAllocator ?? throw new ArgumentNullException(nameof(taskAllocator));
this.serviceProvider = serviceProvider ?? throw new ArgumentNullException(nameof(serviceProvider));
this.logger = logger ?? throw new ArgumentNullException(nameof(logger));
foreach (var taskType in handlerLocator.TaskTypes)
{
var taskMetadata = metadataManager.FindTaskMetadata(taskType);
if (taskMetadata == null)
{
throw new InvalidOperationException();
}
handlerFactories.Add(taskType, new TaskHandlerMetadata(taskMetadata.TaskName, HandlerBaseType.MakeGenericType(taskType)));
}
}
