Stage A's space guard reserved, before each photo, only that photo and the ones after it, so at the end of a sequence it counted a single photo while up to twice the parallelism were still converting: a volume filling meanwhile could go into the reserve. It now reserves the photo and every photo started whose converted file has not landed yet (a file lands whole, by a rename, before it is verified), so nothing in flight is missed and nothing landed is counted twice, at the end of a sequence as anywhere. The confirmed photo ids (about 21 MB for a million photos) lived in the job's parameters, read by every dry run's busy check, by each sequence turn of the conversion and by the job lists. They are now written whole, under a job id chosen before the job is queued, into convert-<job>.photos beside the journal, and go with it; the row keeps each sequence's digest, so the job still converts exactly the photos confirmed (without the file, the whole plan made again must match). The busy check reads only ids, kinds and targets (and a verify's parameters), never the asking job's row; a conversion's turn reads only its creation time; the server's job list and dashboard and the engine's queue peeks read jobs without parameters. A retried New sequence conversion could make a second copy. The journal now names the copy as soon as its photos are filed; a retry finishes that copy whatever changed in the source since, never remakes one deleted since, and needs no space again for what it holds; and a source another conversion copied in the same format after this one was confirmed is done with, with no copy made (new outcome Superseded, with its job log line). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
192 lines
10 KiB
C#
192 lines
10 KiB
C#
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;
|
|
|
|
/// <summary>
|
|
/// <c>/api/v1/jobs</c> (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 <c>jobState</c> and <c>jobProgress</c> events.
|
|
/// </summary>
|
|
public static class JobEndpoints
|
|
{
|
|
/// <summary>Kinds that work on sequences (targets are sequence ids) and need the edit right.</summary>
|
|
private static readonly HashSet<JobKind> SequenceKinds = [JobKind.LightAnalyse, JobKind.DeepAnalyse, JobKind.Proxies, JobKind.Thumbs, JobKind.Verify];
|
|
|
|
/// <summary>Archive-wide maintenance (target: the archive) for administrators.</summary>
|
|
private static readonly HashSet<JobKind> 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<IResult> 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<JobDto>([.. page.Items.Select(Dto.Job)], page.NextCursor, null), ProtocolJson.Default.PageJobDto);
|
|
}
|
|
|
|
private static async Task<IResult> 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<Guid> 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<string>(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<RenderJobParameters> 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);
|
|
}
|
|
|
|
/// <summary>The oriented size of the sequence's first frame (what a preset without a fixed size renders at), else the job's size.</summary>
|
|
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<IResult> 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 });
|
|
});
|
|
}
|
|
|
|
/// <summary>Applies <paramref name="action"/> when the job is in one of <paramref name="allowed"/> states and the caller created it or administers the archive.</summary>
|
|
private static async Task<IResult> ActAsync(HttpContext context, Caller caller, Guid id, ChronosDatabase db, JobState[] allowed, Func<Job, CancellationToken, Task> 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);
|
|
}
|
|
|
|
/// <summary>Render parameters, or null when they are missing or incomplete.</summary>
|
|
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;
|
|
}
|
|
}
|
|
}
|