ToolWheel.Extensions.JobManager 1.0.0-preview6

ToolWheel.Extensions.JobManager

Core runtime library for the ToolWheel Job Manager. Provides default implementations of the abstractions, the DI registration entry point and the middleware pipeline.

Package Info

DI Registration

Callback style

var builder = Host.CreateApplicationBuilder(args);

builder.Services.AddJobManager(configure =>
{
    configure.AddExecutionCondition<MyCondition>();
    configure.AddMiddleware<AuditMiddleware>();
    configure.ConfigureServices(svc => svc.AddSingleton<IAuditLog, FileAuditLog>());

    configure.ConfigureJobs(jobs =>
    {
        var worker = new ReportWorker();
        jobs.Add("daily-report", worker.Generate)
            .Name("Daily Report")
            .Description("Generates the daily sales report")
            .Enabled();
    });
});

Startup class style

builder.Services.AddJobManager<MyStartup>();

public class MyStartup : JobManagerStartup
{
    public override void ConfigureJobManager(IJobManagerConfigurationBuilder configure)
    {
        configure.AddMiddleware<AuditMiddleware>();
    }

    public override void ConfigureJobs(IJobDescriptionCollection collection)
    {
        var worker = new ReportWorker();
        collection.Add("daily-report", worker.Generate)
            .Name("Daily Report")
            .Enabled();
    }
}

Services

JobService

Default implementation of IJobService. Maintains an in-memory ConcurrentDictionary<string, IJob> registry and delegates execution to IJobTaskService.

After a job is registered, Add iterates the features on the IJobDescription and calls IJobManagerFeature.Apply(serviceProvider, jobDescription, job) on each one. This is the single, unified hook for extension features to register per-job data with their runtime services (trigger schedules, retry policies, �). It works identically for jobs registered at startup and for jobs added dynamically at runtime.

var jobService = serviceProvider.GetRequiredService<IJobService>();

// Add � Apply is called for every attached feature
IJob job = jobService.Add(jobDescription);

// Add dynamically at runtime
IJob job = jobService.Add(worker.DoWork, b => b
    .Name("Dynamic Job")
    .WithFeature<TriggerFeature>(f => f.Add(new IntervalTrigger(TimeSpan.FromMinutes(5)))));

IJob? found = jobService.FindById("my-job");
IJob  read  = jobService.ReadById("my-job"); // throws KeyNotFoundException when missing
IEnumerable<IJob> all = jobService.ReadAll();

IJobTask task = await jobService.ExecuteAsync(job);
bool removed  = jobService.Remove(job);

JobTaskService

Default implementation of IJobTaskService. Creates JobTask instances, delegates execution to IJobTaskExecutionService and tracks active tasks.

CancelAllAndWaitAsync signals cancellation on all tracked tasks and awaits their completion � called during graceful shutdown.

JobTaskExecutionService

Builds the middleware pipeline for a job task and executes it. Before the pipeline starts, execution conditions are evaluated via IJobExecutionEvaluatorService. If any condition returns not-ready, the task status is set to NotReady and execution is skipped.

Built-in pipeline steps (innermost last):

1. JobTaskTargetObjectMiddleware � resolves TargetObject from DI when it is null.
2. The final step invokes IJob.TargetMethod.

JobExecutionEvaluatorService

Evaluates all registered execution conditions without starting a task and returns the aggregated JobConditionStatus. Useful for pre-flight checks.

var evaluator = serviceProvider.GetRequiredService<IJobExecutionEvaluatorService>();
var status = await evaluator.EvaluateAsync(job);

if (status.Status == JobConditionStatusEnum.NotReady)
    Console.WriteLine($"Job not ready: {status.Message}");

Built-in Middleware and Conditions

Singleton Instances

When a job is configured with .AsSingleton(), JobTaskTargetObjectMiddleware creates the target instance once on the first execution and caches it for all subsequent executions. Without .AsSingleton() a fresh instance is resolved from DI on every execution.

jobs.Add<MyWorker>(w => w.Process)
    .Name("Singleton Worker")
    .AsSingleton();

Auto Feature Configuration

AddJobManager scans all loaded assemblies, finds every non-abstract IAutoFeatureConfigurator implementation and calls AutoConfigure(builder) on each. Configurators register services only (middleware, conditions, singletons).

Per-job feature data flows through a separate path:

Startup:  AddJobManager ? IAutoFeatureConfigurator.AutoConfigure   (services)
                        ? JobService.Add ? IJobManagerFeature.Apply (per-job data)

Runtime:  JobService.Add ? IJobManagerFeature.Apply                (per-job data)

Implementing a custom feature

// 1. Feature � override Apply to push per-job data into a runtime service
public class NotifyFeature : IJobManagerFeature
{
    public string WebhookUrl { get; set; } = string.Empty;

    public void Apply(IServiceProvider serviceProvider, IJobDescription jobDescription, IJob job)
    {
        serviceProvider.GetRequiredService<INotifyService>()
            .Register(job.Id, WebhookUrl);
    }
}

// 2. Configurator � registers the runtime service once
public class NotifyConfigurator : IAutoFeatureConfigurator
{
    public void AutoConfigure(IJobManagerConfigurationBuilder builder)
    {
        builder.ConfigureServices(services =>
            services.AddSingleton<INotifyService, NotifyService>());
    }
}

// 3. Usage
jobs.Add("my-job", worker.Run)
    .WithFeature<NotifyFeature>(f => f.WebhookUrl = "https://hooks.example.com/notify");

Job Task Journal

Each IJobTask exposes a Journal of JobTaskJournalEntry records. When a per-job logger is configured via .WithLogger(...), journal entries are forwarded to it through JobTaskJournalLoggerAdapter.