using System.Text.Json; using Chronos.Core.Model; using Chronos.Data; using Chronos.Data.Jobs; using Chronos.Data.Processing; using Chronos.Protocol; using Chronos.Server.Jobs; using Chronos.Server.Security; using Chronos.Server.Storage; namespace Chronos.Server.Api; /// /// /api/v1/jobs (BRIEF §14.6): queue and history, creation (a render batch becomes one job per preset), cancel, /// pause, resume, retry and priority. Changes reach WebSocket clients as jobState and jobProgress events. /// public static class JobEndpoints { /// Kinds that work on sequences (targets are sequence ids) and need the edit right. private static readonly HashSet SequenceKinds = [JobKind.LightAnalyse, JobKind.DeepAnalyse, JobKind.Proxies, JobKind.Thumbs, JobKind.Verify]; /// Archive-wide maintenance (target: the archive) for administrators. private static readonly HashSet ArchiveKinds = [JobKind.Scan, JobKind.Rebuild, JobKind.Maintenance, JobKind.Duplicates, JobKind.Orphans]; public static void Map(RouteGroupBuilder api) { var jobs = api.MapGroup("/jobs").Requires(Permissions.Read); jobs.MapGet("", ListAsync); jobs.MapPost("", CreateAsync); jobs.MapGet("/{id:guid}", async (HttpContext context, Guid id, ChronosDatabase db) => await db.Jobs.GetAsync(id, context.RequestAborted) is { } job ? Results.Json(Dto.Job(job), ProtocolJson.Default.JobDto) : ApiErrors.NotFound(context, "job")); jobs.MapPost("/{id:guid}/cancel", (HttpContext c, Caller caller, Guid id, ChronosDatabase db, JobEngineHost host) => ActAsync(c, caller, id, db, [JobState.Queued, JobState.Running, JobState.Paused], (job, ct) => host.Engine.CancelAsync(job.Id, ct))); jobs.MapPost("/{id:guid}/pause", (HttpContext c, Caller caller, Guid id, ChronosDatabase db, JobEngineHost host) => ActAsync(c, caller, id, db, [JobState.Queued, JobState.Running], (job, ct) => host.Engine.PauseAsync(job.Id, ct))); jobs.MapPost("/{id:guid}/resume", (HttpContext c, Caller caller, Guid id, ChronosDatabase db, JobEngineHost host) => ActAsync(c, caller, id, db, [JobState.Paused], (job, ct) => host.Engine.ResumeAsync(job.Id, ct))); jobs.MapPost("/{id:guid}/retry", (HttpContext c, Caller caller, Guid id, ChronosDatabase db, JobEngineHost host) => ActAsync(c, caller, id, db, [JobState.Failed, JobState.Cancelled], (job, ct) => host.Engine.ResumeAsync(job.Id, ct))); jobs.MapPost("/{id:guid}/priority", PriorityAsync); } private static async Task ListAsync(HttpContext context, ChronosDatabase db, string? state, string? kind, string? cursor, int? limit) { JobState? stateFilter = null; JobKind? kindFilter = null; if (!string.IsNullOrEmpty(state)) { if (!JobWire.TryParseState(state, out var s)) return ApiErrors.BadRequest(context, "invalid_filter", "state"); stateFilter = s; } if (!string.IsNullOrEmpty(kind)) { if (!JobWire.TryParseKind(kind, out var k)) return ApiErrors.BadRequest(context, "invalid_filter", "kind"); kindFilter = k; } // A job's answer holds no parameters (a conversion's or an import's can name every sequence or file): the list reads none. var page = await db.Jobs.ListBriefAsync(stateFilter, kindFilter, limit ?? 50, string.IsNullOrEmpty(cursor) ? null : cursor, context.RequestAborted); return Results.Json(new Page([.. page.Items.Select(Dto.Job)], page.NextCursor, null), ProtocolJson.Default.PageJobDto); } private static async Task CreateAsync(HttpContext context, Caller caller, CreateJobRequest request, ChronosDatabase db, JobEngineHost host, ServerArchive archive, AuditLog audit) { var ct = context.RequestAborted; if (!JobWire.TryParseKind(request.Kind, out var kind) || !(kind == JobKind.Render || SequenceKinds.Contains(kind) || ArchiveKinds.Contains(kind))) return ApiErrors.BadRequest(context, "invalid_job_kind"); var needed = kind == JobKind.Render ? Permissions.Render : SequenceKinds.Contains(kind) ? Permissions.Edit : Permissions.ManageArchive; if (!caller.Has(needed)) return ApiErrors.Forbidden(context); if (!host.CanRun(kind)) return ApiErrors.Conflict(context, "job_unavailable", JobWire.Kind(kind)); IReadOnlyList targets; string label; if (ArchiveKinds.Contains(kind)) { targets = [archive.Id]; label = archive.Current.Name; } else { var ids = request.Target ?? []; if (ids.Count == 0 || (kind == JobKind.Render && ids.Count != 1)) return ApiErrors.BadRequest(context, "invalid_parameters", "target"); var titles = new List(ids.Count); foreach (var id in ids) { if (await db.Sequences.GetAsync(id, ct) is not { } sequence) return ApiErrors.NotFound(context, "sequence"); titles.Add(sequence.DisplayTitle); } targets = ids; label = titles.Count == 1 ? titles[0] : string.Join(", ", titles.Take(3)) + (titles.Count > 3 ? " …" : string.Empty); } List<(string Label, string? Parameters)> queue = [(label, request.ParametersJson)]; if (kind == JobKind.Render) { if (ParseRender(request.ParametersJson) is not { } render) return ApiErrors.BadRequest(context, "invalid_parameters", "parametersJson"); // A batch becomes one job per preset: a render node uploads one file per job (BRIEF §14.7). IReadOnlyList each; try { var (width, height) = await SourceSizeAsync(db, targets[0], render, ct); each = ProcessingJobs.Split(render, width, height); } catch (InvalidDataException) { return ApiErrors.BadRequest(context, "invalid_parameters", "parametersJson"); } queue = each.Count == 1 ? [(ProcessingJobs.RenderLabel(label, render.PresetName), request.ParametersJson)] : [.. each.Select(p => (ProcessingJobs.RenderLabel(label, p.PresetName), (string?)JsonSerializer.Serialize(p, ProtocolJson.Default.RenderJobParameters)))]; } else if (request.ParametersJson is not null && !IsJsonObject(request.ParametersJson)) { return ApiErrors.BadRequest(context, "invalid_parameters", "parametersJson"); } if (kind == JobKind.Verify) { // A verify of sequences targets their archive and names them in its parameters, as its handler reads it. var verify = LibraryEndpoints.SequenceJob(kind, archive.Current, targets, label); targets = verify.Targets; queue = [(label, verify.ParametersJson)]; } Job? first = null; foreach (var (jobLabel, parameters) in queue) { var job = await host.Engine.EnqueueAsync(kind, targets, jobLabel, parameters, JobPriority.User, caller.Id, ct); await audit.WriteAsync(caller, context, "job_created", "job", job.Id.ToString(), $"{JobWire.Kind(kind)} · {jobLabel}"); first ??= job; } return Results.Json(Dto.Job(first!), ProtocolJson.Default.JobDto, statusCode: StatusCodes.Status202Accepted); } /// The oriented size of the sequence's first frame (what a preset without a fixed size renders at), else the job's size. private static async Task<(int Width, int Height)> SourceSizeAsync(ChronosDatabase db, Guid sequenceId, RenderJobParameters render, CancellationToken ct) => (await db.Frames.ListBySequenceAsync(sequenceId, limit: 1, cancellationToken: ct)).FirstOrDefault() is { Width: > 0, Height: > 0 } frame ? frame.Orientation is >= 5 and <= 8 ? (frame.Height, frame.Width) : (frame.Width, frame.Height) : (render.Width, render.Height); private static async Task PriorityAsync(HttpContext context, Caller caller, Guid id, JobPriorityRequest request, ChronosDatabase db, JobEngineHost host) { if (!JobWire.TryParsePriority(request.Priority, out var priority)) return ApiErrors.BadRequest(context, "invalid_priority"); return await ActAsync(context, caller, id, db, [JobState.Queued, JobState.Paused], async (job, ct) => { await db.Jobs.SetPriorityAsync(job.Id, priority, ct); host.Publish(job with { Priority = priority }); }); } /// Applies when the job is in one of states and the caller created it or administers the archive. private static async Task ActAsync(HttpContext context, Caller caller, Guid id, ChronosDatabase db, JobState[] allowed, Func action) { var ct = context.RequestAborted; if (await db.Jobs.GetAsync(id, ct) is not { } job) return ApiErrors.NotFound(context, "job"); if (job.CreatedBy != caller.Id && !caller.Has(Permissions.ManageArchive)) return ApiErrors.Forbidden(context); if (!allowed.Contains(job.State)) return ApiErrors.Conflict(context, "invalid_state", JobWire.State(job.State)); await action(job, ct); var updated = await db.Jobs.GetAsync(id, ct) ?? job; return Results.Json(Dto.Job(updated), ProtocolJson.Default.JobDto); } /// Render parameters, or null when they are missing or incomplete. public static RenderJobParameters? ParseRender(string? json) { if (string.IsNullOrWhiteSpace(json)) return null; try { var p = JsonSerializer.Deserialize(json, ProtocolJson.Default.RenderJobParameters); return p is { PresetName.Length: > 0, PresetJson.Length: > 0, Codec.Length: > 0, Width: > 0, Height: > 0 } && IsJsonObject(p.PresetJson) ? p : null; } catch (JsonException) { return null; } } private static bool IsJsonObject(string json) { try { using var document = JsonDocument.Parse(json); return document.RootElement.ValueKind == JsonValueKind.Object; } catch (JsonException) { return false; } } }