From 4007293833466b1f9f0bc84f500d1ae3b981e178 Mon Sep 17 00:00:00 2001 From: Claude Date: Sat, 3 Oct 2026 09:39:17 +0000 Subject: [PATCH] feat(server): render MP4 jobs no render node can take as MJPEG, and say so MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit BRIEF §14.7: the server falls back to managed formats when no node is available and says so in the job log. An MP4 job waits for render nodes at least the node timeout, then as long as an online node can encode its codec at its size; after that the server's engine takes it and writes each output it cannot encode as MJPEG in AVI at the same size and frame rate, with a job log line. A job the server started resumes there. Selective acceptance is asynchronous for that; when node availability cannot be read the job keeps waiting. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC --- i18n/en/Export.resx | 1 + i18n/it/Export.it.resx | 1 + src/Titano.Data/Jobs/JobEngine.cs | 8 +- src/Titano.Data/Jobs/JobHandler.cs | 9 ++- .../Jobs/ManagedRenderJobHandler.cs | 74 +++++++++++++++---- .../Processing/Jobs/RenderJobHandler.cs | 7 +- .../Processing/ProcessingOptions.cs | 11 ++- .../Processing/ProcessingService.cs | 6 +- src/Titano.Server/Jobs/JobEngineHost.cs | 4 +- .../Jobs/RenderNodeAvailability.cs | 42 +++++++++++ src/Titano.Server/Storage/ProcessingModule.cs | 8 +- .../Titano.Data.Tests/Jobs/JobEngineTests.cs | 5 +- .../Processing/ProcessingFixture.cs | 11 ++- .../Processing/RenderJobTests.cs | 67 ++++++++++++++--- .../Storage/ProcessingModuleTests.cs | 41 ++++++++++ 15 files changed, 247 insertions(+), 48 deletions(-) create mode 100644 src/Titano.Server/Jobs/RenderNodeAvailability.cs diff --git a/i18n/en/Export.resx b/i18n/en/Export.resx index 3477a2d4..34850b65 100644 --- a/i18n/en/Export.resx +++ b/i18n/en/Export.resx @@ -16,6 +16,7 @@ Downloading framesrender node progress stage Measuring framesjob progress stage {0} failed: {1}long: job log line; {0} preset name; {1} reason + No render node can encode {1}; {0} is rendered as {2} instead.long: job log line; {0} preset name; {1} codec asked for; {2} managed codec used {0} saved as {1}long: job log line; {0} preset name; {1} output file name Playback rate not understood; the export frame rate is used.long No capture times: frames are spaced evenly.long diff --git a/i18n/it/Export.it.resx b/i18n/it/Export.it.resx index 27aed9a6..da3ab965 100644 --- a/i18n/it/Export.it.resx +++ b/i18n/it/Export.it.resx @@ -16,6 +16,7 @@ Download dei fotogrammi Misura dei fotogrammi {0} non riuscito: {1} + Nessun nodo di rendering può codificare {1}; {0} viene esportato in {2}. {0} salvato come {1} Velocità di riproduzione non valida; viene usata la frequenza di esportazione. Nessun orario di scatto: fotogrammi distribuiti in modo uniforme. diff --git a/src/Titano.Data/Jobs/JobEngine.cs b/src/Titano.Data/Jobs/JobEngine.cs index d6296ebc..0b883614 100644 --- a/src/Titano.Data/Jobs/JobEngine.cs +++ b/src/Titano.Data/Jobs/JobEngine.cs @@ -242,7 +242,7 @@ public sealed class JobEngine : IAsyncDisposable Job? candidate = null; foreach (var queued in await _db.Jobs.ListQueuedAsync(_selective.Keys, SelectiveWindow, cancellationToken).ConfigureAwait(false)) { - if (!Accepts(queued)) continue; + if (!await AcceptsAsync(queued, cancellationToken).ConfigureAwait(false)) continue; candidate = queued; break; } @@ -261,13 +261,13 @@ public sealed class JobEngine : IAsyncDisposable } /// A job its handler cannot judge is taken, so it fails here with its reason instead of blocking the queue. - private bool Accepts(Job job) + private async ValueTask AcceptsAsync(Job job, CancellationToken cancellationToken) { try { - return _selective[job.Kind].Accepts(job); + return await _selective[job.Kind].AcceptsAsync(job, cancellationToken).ConfigureAwait(false); } - catch (Exception ex) + catch (Exception ex) when (!(ex is OperationCanceledException && cancellationToken.IsCancellationRequested)) { Log.Warning("jobs", $"{job.Kind} job {job.Id} could not be examined; it is claimed so that it fails with its reason", ex); return true; diff --git a/src/Titano.Data/Jobs/JobHandler.cs b/src/Titano.Data/Jobs/JobHandler.cs index 6a1af038..f78f9246 100644 --- a/src/Titano.Data/Jobs/JobHandler.cs +++ b/src/Titano.Data/Jobs/JobHandler.cs @@ -14,13 +14,14 @@ public interface IJobHandler } /// -/// A handler that runs only some jobs of its kind, decided from the job alone (its parameters never change). The engine -/// leaves the others queued for other claimers: the server renders what its managed encoders produce and leaves the -/// rest to render nodes (BRIEF §14.5, §14.7). +/// A handler that runs only some jobs of its kind. The engine leaves the others queued for other claimers and asks again +/// at every claim, so an answer may change while the job waits: the server renders what its managed encoders produce, +/// leaves the rest to render nodes, and takes those too in a managed format once no node can (BRIEF §14.5, §14.7). /// public interface ISelectiveJobHandler : IJobHandler { - bool Accepts(Job job); + /// Whether this handler takes now. A job it cannot read should be taken, so it fails with its reason. + ValueTask AcceptsAsync(Job job, CancellationToken cancellationToken); } /// A component that brings several handlers (the archive engine: scan, rebuild, verify, import, images, maintenance). diff --git a/src/Titano.Data/Processing/Jobs/ManagedRenderJobHandler.cs b/src/Titano.Data/Processing/Jobs/ManagedRenderJobHandler.cs index 0dfb22fa..7151b807 100644 --- a/src/Titano.Data/Processing/Jobs/ManagedRenderJobHandler.cs +++ b/src/Titano.Data/Processing/Jobs/ManagedRenderJobHandler.cs @@ -1,39 +1,87 @@ +using Titano.Core.Diagnostics; using Titano.Core.Export; +using Titano.Core.Localization; using Titano.Core.Model; using Titano.Core.Video; using Titano.Data.Jobs; +using Titano.Protocol; namespace Titano.Data.Processing.Jobs; /// -/// on the server (BRIEF §4.4, §14.5): it takes only jobs whose every output (the preset and -/// each batch preset) its managed encoders produce, and runs them like a client does. Jobs that need a platform encoder -/// (MP4) stay queued for render nodes (§14.7). Jobs whose parameters cannot be read are taken, so they fail with their -/// reason instead of waiting for a claimer that never comes. +/// on the server (BRIEF §4.4, §14.5, §14.7): it takes the jobs whose every output (the preset +/// and each batch preset) its managed encoders produce, and runs them like a client does. Jobs that need a platform +/// encoder (MP4) wait for render nodes while says one may take them; +/// after that the server takes them too, writes each output it cannot encode as MJPEG in AVI at the same size and frame +/// rate, and says so in the job log. A job it started (it left a checkpoint) resumes here, and jobs whose parameters +/// cannot be read are taken, so they fail with their reason instead of waiting for a claimer that never comes. /// -internal sealed class ManagedRenderJobHandler(RenderJobHandler render, IReadOnlyList encoders) : ISelectiveJobHandler +internal sealed class ManagedRenderJobHandler(RenderJobHandler render, ProcessingOptions options) : ISelectiveJobHandler { - private readonly EncoderCapability[] _capabilities = [.. encoders.SelectMany(e => e.Capabilities)]; + /// The managed preset whose values stand in for an output only a render node could make. + private const string FallbackPresetId = "mjpeg-avi"; + + private readonly EncoderCapability[] _capabilities = [.. options.Encoders.SelectMany(e => e.Capabilities)]; public JobKind Kind => JobKind.Render; - public bool Accepts(Job job) + public async ValueTask AcceptsAsync(Job job, CancellationToken cancellationToken) { ArgumentNullException.ThrowIfNull(job); + RenderJobParameters parameters; try { - var parameters = ProcessingJobs.ReadParameters(job.ParametersJson); - // Most declined jobs are decided by the main codec, before the export is read. - return _capabilities.Any(c => string.Equals(ProcessingJobs.CodecName(c.Codec), parameters.Codec, StringComparison.OrdinalIgnoreCase)) - && RenderJobHandler.Targets(ProcessingJobs.ReadExport(parameters.PresetJson), parameters.PresetName).All(t => Produces(t.Export)); + parameters = ProcessingJobs.ReadParameters(job.ParametersJson); + // Most jobs are decided by the main codec, before the export is read. + if (Produces(parameters.Codec) && RenderJobHandler.Targets(ProcessingJobs.ReadExport(parameters.PresetJson), parameters.PresetName).All(t => Produces(t.Export))) + return true; } - catch (InvalidDataException) + catch (Exception ex) when (ex is not OperationCanceledException) { return true; } + if (job.Checkpoint is not null) return true; + if (options.AwaitsRenderNode is not { } awaits) return false; + try + { + return !await awaits(job, parameters, cancellationToken).ConfigureAwait(false); + } + catch (Exception ex) when (ex is not OperationCanceledException) + { + // Unknown whether a node could take it: the job keeps waiting rather than losing its format. + Log.Warning("processing", $"Render job {job.Id}: render node availability unknown", ex); + return false; + } } - public Task RunAsync(JobContext context) => render.RunAsync(context); + public Task RunAsync(JobContext context) => + render.RunAsync(context, target => Produces(target.Export) ? target : Fallback(context, target)); + + /// The output as MJPEG in AVI with the managed preset's quality, at the size and frame rate asked for. + private static ExportTarget Fallback(JobContext context, ExportTarget target) + { + var mjpeg = ExportResolver.FromPreset(ExportPresets.Find(FallbackPresetId)!); + context.Log(Loc.L("Export.Log.NoRenderNode", target.PresetName, ExportNaming.CodecLabel(target.Export.Codec), ExportNaming.CodecLabel(mjpeg.Codec))); + return target with + { + Export = target.Export with + { + PresetId = ExportResolver.CustomId, + NameKey = null, + Codec = mjpeg.Codec, + Profile = mjpeg.Profile, + BitDepth = mjpeg.BitDepth, + BitRate = 0, + BitsPerPixel = 0, + Quality = mjpeg.Quality, + RateControl = mjpeg.RateControl, + Encoder = null, + }, + }; + } + + private bool Produces(string codec) => + _capabilities.Any(c => string.Equals(ProcessingJobs.CodecName(c.Codec), codec, StringComparison.OrdinalIgnoreCase)); private bool Produces(ResolvedExport export) => _capabilities.Any(c => c.Codec == export.Codec && export.Width <= c.MaxWidth && export.Height <= c.MaxHeight); diff --git a/src/Titano.Data/Processing/Jobs/RenderJobHandler.cs b/src/Titano.Data/Processing/Jobs/RenderJobHandler.cs index 47fb5865..359361d5 100644 --- a/src/Titano.Data/Processing/Jobs/RenderJobHandler.cs +++ b/src/Titano.Data/Processing/Jobs/RenderJobHandler.cs @@ -25,7 +25,10 @@ internal sealed class RenderJobHandler(TitanoDatabase db, ProcessingOptions opti { public JobKind Kind => JobKind.Render; - public async Task RunAsync(JobContext context) + public Task RunAsync(JobContext context) => RunAsync(context, target => target); + + /// Runs the job with each output still to render passed through (the server's managed stand-ins). + internal async Task RunAsync(JobContext context, Func adapt) { var cancellation = context.Cancellation; var (parameters, export) = ProcessingJobs.ReadRender(context.Job.ParametersJson); @@ -56,7 +59,7 @@ internal sealed class RenderJobHandler(TitanoDatabase db, ProcessingOptions opti Discard(output, keepOutput: recorded.Any(r => r.OutputPath == Stored(paths, output))); names.Release(output); // free again for the entry's new attempt } - var targets = all.Select((t, i) => (i, t)).Where(t => !done.Contains(t.i)).ToList(); + var targets = all.Select((t, i) => (i, t)).Where(t => !done.Contains(t.i)).Select(t => (t.i, adapt(t.t))).ToList(); if (targets.Count == 0) return; var frames = await SequenceFrames.LoadAsync(db, archive, sequence, parameters.UseProxies, cancellation).ConfigureAwait(false); diff --git a/src/Titano.Data/Processing/ProcessingOptions.cs b/src/Titano.Data/Processing/ProcessingOptions.cs index 82add6e3..e14efb8e 100644 --- a/src/Titano.Data/Processing/ProcessingOptions.cs +++ b/src/Titano.Data/Processing/ProcessingOptions.cs @@ -1,10 +1,12 @@ using Titano.Core.Analysis.Deep; using Titano.Core.Export; using Titano.Core.Imaging; +using Titano.Core.Model; using Titano.Core.Render; using Titano.Core.Video; using Titano.Core.Video.Managed; using Titano.Data.Archiving; +using Titano.Protocol; namespace Titano.Data.Processing; @@ -40,9 +42,16 @@ public sealed record ProcessingOptions /// public Func? SequenceChanged { get; init; } - /// The server delegates platform codecs to render nodes and never runs them itself. + /// The server delegates platform codecs to render nodes (). public EncoderHost Host { get; init; } = EncoderHost.Client; + /// + /// Server: whether a queued render job that needs a platform encoder still waits for a render node (BRIEF §14.7). Once + /// it does not, the server renders it itself, every output only a node could make as MJPEG in AVI at the same size and + /// frame rate, and says so in the job log. Null: such jobs always wait for a node. + /// + public Func>? AwaitsRenderNode { get; init; } + /// Recorded with every render this host produces (client or server name). public string ProducedBy { get; init; } = Environment.MachineName; diff --git a/src/Titano.Data/Processing/ProcessingService.cs b/src/Titano.Data/Processing/ProcessingService.cs index b5033dfd..581a87b7 100644 --- a/src/Titano.Data/Processing/ProcessingService.cs +++ b/src/Titano.Data/Processing/ProcessingService.cs @@ -10,8 +10,8 @@ namespace Titano.Data.Processing; /// The analysis and render engine of a host (BRIEF §4.3, §10, §11): job handlers for light analysis, deep analysis and /// renders over the archive in the index, built with the host's decoders and encoders (). /// Register it on the next to the archive engine. A client renders every job it is given; a -/// server takes only the renders its managed encoders produce and leaves the others to render nodes. Create jobs with -/// . +/// server takes the renders its managed encoders produce and leaves the others to render nodes until none can take them +/// (). Create jobs with . /// public sealed class ProcessingService : IJobHandlerProvider { @@ -37,7 +37,7 @@ public sealed class ProcessingService : IJobHandlerProvider [ new AnalyseJobHandler(_db, _analyser, JobKind.LightAnalyse), new AnalyseJobHandler(_db, _analyser, JobKind.DeepAnalyse), - Options.Host == EncoderHost.Server ? new ManagedRenderJobHandler(render, Options.Encoders) : render, + Options.Host == EncoderHost.Server ? new ManagedRenderJobHandler(render, Options) : render, ]; } } diff --git a/src/Titano.Server/Jobs/JobEngineHost.cs b/src/Titano.Server/Jobs/JobEngineHost.cs index 2c5d5faf..e9ea3401 100644 --- a/src/Titano.Server/Jobs/JobEngineHost.cs +++ b/src/Titano.Server/Jobs/JobEngineHost.cs @@ -13,8 +13,8 @@ namespace Titano.Server.Jobs; /// Hosts the server's (BRIEF §14.6) with the s registered in DI (directly or /// through s) and /// relays its state changes and progress as WebSocket events. Render jobs run here only when the registered render -/// handler accepts them (managed formats, ); render nodes claim the others (BRIEF -/// §14.5, §14.7). On shutdown running jobs stay marked running and are requeued from their checkpoints at the next start. +/// handler accepts them (: managed formats, and MP4 jobs no render node can take); +/// render nodes claim the others (BRIEF §14.5, §14.7). On shutdown running jobs stay marked running and are requeued from their checkpoints at the next start. /// public sealed class JobEngineHost : IHostedService { diff --git a/src/Titano.Server/Jobs/RenderNodeAvailability.cs b/src/Titano.Server/Jobs/RenderNodeAvailability.cs new file mode 100644 index 00000000..44d3e7b3 --- /dev/null +++ b/src/Titano.Server/Jobs/RenderNodeAvailability.cs @@ -0,0 +1,42 @@ +using System.Diagnostics; +using Titano.Core.Model; +using Titano.Data; +using Titano.Protocol; +using Titano.Server.Api; +using Titano.Server.Configuration; + +namespace Titano.Server.Jobs; + +/// +/// Whether a queued render job that needs a platform encoder still waits for a render node (BRIEF §14.7); once it does +/// not, the server's own engine renders it in a managed format. A job waits at least as long as a node may stay silent +/// (), so a node that is restarting or reconnecting takes it back, and +/// then as long as an online node can encode its codec at its size. The server's render handler asks for every queued +/// job it examines, so the online nodes are read at most once a second. +/// +public sealed class RenderNodeAvailability(TitanoDatabase db, ServerOptions options, TimeProvider time) +{ + private static readonly TimeSpan SnapshotAge = TimeSpan.FromSeconds(1); + + private Snapshot? _snapshot; + + public async Task AwaitsNodeAsync(Job job, RenderJobParameters parameters, CancellationToken cancellationToken) + { + ArgumentNullException.ThrowIfNull(job); + ArgumentNullException.ThrowIfNull(parameters); + var now = time.GetUtcNow(); + var timeout = TimeSpan.FromSeconds(options.NodeTimeoutSeconds); + if (now - job.Created < timeout) return true; + var snapshot = Volatile.Read(ref _snapshot); + if (snapshot is null || Stopwatch.GetElapsedTime(snapshot.Read) >= SnapshotAge) + { + var online = await db.RenderNodes.ListOnlineAsync(now - timeout, cancellationToken); + snapshot = new Snapshot(Stopwatch.GetTimestamp(), [.. online.Select(Dto.Capabilities).OfType()]); + Volatile.Write(ref _snapshot, snapshot); + } + return snapshot.Nodes.Any(node => RenderNodeService.CanEncode(node, parameters)); + } + + /// What the online nodes announced, and when it was read (a timestamp). + private sealed record Snapshot(long Read, IReadOnlyList Nodes); +} diff --git a/src/Titano.Server/Storage/ProcessingModule.cs b/src/Titano.Server/Storage/ProcessingModule.cs index 16477d56..26b47a9a 100644 --- a/src/Titano.Server/Storage/ProcessingModule.cs +++ b/src/Titano.Server/Storage/ProcessingModule.cs @@ -8,20 +8,23 @@ using Titano.Data.Processing; using Titano.Protocol; using Titano.Server.Configuration; using Titano.Server.Events; +using Titano.Server.Jobs; namespace Titano.Server.Storage; /// /// Analysis and render engine of the server (BRIEF §4.2, §10, §14.5, §14.6): light and deep analysis with managed /// decoders (the light analysis queued after uploads runs here) and renders with managed encoders only. The render -/// handler takes just the jobs whose every output a managed encoder produces (AVI MJPEG, image sequences, GIF, APNG); -/// MP4 jobs stay queued for render nodes (BRIEF §14.7). Renders recorded and Auto values changed here reach connected +/// handler takes the jobs whose every output a managed encoder produces (AVI MJPEG, image sequences, GIF, APNG); MP4 +/// jobs wait for render nodes until none can take them (), and then render here as +/// MJPEG in AVI with a line in the job log (BRIEF §14.7). Renders recorded and Auto values changed here reach connected /// clients as sequenceChanged events (§14.3). /// public static class ProcessingModule { public static void Register(IServiceCollection services) { + services.AddSingleton(); services.AddSingleton(sp => { var db = sp.GetRequiredService(); @@ -31,6 +34,7 @@ public static class ProcessingModule Archive = new ArchiveServiceOptions { Decoder = DecoderFactory.CreateServer(), Owner = ArchiveModule.Owner }, Encoders = [new ManagedEncoderProvider()], Host = EncoderHost.Server, + AwaitsRenderNode = sp.GetRequiredService().AwaitsNodeAsync, ProducedBy = sp.GetRequiredService().ServerName, SequenceChanged = async (id, change, ct) => { diff --git a/tests/Titano.Data.Tests/Jobs/JobEngineTests.cs b/tests/Titano.Data.Tests/Jobs/JobEngineTests.cs index 283648b6..d4d8d15b 100644 --- a/tests/Titano.Data.Tests/Jobs/JobEngineTests.cs +++ b/tests/Titano.Data.Tests/Jobs/JobEngineTests.cs @@ -34,7 +34,7 @@ public sealed class JobEngineTests(TestContext context) public JobKind Kind => kind; - public bool Accepts(Job job) => job.ParametersJson == Mine; + public ValueTask AcceptsAsync(Job job, CancellationToken cancellationToken) => ValueTask.FromResult(job.ParametersJson == Mine); public Task RunAsync(JobContext c) => Task.CompletedTask; } @@ -44,7 +44,8 @@ public sealed class JobEngineTests(TestContext context) { public JobKind Kind => kind; - public bool Accepts(Job job) => job.ParametersJson?.Length > 0 ? true : throw new ArgumentNullException(nameof(job)); + public ValueTask AcceptsAsync(Job job, CancellationToken cancellationToken) => + job.ParametersJson?.Length > 0 ? ValueTask.FromResult(true) : throw new ArgumentNullException(nameof(job)); public Task RunAsync(JobContext c) => c.Job.ParametersJson is null ? throw new InvalidDataException("no parameters") : Task.CompletedTask; diff --git a/tests/Titano.Data.Tests/Processing/ProcessingFixture.cs b/tests/Titano.Data.Tests/Processing/ProcessingFixture.cs index 9572451f..d5b9ad90 100644 --- a/tests/Titano.Data.Tests/Processing/ProcessingFixture.cs +++ b/tests/Titano.Data.Tests/Processing/ProcessingFixture.cs @@ -23,16 +23,17 @@ internal sealed class ProcessingFixture : IAsyncDisposable private JobEngine? _engine; - private ProcessingFixture(ArchiveFixture archive, GateDecoder decoder) + private ProcessingFixture(ArchiveFixture archive, GateDecoder decoder, Func? configure) { Archive = archive; Decoder = decoder; - Processing = new ProcessingService(archive.Db, new ProcessingOptions + var options = new ProcessingOptions { Archive = new ArchiveServiceOptions { Decoder = new ImageDecoder([decoder]), Owner = "test", LeaseWait = TimeSpan.FromSeconds(20) }, DeepAnalysis = DeepOptions, ProducedBy = "test-pc", - }); + }; + Processing = new ProcessingService(archive.Db, configure?.Invoke(options) ?? options); } public ArchiveFixture Archive { get; } @@ -43,7 +44,9 @@ internal sealed class ProcessingFixture : IAsyncDisposable public JobEngine Engine => _engine ?? throw new InvalidOperationException("Start the engine first."); - public static async Task CreateAsync(TestContext context) => new(await ArchiveFixture.CreateAsync(context), new GateDecoder()); + /// Changes to the processing options (a server's host and render-node check). + public static async Task CreateAsync(TestContext context, Func? configure = null) => + new(await ArchiveFixture.CreateAsync(context), new GateDecoder(), configure); /// A started engine with the processing handlers, and the archive's when asked (one worker unless asked, fast checkpoints). public async Task StartEngineAsync(bool withArchive = false, int workers = 1) diff --git a/tests/Titano.Data.Tests/Processing/RenderJobTests.cs b/tests/Titano.Data.Tests/Processing/RenderJobTests.cs index 4739af73..656032ef 100644 --- a/tests/Titano.Data.Tests/Processing/RenderJobTests.cs +++ b/tests/Titano.Data.Tests/Processing/RenderJobTests.cs @@ -26,6 +26,9 @@ public sealed class RenderJobTests(TestContext context) NameTemplate = "clip-{codec}", }; + /// HEVC (a render node's codec) at the size of . + private static readonly ExportSettings Hevc = Mjpeg with { Preset = new Auto().WithManual("4k-hevc") }; + private static SyntheticSequence Scene() => SyntheticSequence.Create(new SyntheticSequenceOptions { FrameCount = Frames, StartEv = 0.5, EndEv = -0.5 }); [Test] @@ -214,25 +217,62 @@ public sealed class RenderJobTests(TestContext context) public async Task AServerTakesOnlyTheRendersItsManagedEncodersProduce() { await using var fx = await ProcessingFixture.CreateAsync(context); - var server = new ProcessingService(fx.Db, new ProcessingOptions { Host = EncoderHost.Server }); + var server = new ProcessingService(fx.Db, new ProcessingOptions { Host = EncoderHost.Server, AwaitsRenderNode = (_, _, _) => Task.FromResult(true) }); var handler = Assert.NotNull(server.CreateJobHandlers().Single(h => h.Kind == JobKind.Render) as ISelectiveJobHandler); var sequence = new Sequence { Id = Guid.CreateVersion7(), ArchiveId = Guid.CreateVersion7(), Folder = "Synthetic" }; - bool Accepts(ExportSettings export) => - handler.Accepts(new Job { Id = Guid.CreateVersion7(), Kind = JobKind.Render, ParametersJson = ProcessingJobs.Render(sequence, export, 96, 64).ParametersJson }); + Job Job(ExportSettings export) => new() { Id = Guid.CreateVersion7(), Kind = JobKind.Render, ParametersJson = ProcessingJobs.Render(sequence, export, 96, 64).ParametersJson }; + async Task AcceptsAsync(string? parametersJson) => + await handler.AcceptsAsync(new Job { Id = Guid.CreateVersion7(), Kind = JobKind.Render, ParametersJson = parametersJson }, fx.Ct); - Assert.True(Accepts(Mjpeg with { Batch = ["png-sequence", "gif-preview"] }), "managed outputs only"); - Assert.False(Accepts(new ExportSettings { Preset = new Auto().WithManual("4k-hevc") }), "HEVC needs a render node"); - Assert.False(Accepts(Mjpeg with { Batch = ["1080p-h264"] }), "one MP4 in the batch"); - Assert.True(handler.Accepts(new Job { Id = Guid.CreateVersion7(), Kind = JobKind.Render, ParametersJson = "{}" }), "unreadable: fails with its reason"); - Assert.True(handler.Accepts(new Job { Id = Guid.CreateVersion7(), Kind = JobKind.Render, ParametersJson = WithPreset("""{"preset":{},"Preset":{}}""") }), - "a member given twice: fails with its reason"); - Assert.True(handler.Accepts(new Job { Id = Guid.CreateVersion7(), Kind = JobKind.Render, ParametersJson = WithPreset("""{"preset":{"isAuto":false,"manual":"mjpeg-avi"},"batch":null}""") }), - "a null batch is no batch"); + Assert.True(await handler.AcceptsAsync(Job(Mjpeg with { Batch = ["png-sequence", "gif-preview"] }), fx.Ct), "managed outputs only"); + Assert.False(await handler.AcceptsAsync(Job(Hevc), fx.Ct), "HEVC waits for a render node"); + Assert.False(await handler.AcceptsAsync(Job(Mjpeg with { Batch = ["1080p-h264"] }), fx.Ct), "one MP4 in the batch"); + Assert.True(await handler.AcceptsAsync(Job(Hevc) with { Checkpoint = """{"done":[],"pending":0}""" }, fx.Ct), "started here: resumes here"); + Assert.True(await AcceptsAsync("{}"), "unreadable: fails with its reason"); + Assert.True(await AcceptsAsync(WithPreset("""{"preset":{},"Preset":{}}""")), "a member given twice: fails with its reason"); + Assert.True(await AcceptsAsync(WithPreset("""{"preset":{"isAuto":false,"manual":"mjpeg-avi"},"batch":null}""")), "a null batch is no batch"); var client = new ProcessingService(fx.Db).CreateJobHandlers().Single(h => h.Kind == JobKind.Render); Assert.False(client is ISelectiveJobHandler, "a client renders whatever it is given"); } + [Test] + public async Task AServerTakesMp4JobsOnceNoRenderNodeCanAndOnlyThen() + { + await using var fx = await ProcessingFixture.CreateAsync(context); + var sequence = new Sequence { Id = Guid.CreateVersion7(), ArchiveId = Guid.CreateVersion7(), Folder = "Synthetic" }; + var job = new Job { Id = Guid.CreateVersion7(), Kind = JobKind.Render, ParametersJson = ProcessingJobs.Render(sequence, Hevc, 96, 64).ParametersJson }; + async Task AcceptsAsync(Func>? awaits) + { + var server = new ProcessingService(fx.Db, new ProcessingOptions { Host = EncoderHost.Server, AwaitsRenderNode = awaits }); + return await ((ISelectiveJobHandler)server.CreateJobHandlers().Single(h => h.Kind == JobKind.Render)).AcceptsAsync(job, fx.Ct); + } + + Titano.Protocol.RenderJobParameters? asked = null; + Assert.True(await AcceptsAsync((_, p, _) => { asked = p; return Task.FromResult(false); }), "no node can take it"); + Assert.Equal(("hevc", 96, 64), (asked!.Codec, asked.Width, asked.Height)); + Assert.False(await AcceptsAsync(null), "without a node check, MP4 jobs always wait"); + Assert.False(await AcceptsAsync((_, _, _) => throw new InvalidOperationException("database unreachable")), "unknown: keeps waiting"); + } + + [Test] + public async Task AServerRendersAsMjpegWhatNoRenderNodeTookAndSaysSo() + { + await using var fx = await ProcessingFixture.CreateAsync(context, o => o with { Host = EncoderHost.Server, AwaitsRenderNode = (_, _, _) => Task.FromResult(false) }); + var sequence = await fx.AddAsync(Scene()); + await fx.StartEngineAsync(); + + var request = ProcessingJobs.Render(sequence, Hevc, 96, 64); + var job = await fx.WaitForAsync((await fx.EnqueueAsync(request)).Id, JobState.Done); + + var avi = await File.ReadAllBytesAsync(Path.Combine(fx.Folder(sequence).Exports, "clip-MJPEG.avi"), fx.Ct); + Assert.Equal(("RIFF", "AVI "), (Encoding.ASCII.GetString(avi, 0, 4), Encoding.ASCII.GetString(avi, 8, 4))); + var render = (await fx.Db.Renders.ListBySequenceAsync(sequence.Id, fx.Ct)).Single(); + var preset = Loc.L("Export.Preset.Custom"); + Assert.Equal((preset, "Mjpeg", 96, 64), (render.PresetName, render.Codec, render.Width, render.Height)); + Assert.Contains(Loc.L("Export.Log.NoRenderNode", preset, "HEVC", "MJPEG"), job.LogTail); + } + [Test] public void ABatchForAServerBecomesOneJobPerPreset() { @@ -243,6 +283,11 @@ public sealed class RenderJobTests(TestContext context) Assert.True(jobs.All(j => j.Kind == JobKind.Render && j.Targets.SequenceEqual([sequence.Id])), "render jobs of the sequence"); Assert.True(parameters.All(p => ProcessingJobs.ReadExport(p.PresetJson).Batch.Count == 0), "no job carries a batch"); Assert.Equal((3840, 2160), (parameters[2].Width, parameters[2].Height)); + + // A posted batch written by hand may hold blank entries: they name no preset. + var posted = System.Text.Json.JsonSerializer.Deserialize(WithPreset("""{"preset":{"isAuto":false,"manual":"mjpeg-avi"},"batch":[null," ","gif-preview"]}"""), + Titano.Protocol.ProtocolJson.Default.RenderJobParameters)!; + Assert.SequenceEqual(["mjpeg", "gif"], ProcessingJobs.Split(posted, 96, 64).Select(p => p.Codec)); } /// MJPEG job parameters whose preset JSON is . diff --git a/tests/Titano.Server.Tests/Storage/ProcessingModuleTests.cs b/tests/Titano.Server.Tests/Storage/ProcessingModuleTests.cs index aeb83eb6..6cb2d346 100644 --- a/tests/Titano.Server.Tests/Storage/ProcessingModuleTests.cs +++ b/tests/Titano.Server.Tests/Storage/ProcessingModuleTests.cs @@ -94,6 +94,47 @@ public sealed class ProcessingModuleTests(TestContext context) Assert.Contains(Drain(events), e => e is SequenceChangedEvent { Change: "renders" } changed && changed.SequenceId == sequence.Id); } + [Test] + public async Task Mp4JobsNoRenderNodeCanTakeAreRenderedAsMjpegAndTheLogSaysSo() + { + var clock = new ManualTimeProvider(); + await using var server = await TestServer.StartAsync(context, o => o.NodeTimeoutSeconds = 60, s => + { + Production(s); + s.AddSingleton(clock); + }); + var engine = server.Services.GetRequiredService().Engine; + var (editor, _, _) = await server.UserAsync("alberto", "editor", renderNode: true); + var sequence = (await server.Database.Sequences.GetAsync(await UploadSceneAsync(editor)))!; + var hevc = new ExportSettings + { + Preset = new Auto().WithManual("4k-hevc"), + Overrides = new ExportOverrides { Width = 96, Height = 64 }, + NameTemplate = "clip-{codec}", + }; + var job = await JobApiTests.CreateAsync(editor, "render", sequence.Id, ProcessingJobs.Render(sequence, hevc, 96, 64).ParametersJson); + + // A node that encodes HEVC is online: the job waits for it, however long it has been queued. + using (var registered = await editor.PostAsJsonAsync("/api/v1/nodes/register", + new RegisterNodeRequest("studio-pc", [new NodeEncoder("hevc", "NVENC HEVC", true, true, 8192, 8192)], 8192, 8192), ProtocolJson.Default.RegisterNodeRequest)) + await registered.ExpectAsync(HttpStatusCode.OK); + clock.Advance(TimeSpan.FromSeconds(61)); + var node = (await server.Database.RenderNodes.ListAsync()).Single(); + Assert.True(await server.Database.RenderNodes.HeartbeatAsync(node.Id, "idle", clock.GetUtcNow())); + engine.Wake(); + await Task.Delay(1500); + Assert.Equal("queued", (await JobApiTests.GetAsync(editor, job.Id)).State); + + // The node goes silent: the server renders the job itself in a managed format. + clock.Advance(TimeSpan.FromSeconds(61)); + engine.Wake(); + var done = await JobApiTests.WaitForAsync(editor, job.Id, "done"); + Assert.Equal(JobEngineHost.WorkerId, done.NodeId?.Split('#')[0]); + var render = (await server.Database.Renders.ListBySequenceAsync(sequence.Id)).Single(); + Assert.Equal(($"{sequence.Folder}/exports/clip-MJPEG.avi", "Mjpeg", 96, 64), (render.OutputPath, render.Codec, render.Width, render.Height)); + Assert.Contains(Loc.L("Export.Log.NoRenderNode", Loc.L("Export.Preset.Custom"), "HEVC", "MJPEG"), done.LogTail); + } + [Test] public async Task APostedBatchBecomesOneJobPerPreset() {