diff --git a/src/Titano.Core/Export/ExportNaming.cs b/src/Titano.Core/Export/ExportNaming.cs
index f594b0b1..f0194676 100644
--- a/src/Titano.Core/Export/ExportNaming.cs
+++ b/src/Titano.Core/Export/ExportNaming.cs
@@ -105,33 +105,34 @@ public static class ExportNaming
///
/// Full output path inside : the expanded name plus the codec's extension, or the bare name
- /// for image sequences (a folder), made unique against existing files and folders.
+ /// for image sequences (a folder), made unique against existing files and folders and the paths
+ /// says are being written.
///
- public static string OutputPath(string folder, string template, ExportNameContext context)
+ public static string OutputPath(string folder, string template, ExportNameContext context, Func? taken = null)
{
ArgumentException.ThrowIfNullOrWhiteSpace(folder);
var name = Expand(template, context).Name;
var extension = VideoCodecInfo.DefaultContainer(context.Codec) == ContainerFormat.ImageSequence ? string.Empty : VideoCodecInfo.FileExtension(context.Codec);
- return Unique(folder, name, extension);
+ return Unique(folder, name, extension, taken);
}
///
/// Output path of a project's export: or, when unset, the sequence's exports folder,
/// named by .
///
- public static string OutputPath(ExportSettings settings, string sequenceExportsFolder, ExportNameContext context)
+ public static string OutputPath(ExportSettings settings, string sequenceExportsFolder, ExportNameContext context, Func? taken = null)
{
ArgumentNullException.ThrowIfNull(settings);
- return OutputPath(string.IsNullOrWhiteSpace(settings.Folder) ? sequenceExportsFolder : settings.Folder, settings.NameTemplate, context);
+ return OutputPath(string.IsNullOrWhiteSpace(settings.Folder) ? sequenceExportsFolder : settings.Folder, settings.NameTemplate, context, taken);
}
- /// "name.ext", or "name (2).ext", "name (3).ext"… when a file or folder of that name exists.
- public static string Unique(string folder, string name, string extension)
+ /// "name.ext", or "name (2).ext", "name (3).ext"… when a file or folder of that name exists or is .
+ public static string Unique(string folder, string name, string extension, Func? taken = null)
{
for (var n = 1; ; n++)
{
var candidate = Path.Combine(folder, (n == 1 ? name : string.Create(CultureInfo.InvariantCulture, $"{name} ({n})")) + extension);
- if (!File.Exists(candidate) && !Directory.Exists(candidate)) return candidate;
+ if (!File.Exists(candidate) && !Directory.Exists(candidate) && taken?.Invoke(candidate) != true) return candidate;
}
}
diff --git a/src/Titano.Data/Processing/Jobs/RenderJobHandler.cs b/src/Titano.Data/Processing/Jobs/RenderJobHandler.cs
index c8ea860b..47fb5865 100644
--- a/src/Titano.Data/Processing/Jobs/RenderJobHandler.cs
+++ b/src/Titano.Data/Processing/Jobs/RenderJobHandler.cs
@@ -1,3 +1,5 @@
+using System.Buffers.Binary;
+using System.Security.Cryptography;
using Titano.Core.Archiving;
using Titano.Core.Export;
using Titano.Core.Localization;
@@ -13,9 +15,11 @@ namespace Titano.Data.Processing.Jobs;
/// RenderJobParameters whose preset JSON is the export section of a project (preset, overrides, name template,
/// folder, batch). The project is the embedded one or the sequence's own; frames flagged missing, corrupt, excluded or
/// undecodable are left out. The preset and every batch preset render after one preparation pass into the sequence's
-/// exports/ (or the export folder, never on a server), named by the template, and each finished output is recorded at once.
-/// Checkpoint: the batch entries recorded and the output being written, so a crashed attempt's leftovers are removed and
-/// only unfinished entries render again. A failed entry fails the job after the others ran; retrying renders it alone.
+/// exports/ (or the export folder, never on a server), named by the template without taking a name another render
+/// of this process is writing, and each finished output is recorded at once (its row id derives from the job and the
+/// entry, so every attempt knows what is recorded). Checkpoint: the entries recorded and the output being written, so a
+/// crashed attempt's leftovers are removed and only unfinished entries render again. A failed entry fails the job after
+/// the others ran; retrying renders it alone.
///
internal sealed class RenderJobHandler(TitanoDatabase db, ProcessingOptions options) : IJobHandler
{
@@ -36,16 +40,23 @@ internal sealed class RenderJobHandler(TitanoDatabase db, ProcessingOptions opti
var project = (parameters.SettingsJson is { } embedded ? ProjectStore.Parse(embedded) : ProjectStore.Read(sequence, folder)) with { Export = export };
var settingsJson = project.ToJson();
+ using var names = new OutputNames();
+ var all = Targets(export, parameters.PresetName);
var resume = RenderCheckpoint.Parse(context.Checkpoint);
var done = resume.Done.ToList();
- if (resume is { Pending: { } pending, PendingOutput: { } output })
+ // A crash after a render row was written but before the checkpoint: that entry is finished.
+ for (var i = 0; i < all.Count; i++)
{
- // A crash after the render row was written but before the checkpoint: that entry is finished.
- var recorded = await db.Renders.ListBySequenceAsync(sequence.Id, cancellation).ConfigureAwait(false);
- if (recorded.Any(r => r.OutputPath == Stored(paths, output))) done.Add(pending);
- else Discard(output);
+ if (!done.Contains(i) && await db.Renders.GetAsync(RenderId(context.Job.Id, i), cancellation).ConfigureAwait(false) is not null) done.Add(i);
}
- var targets = Targets(export, parameters.PresetName).Select((t, i) => (i, t)).Where(t => !done.Contains(t.i)).ToList();
+ if (resume is { Pending: { } pending, PendingOutput: { } output } && !done.Contains(pending) && names.TryReserve(output))
+ {
+ // Unless another render recorded that name since (the output did not exist yet when it chose it).
+ var recorded = await db.Renders.ListBySequenceAsync(sequence.Id, cancellation).ConfigureAwait(false);
+ 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();
if (targets.Count == 0) return;
var frames = await SequenceFrames.LoadAsync(db, archive, sequence, parameters.UseProxies, cancellation).ConfigureAwait(false);
@@ -54,17 +65,22 @@ internal sealed class RenderJobHandler(TitanoDatabase db, ProcessingOptions opti
{
outcomes = await render.RenderAllAsync(
targets,
- (target, setup) => ExportNaming.OutputPath(project.Export, folder.Exports, SequenceRender.NameContext(sequence, target, setup)),
+ (target, setup) => names.Reserve(taken => ExportNaming.OutputPath(project.Export, folder.Exports, SequenceRender.NameContext(sequence, target, setup), taken)),
(index, path) => context.CheckpointAsync(new RenderCheckpoint(done, index, path).ToJson(), context.Done, context.Total),
async (index, target, result) =>
{
// The output is complete: record it even if the job is being cancelled, so it is never orphaned.
- var entity = result.ToEntity(sequence.Id, target.PresetName, settingsJson, options.ProducedBy) with { OutputPath = Stored(paths, result.OutputPath) };
+ var entity = result.ToEntity(sequence.Id, target.PresetName, settingsJson, options.ProducedBy) with
+ {
+ Id = RenderId(context.Job.Id, index),
+ OutputPath = Stored(paths, result.OutputPath),
+ };
await db.Renders.InsertAsync(entity, CancellationToken.None).ConfigureAwait(false);
done.Add(index);
await context.CheckpointAsync(new RenderCheckpoint(done, null, null).ToJson(), context.Done, context.Total).ConfigureAwait(false);
context.Log(Loc.L("Export.Log.Rendered", target.PresetName, Path.GetFileName(result.OutputPath)));
foreach (var remark in SequenceRender.Remarks(result)) context.Log(remark);
+ await options.NotifyAsync(sequence.Id, ProcessingOptions.RenderedChange, CancellationToken.None).ConfigureAwait(false);
},
context.ReportAsync,
cancellation).ConfigureAwait(false);
@@ -90,15 +106,32 @@ internal sealed class RenderJobHandler(TitanoDatabase db, ProcessingOptions opti
return relative.StartsWith("..", StringComparison.Ordinal) || Path.IsPathRooted(relative) ? output : relative;
}
+ ///
+ /// The id of the render row of entry of a job: the same in every attempt, so a resumed job
+ /// finds what it recorded (a name-based UUID, version 8).
+ ///
+ internal static Guid RenderId(Guid jobId, int index)
+ {
+ Span name = stackalloc byte[20];
+ jobId.TryWriteBytes(name, bigEndian: true, out _);
+ BinaryPrimitives.WriteInt32BigEndian(name[16..], index);
+ Span hash = stackalloc byte[SHA256.HashSizeInBytes];
+ SHA256.HashData(name, hash);
+ hash[6] = (byte)((hash[6] & 0x0F) | 0x80);
+ hash[8] = (byte)((hash[8] & 0x3F) | 0x80);
+ return new Guid(hash[..16], bigEndian: true);
+ }
+
///
/// Removes what an interrupted attempt left of : the encoder's hidden temporary file or
/// folder, and an output that was completed but never recorded (it renders again under the same name).
///
- private static void Discard(string output)
+ private static void Discard(string output, bool keepOutput)
{
var parent = Path.GetDirectoryName(output);
if (parent is null || !Directory.Exists(parent)) return;
- foreach (var leftover in Directory.EnumerateFileSystemEntries(parent, "." + Path.GetFileName(output) + ".*.tmp").Append(output))
+ var leftovers = Directory.EnumerateFileSystemEntries(parent, "." + Path.GetFileName(output) + ".*.tmp");
+ foreach (var leftover in keepOutput ? leftovers : leftovers.Append(output))
{
if (Directory.Exists(leftover)) Directory.Delete(leftover, recursive: true);
else if (File.Exists(leftover)) File.Delete(leftover);
diff --git a/src/Titano.Data/Processing/OutputNames.cs b/src/Titano.Data/Processing/OutputNames.cs
new file mode 100644
index 00000000..f4d97b28
--- /dev/null
+++ b/src/Titano.Data/Processing/OutputNames.cs
@@ -0,0 +1,55 @@
+using System.Collections.Concurrent;
+
+namespace Titano.Data.Processing;
+
+///
+/// The output paths the renders of this process are writing. Encoders write to a hidden temporary file and rename it over
+/// the output when they finish, so two renders that picked the same free name (the same preset queued twice) would
+/// overwrite each other: a render reserves each name it picks until it ends.
+///
+internal sealed class OutputNames : IDisposable
+{
+ private static readonly ConcurrentDictionary Writing = new(StringComparer.OrdinalIgnoreCase);
+ private readonly List _mine = [];
+
+ /// A path from , given the test for paths other renders are writing, reserved for this render.
+ public string Reserve(Func, string> pick)
+ {
+ while (true)
+ {
+ var path = pick(p => Writing.ContainsKey(Key(p)));
+ // Another render may have taken the same name since: pick again.
+ if (TryReserve(path)) return path;
+ }
+ }
+
+ /// Reserves for this render; false when another render is writing it.
+ public bool TryReserve(string path)
+ {
+ var key = Key(path);
+ if (!Writing.TryAdd(key, 0)) return false;
+ lock (_mine) _mine.Add(key);
+ return true;
+ }
+
+ /// Gives back a path this render reserved, so it can be picked again.
+ public void Release(string path)
+ {
+ var key = Key(path);
+ lock (_mine)
+ {
+ if (_mine.Remove(key)) Writing.TryRemove(key, out _);
+ }
+ }
+
+ public void Dispose()
+ {
+ lock (_mine)
+ {
+ foreach (var key in _mine) Writing.TryRemove(key, out _);
+ _mine.Clear();
+ }
+ }
+
+ private static string Key(string path) => Path.GetFullPath(path);
+}
diff --git a/src/Titano.Data/Processing/SequenceAnalyser.cs b/src/Titano.Data/Processing/SequenceAnalyser.cs
index 241a6ea7..c99cd8c7 100644
--- a/src/Titano.Data/Processing/SequenceAnalyser.cs
+++ b/src/Titano.Data/Processing/SequenceAnalyser.cs
@@ -59,21 +59,26 @@ internal sealed class SequenceAnalyser(TitanoDatabase db, ProcessingOptions opti
(changed, unreadable) = (false, true);
}
- // A deep analysis of the same sequence may have finished meanwhile: count its findings and keep its status.
- report ??= ReadReport(folder, frames.Count);
- var warnings = Advisor.Recommend(light, report, context).Findings.Count(f => f.Severity >= FindingSeverity.Warning);
- var set = SequenceStatus.AnalyzedLight | (report is null ? SequenceStatus.None : SequenceStatus.AnalyzedDeep)
- | (warnings > 0 ? SequenceStatus.HasWarnings : SequenceStatus.None);
- // Without a current report (none, or made before frames were added) the deep status no longer holds.
- var clear = (report is null ? SequenceStatus.AnalyzedDeep : SequenceStatus.None) | (warnings > 0 ? SequenceStatus.None : SequenceStatus.HasWarnings);
- var summary = deep && report is not null ? AnalysisSummary.From(report).ToJson() : null;
- await writer.UpdateAsync(paths, sequence.Id, sequence.Folder, m =>
+ if (changed) await options.NotifyAsync(sequence.Id, ProcessingOptions.SettingsChange, cancellationToken).ConfigureAwait(false);
+
+ int warnings;
+ // Under the sequence lock, which a deep pass of the same sequence also takes to record its report: a light pass
+ // then either sees that report or runs before it is recorded, and never clears what it recorded.
+ await using (await writer.LockAsync(paths, sequence.Id, cancellationToken).ConfigureAwait(false))
{
- var status = (m.Status | set) & ~clear;
- return status == m.Status ? null : m with { Status = status, UpdatedAt = DateTimeOffset.UtcNow };
- }, cancellationToken).ConfigureAwait(false);
- await db.Sequences.RecordAnalysisAsync(sequence.Id, set, clear, warnings, summary, cancellationToken).ConfigureAwait(false);
- await indexer.RecordStampsAsync(archive, folder, sequence.Id, cancellationToken).ConfigureAwait(false);
+ report ??= ReadReport(folder, frames.Count);
+ warnings = Advisor.Recommend(light, report, context).Findings.Count(f => f.Severity >= FindingSeverity.Warning);
+ var set = SequenceStatus.AnalyzedLight | (report is null ? SequenceStatus.None : SequenceStatus.AnalyzedDeep)
+ | (warnings > 0 ? SequenceStatus.HasWarnings : SequenceStatus.None);
+ // Without a current report (none, or made before frames were added) the deep status no longer holds.
+ var clear = (report is null ? SequenceStatus.AnalyzedDeep : SequenceStatus.None) | (warnings > 0 ? SequenceStatus.None : SequenceStatus.HasWarnings);
+ var manifest = SequenceWriter.ReadLocked(folder, sequence.Id);
+ var status = (manifest.Status | set) & ~clear;
+ if (status != manifest.Status) ManifestStore.WriteSequence(folder.ManifestPath, manifest with { Status = status, UpdatedAt = DateTimeOffset.UtcNow });
+ var summary = deep && report is not null ? AnalysisSummary.From(report).ToJson() : null;
+ await db.Sequences.RecordAnalysisAsync(sequence.Id, set, clear, warnings, summary, cancellationToken).ConfigureAwait(false);
+ await indexer.RecordStampsAsync(archive, folder, sequence.Id, cancellationToken).ConfigureAwait(false);
+ }
var presets = deep ? SequencePresets.Generate(light, report, context) : [];
return new AnalysisOutcome(sequence, frames.Count, warnings, changed, unreadable, presets);
diff --git a/src/Titano.Server/Storage/ProcessingModule.cs b/src/Titano.Server/Storage/ProcessingModule.cs
index 1a241bbe..16477d56 100644
--- a/src/Titano.Server/Storage/ProcessingModule.cs
+++ b/src/Titano.Server/Storage/ProcessingModule.cs
@@ -5,7 +5,9 @@ using Titano.Data;
using Titano.Data.Archiving;
using Titano.Data.Jobs;
using Titano.Data.Processing;
+using Titano.Protocol;
using Titano.Server.Configuration;
+using Titano.Server.Events;
namespace Titano.Server.Storage;
@@ -13,19 +15,30 @@ 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).
+/// MP4 jobs stay queued for render nodes (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(sp => new ProcessingService(sp.GetRequiredService(), new ProcessingOptions
+ services.AddSingleton(sp =>
{
- Archive = new ArchiveServiceOptions { Decoder = DecoderFactory.CreateServer(), Owner = ArchiveModule.Owner },
- Encoders = [new ManagedEncoderProvider()],
- Host = EncoderHost.Server,
- ProducedBy = sp.GetRequiredService().ServerName,
- }));
+ var db = sp.GetRequiredService();
+ var events = sp.GetRequiredService();
+ return new ProcessingService(db, new ProcessingOptions
+ {
+ Archive = new ArchiveServiceOptions { Decoder = DecoderFactory.CreateServer(), Owner = ArchiveModule.Owner },
+ Encoders = [new ManagedEncoderProvider()],
+ Host = EncoderHost.Server,
+ ProducedBy = sp.GetRequiredService().ServerName,
+ SequenceChanged = async (id, change, ct) =>
+ {
+ if (await db.Sequences.GetAsync(id, ct) is { } sequence)
+ events.Publish(new SequenceChangedEvent(id, change, sequence.FramesVersion, sequence.SettingsVersion));
+ },
+ });
+ });
services.AddSingleton(sp => sp.GetRequiredService());
}
}
diff --git a/tests/Titano.Data.Tests/Archiving/ArchiveFixture.cs b/tests/Titano.Data.Tests/Archiving/ArchiveFixture.cs
index 299674ff..8635995f 100644
--- a/tests/Titano.Data.Tests/Archiving/ArchiveFixture.cs
+++ b/tests/Titano.Data.Tests/Archiving/ArchiveFixture.cs
@@ -80,11 +80,11 @@ internal sealed class ArchiveFixture : IAsyncDisposable
}
/// Queues a job directly with a checkpoint, as a crashed earlier attempt would have left it.
- public async Task EnqueueWithCheckpointAsync(JobEngine engine, Titano.Data.Archiving.Jobs.ArchiveJobRequest request, string checkpoint)
+ public async Task EnqueueWithCheckpointAsync(JobEngine engine, Titano.Data.Archiving.Jobs.ArchiveJobRequest request, string checkpoint, Guid? id = null)
{
var job = new Job
{
- Id = Guid.CreateVersion7(),
+ Id = id ?? Guid.CreateVersion7(),
Kind = request.Kind,
TargetIds = request.Targets,
ParametersJson = request.ParametersJson,
diff --git a/tests/Titano.Data.Tests/Processing/ProcessingFixture.cs b/tests/Titano.Data.Tests/Processing/ProcessingFixture.cs
index 78ed3a47..9572451f 100644
--- a/tests/Titano.Data.Tests/Processing/ProcessingFixture.cs
+++ b/tests/Titano.Data.Tests/Processing/ProcessingFixture.cs
@@ -45,11 +45,11 @@ internal sealed class ProcessingFixture : IAsyncDisposable
public static async Task CreateAsync(TestContext context) => new(await ArchiveFixture.CreateAsync(context), new GateDecoder());
- /// A started engine with the processing handlers, and the archive's when asked (one worker, fast checkpoints).
- public async Task StartEngineAsync(bool withArchive = false)
+ /// 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)
{
_engine = new JobEngine(Db, [.. withArchive ? Archive.Service.CreateJobHandlers() : [], .. Processing.CreateJobHandlers()],
- new JobEngineOptions { Workers = 1, WorkerId = "test", PollInterval = TimeSpan.FromMilliseconds(50), CheckpointInterval = TimeSpan.FromMilliseconds(50) });
+ new JobEngineOptions { Workers = workers, WorkerId = "test", PollInterval = TimeSpan.FromMilliseconds(50), CheckpointInterval = TimeSpan.FromMilliseconds(50) });
await _engine.StartAsync(Ct);
return _engine;
}
diff --git a/tests/Titano.Data.Tests/Processing/RenderJobTests.cs b/tests/Titano.Data.Tests/Processing/RenderJobTests.cs
index 81307a33..4739af73 100644
--- a/tests/Titano.Data.Tests/Processing/RenderJobTests.cs
+++ b/tests/Titano.Data.Tests/Processing/RenderJobTests.cs
@@ -6,6 +6,7 @@ using Titano.Core.Imaging.Decoders;
using Titano.Core.Localization;
using Titano.Core.Model;
using Titano.Core.Project;
+using Titano.Core.Video;
using Titano.Data.Jobs;
using Titano.Data.Processing;
using Titano.Testing;
@@ -126,18 +127,13 @@ public sealed class RenderJobTests(TestContext context)
Directory.CreateDirectory(exports);
var recorded = Encoding.ASCII.GetBytes("RIFF recorded before the crash");
await File.WriteAllBytesAsync(output, recorded, fx.Ct);
- await fx.Db.Renders.InsertAsync(new Render
- {
- Id = Guid.CreateVersion7(),
- SequenceId = sequence.Id,
- PresetName = "MJPEG",
- OutputPath = "Synthetic/exports/clip-MJPEG.avi",
- Created = DateTimeOffset.UtcNow,
- }, fx.Ct);
+ // The crash came after the job recorded its first entry and before its checkpoint said so.
+ var jobId = Guid.CreateVersion7();
+ await fx.Db.Renders.InsertAsync(RecordedRender(sequence, Titano.Data.Processing.Jobs.RenderJobHandler.RenderId(jobId, 0)), fx.Ct);
await fx.StartEngineAsync();
var job = await fx.Archive.EnqueueWithCheckpointAsync(fx.Engine, ProcessingJobs.Render(sequence, Mjpeg with { Batch = ["gif-preview"] }, 96, 64),
- new RenderCheckpoint([], 0, output).ToJson());
+ new RenderCheckpoint([], 0, output).ToJson(), jobId);
await fx.WaitForAsync(job.Id, JobState.Done);
var kept = await File.ReadAllBytesAsync(output, fx.Ct);
@@ -146,6 +142,74 @@ public sealed class RenderJobTests(TestContext context)
Assert.Count(2, await fx.Db.Renders.ListBySequenceAsync(sequence.Id, fx.Ct));
}
+ [Test]
+ public async Task ARenderResumedAfterAnotherRecordedItsNameKeepsThatOutput()
+ {
+ await using var fx = await ProcessingFixture.CreateAsync(context);
+ var sequence = await fx.AddAsync(Scene());
+ var exports = fx.Folder(sequence).Exports;
+ var output = Path.Combine(exports, "clip-MJPEG.avi");
+ Directory.CreateDirectory(exports);
+ // While this job waited to resume, another render of the same preset finished under the name it had chosen.
+ var other = Encoding.ASCII.GetBytes("RIFF another render's output");
+ await File.WriteAllBytesAsync(output, other, fx.Ct);
+ await fx.Db.Renders.InsertAsync(RecordedRender(sequence, Guid.CreateVersion7()), fx.Ct);
+ await fx.StartEngineAsync();
+
+ var job = await fx.Archive.EnqueueWithCheckpointAsync(fx.Engine, ProcessingJobs.Render(sequence, Mjpeg, 96, 64), new RenderCheckpoint([], 0, output).ToJson());
+ await fx.WaitForAsync(job.Id, JobState.Done);
+
+ var kept = await File.ReadAllBytesAsync(output, fx.Ct);
+ Assert.BytesEqual(other, kept);
+ Assert.SequenceEqual(["clip-MJPEG (2).avi", "clip-MJPEG.avi"], Entries(exports));
+ Assert.Count(2, await fx.Db.Renders.ListBySequenceAsync(sequence.Id, fx.Ct));
+ }
+
+ [Test]
+ public async Task ConcurrentRendersOfOnePresetKeepBothOutputs()
+ {
+ await using var fx = await ProcessingFixture.CreateAsync(context);
+ var sequence = await fx.AddAsync(Scene());
+ await fx.StartEngineAsync(workers: 2);
+
+ var first = await fx.EnqueueAsync(ProcessingJobs.Render(sequence, Mjpeg, 96, 64));
+ var second = await fx.EnqueueAsync(ProcessingJobs.Render(sequence, Mjpeg, 96, 64));
+ await fx.WaitForAsync(first.Id, JobState.Done);
+ await fx.WaitForAsync(second.Id, JobState.Done);
+
+ Assert.SequenceEqual(["clip-MJPEG (2).avi", "clip-MJPEG.avi"], Entries(fx.Folder(sequence).Exports));
+ var renders = await fx.Db.Renders.ListBySequenceAsync(sequence.Id, fx.Ct);
+ Assert.Equal(2, renders.Select(r => r.OutputPath).Distinct().Count());
+ }
+
+ [Test]
+ public void ANameBeingWrittenIsNotPickedAgain()
+ {
+ var folder = context.CreateTempDirectory("exports");
+ var name = new ExportNameContext { Date = new DateTime(2026, 6, 1), Title = "Roof", PresetName = "MJPEG", Codec = VideoCodec.Mjpeg };
+ using var a = new OutputNames();
+ using var b = new OutputNames();
+ var first = a.Reserve(taken => ExportNaming.OutputPath(folder, "{title}", name, taken));
+ var second = b.Reserve(taken => ExportNaming.OutputPath(folder, "{title}", name, taken));
+ Assert.Equal((Path.Combine(folder, "Roof.avi"), Path.Combine(folder, "Roof (2).avi")), (first, second));
+ Assert.False(b.TryReserve(first), "held by the first render");
+
+ a.Dispose();
+ using var c = new OutputNames();
+ Assert.Equal(first, c.Reserve(taken => ExportNaming.OutputPath(folder, "{title}", name, taken)));
+ }
+
+ [Test]
+ public void RenderRowIdsAreStablePerJobAndEntry()
+ {
+ var job = Guid.CreateVersion7();
+ var id = Titano.Data.Processing.Jobs.RenderJobHandler.RenderId(job, 0);
+ Assert.Equal(id, Titano.Data.Processing.Jobs.RenderJobHandler.RenderId(job, 0));
+ Assert.NotEqual(id, Titano.Data.Processing.Jobs.RenderJobHandler.RenderId(job, 1));
+ Assert.NotEqual(id, Titano.Data.Processing.Jobs.RenderJobHandler.RenderId(Guid.CreateVersion7(), 0));
+ Assert.Equal(8, id.Version);
+ }
+
[Test]
public async Task AServerTakesOnlyTheRendersItsManagedEncodersProduce()
{
@@ -160,6 +224,10 @@ public sealed class RenderJobTests(TestContext context)
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");
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");
@@ -177,6 +245,19 @@ public sealed class RenderJobTests(TestContext context)
Assert.Equal((3840, 2160), (parameters[2].Width, parameters[2].Height));
}
+ /// MJPEG job parameters whose preset JSON is .
+ private static string WithPreset(string presetJson) => System.Text.Json.JsonSerializer.Serialize(
+ new Titano.Protocol.RenderJobParameters("MJPEG", presetJson, "mjpeg", 96, 64, false, null), Titano.Protocol.ProtocolJson.Default.RenderJobParameters);
+
+ private static Render RecordedRender(Sequence sequence, Guid id) => new()
+ {
+ Id = id,
+ SequenceId = sequence.Id,
+ PresetName = "MJPEG",
+ OutputPath = "Synthetic/exports/clip-MJPEG.avi",
+ Created = DateTimeOffset.UtcNow,
+ };
+
private static List Entries(string folder) =>
Directory.Exists(folder) ? [.. Directory.EnumerateFileSystemEntries(folder).Select(e => Path.GetFileName(e)).Order(StringComparer.Ordinal)] : [];
diff --git a/tests/Titano.Server.Tests/Storage/ProcessingModuleTests.cs b/tests/Titano.Server.Tests/Storage/ProcessingModuleTests.cs
index 059432c1..aeb83eb6 100644
--- a/tests/Titano.Server.Tests/Storage/ProcessingModuleTests.cs
+++ b/tests/Titano.Server.Tests/Storage/ProcessingModuleTests.cs
@@ -1,11 +1,17 @@
+using System.Net;
+using System.Net.Http.Json;
+using System.Text.Json;
using Microsoft.Extensions.DependencyInjection;
using Titano.Core.Archiving;
using Titano.Core.Codecs.Jpeg;
using Titano.Core.Diagnostics.Synthetic;
using Titano.Core.Metadata;
using Titano.Core.Model;
+using Titano.Core.Localization;
using Titano.Core.Project;
using Titano.Data.Processing;
+using Titano.Protocol;
+using Titano.Server.Events;
using Titano.Server.Jobs;
using Titano.Server.Storage;
using Titano.Server.Tests.Jobs;
@@ -33,6 +39,7 @@ public sealed class ProcessingModuleTests(TestContext context)
public async Task UploadedFramesAreLightAnalysedAndAdvised()
{
await using var server = await TestServer.StartAsync(context, services: Production);
+ using var events = server.Services.GetRequiredService().Subscribe();
var (editor, _, _) = await server.UserAsync("alberto", "editor");
var sequenceId = await UploadSceneAsync(editor);
@@ -52,12 +59,15 @@ public sealed class ProcessingModuleTests(TestContext context)
var folder = new ArchivePaths(server.Options.ArchivePath).Sequence(sequence.Folder);
Assert.FileExists(folder.ProjectPath);
Assert.True(ManifestStore.ReadSequence(folder.ManifestPath).Status.HasFlag(SequenceStatus.AnalyzedLight), "sidecar status");
+ // Connected clients learn that the Auto values changed (BRIEF §14.3).
+ Assert.Contains(Drain(events), e => e is SequenceChangedEvent { Change: "settings" } changed && changed.SequenceId == sequenceId);
}
[Test]
public async Task TheServerRendersManagedFormatsAndLeavesMp4ToRenderNodes()
{
await using var server = await TestServer.StartAsync(context, services: Production);
+ using var events = server.Services.GetRequiredService().Subscribe();
var (editor, _, _) = await server.UserAsync("alberto", "editor");
var sequence = (await server.Database.Sequences.GetAsync(await UploadSceneAsync(editor)))!;
// A client's export folder means nothing on the server: the output still goes to the sequence's exports.
@@ -81,6 +91,68 @@ public sealed class ProcessingModuleTests(TestContext context)
Assert.Empty(Directory.EnumerateFileSystemEntries(avi.Folder));
var waiting = await JobApiTests.GetAsync(editor, mp4.Id);
Assert.Equal(("queued", (string?)null), (waiting.State, waiting.NodeId));
+ Assert.Contains(Drain(events), e => e is SequenceChangedEvent { Change: "renders" } changed && changed.SequenceId == sequence.Id);
+ }
+
+ [Test]
+ public async Task APostedBatchBecomesOneJobPerPreset()
+ {
+ await using var server = await TestServer.StartAsync(context, services: Production);
+ var (editor, _, _) = await server.UserAsync("alberto", "editor");
+ var sequence = (await server.Database.Sequences.GetAsync(await UploadSceneAsync(editor)))!;
+ var batch = new ExportSettings
+ {
+ Preset = new Auto().WithManual("mjpeg-avi"),
+ Overrides = new ExportOverrides { Width = 96, Height = 64 },
+ NameTemplate = "{title} - {codec}",
+ Batch = ["gif-preview", "1080p-h264"],
+ };
+
+ var main = await JobApiTests.CreateAsync(editor, "render", sequence.Id, ProcessingJobs.Render(sequence, batch, 96, 64).ParametersJson);
+ var jobs = (await server.Database.Jobs.ListAsync(null, JobKind.Render)).Items;
+ Assert.Count(3, jobs);
+ var mp4 = jobs.Single(j => j.TargetLabel!.EndsWith(Loc.L("Export.Preset.1080pShare"), StringComparison.Ordinal));
+ var gif = jobs.Single(j => j.TargetLabel!.EndsWith(Loc.L("Export.Preset.Gif"), StringComparison.Ordinal));
+ await JobApiTests.WaitForAsync(editor, main.Id, "done");
+ await JobApiTests.WaitForAsync(editor, gif.Id, "done");
+
+ // The server renders the managed presets; the MP4 one waits for a render node, at the preset's size.
+ Assert.SequenceEqual(["Gif", "Mjpeg"], (await server.Database.Renders.ListBySequenceAsync(sequence.Id)).Select(r => r.Codec!).Order(StringComparer.Ordinal));
+ Assert.Equal("queued", (await JobApiTests.GetAsync(editor, mp4.Id)).State);
+ var parameters = JsonSerializer.Deserialize(mp4.ParametersJson!, ProtocolJson.Default.RenderJobParameters)!;
+ Assert.Equal(("h264", 1920, 1080), (parameters.Codec, parameters.Width, parameters.Height));
+ }
+
+ [Test]
+ public async Task RenderJobsThatCannotBeReadNeverStopTheEngine()
+ {
+ await using var server = await TestServer.StartAsync(context, services: Production);
+ var (editor, user, _) = await server.UserAsync("alberto", "editor");
+ var sequence = (await server.Database.Sequences.GetAsync(await UploadSceneAsync(editor)))!;
+ const string mjpeg = """{"preset":{"isAuto":false,"manual":"mjpeg-avi"},"overrides":{"width":96,"height":64}""";
+
+ // The API refuses a preset that gives a member twice; one already queued fails with its reason.
+ using (var refused = await editor.PostAsJsonAsync("/api/v1/jobs",
+ new CreateJobRequest("render", [sequence.Id], Parameters(mjpeg + ""","Preset":{}}""")), ProtocolJson.Default.CreateJobRequest))
+ await refused.ExpectErrorAsync(HttpStatusCode.BadRequest, "invalid_parameters");
+ var engine = server.Services.GetRequiredService().Engine;
+ var broken = await engine.EnqueueAsync(JobKind.Render, [sequence.Id], "broken", Parameters(mjpeg + ""","Preset":{}}"""), JobPriority.User, user.Id);
+ var failed = await JobApiTests.WaitForAsync(editor, broken.Id, "failed");
+ Assert.Equal(Loc.L("Errors.Render.Parameters"), failed.Error);
+
+ // The workers carry on: a null batch is no batch.
+ var fine = await JobApiTests.CreateAsync(editor, "render", sequence.Id, Parameters(mjpeg + ""","batch":null}"""));
+ await JobApiTests.WaitForAsync(editor, fine.Id, "done");
+ }
+
+ private static string Parameters(string presetJson) =>
+ JsonSerializer.Serialize(new RenderJobParameters("MJPEG", presetJson, "mjpeg", 96, 64, false, null), ProtocolJson.Default.RenderJobParameters);
+
+ private static List Drain(EventHub.Subscription events)
+ {
+ var drained = new List();
+ while (events.Reader.TryRead(out var e)) drained.Add(e);
+ return drained;
}
/// Uploads a synthetic scene with Exif into one new sequence; returns its id.