A render reserves the output name it picks, so the same preset queued twice no longer overwrites one output with the other; render rows take ids from their job and entry, so a resumed job recognises only its own outputs and never deletes another render's file. A light pass records its status under the sequence lock and cannot clear a deep pass's. Renders and Auto value changes made by the server engine publish sequenceChanged events. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
173 lines
9.3 KiB
C#
173 lines
9.3 KiB
C#
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;
|
|
using Titano.Testing;
|
|
|
|
namespace Titano.Server.Tests.Storage;
|
|
|
|
/// <summary>
|
|
/// The production composition: frames committed by the archive engine are light-analysed by the processing handlers,
|
|
/// and the server renders the managed formats itself.
|
|
/// </summary>
|
|
[Category("processing")]
|
|
public sealed class ProcessingModuleTests(TestContext context)
|
|
{
|
|
private const int Frames = 10;
|
|
|
|
/// <summary>The registrations of Program.cs.</summary>
|
|
private static void Production(IServiceCollection services)
|
|
{
|
|
ArchiveModule.Register(services);
|
|
ProcessingModule.Register(services);
|
|
}
|
|
|
|
[Test]
|
|
public async Task UploadedFramesAreLightAnalysedAndAdvised()
|
|
{
|
|
await using var server = await TestServer.StartAsync(context, services: Production);
|
|
using var events = server.Services.GetRequiredService<EventHub>().Subscribe();
|
|
var (editor, _, _) = await server.UserAsync("alberto", "editor");
|
|
var sequenceId = await UploadSceneAsync(editor);
|
|
|
|
// The commits queue a light analysis; its handler comes from the processing module.
|
|
var until = DateTime.UtcNow + TimeSpan.FromSeconds(30);
|
|
Sequence sequence;
|
|
while (true)
|
|
{
|
|
sequence = (await server.Database.Sequences.GetAsync(sequenceId))!;
|
|
if (sequence.Status.HasFlag(SequenceStatus.AnalyzedLight) && sequence.FrameCount == Frames
|
|
&& !await server.Database.Jobs.IsQueuedAsync(JobKind.LightAnalyse, sequenceId)) break;
|
|
Assert.True(DateTime.UtcNow < until, $"not analysed: {sequence.Status}, {sequence.FrameCount} frames");
|
|
await Task.Delay(100);
|
|
}
|
|
var project = ProjectSettings.FromJson(Assert.NotNull(sequence.SettingsJson));
|
|
Assert.True(project.Timing.Mode.HasAdvice, "timing mode advised");
|
|
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<EventHub>().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.
|
|
var avi = new ExportSettings
|
|
{
|
|
Preset = new Auto<string>().WithManual("mjpeg-avi"),
|
|
Overrides = new ExportOverrides { Width = 96, Height = 64 },
|
|
NameTemplate = "clip",
|
|
Folder = context.CreateTempDirectory("elsewhere"),
|
|
};
|
|
var hevc = new ExportSettings { Preset = new Auto<string>().WithManual("4k-hevc") };
|
|
|
|
var mp4 = await JobApiTests.CreateAsync(editor, "render", sequence.Id, ProcessingJobs.Render(sequence, hevc, 96, 64).ParametersJson);
|
|
var managed = await JobApiTests.CreateAsync(editor, "render", sequence.Id, ProcessingJobs.Render(sequence, avi, 96, 64).ParametersJson);
|
|
var done = await JobApiTests.WaitForAsync(editor, managed.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.avi", server.Options.ServerName, "Mjpeg"), (render.OutputPath, render.ProducedBy, render.Codec));
|
|
Assert.FileExists(Path.Combine(server.Options.ArchivePath, render.OutputPath));
|
|
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<string>().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<JobEngineHost>().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<ServerEvent> Drain(EventHub.Subscription events)
|
|
{
|
|
var drained = new List<ServerEvent>();
|
|
while (events.Reader.TryRead(out var e)) drained.Add(e);
|
|
return drained;
|
|
}
|
|
|
|
/// <summary>Uploads a synthetic scene with Exif into one new sequence; returns its id.</summary>
|
|
private static async Task<Guid> UploadSceneAsync(HttpClient editor)
|
|
{
|
|
var scene = SyntheticSequence.Create(new SyntheticSequenceOptions { FrameCount = Frames, StartEv = 0.5, EndEv = -0.5 });
|
|
Guid sequenceId = default;
|
|
for (var i = 0; i < scene.Count; i++)
|
|
{
|
|
using var image = scene.Render(i);
|
|
var exif = ExifWriter.BuildJpegApp1(scene.Metadata[i]);
|
|
var photo = JpegEncoder.Encode(image, new JpegEncodeOptions { Quality = 90, App1Segments = [exif[4..]] });
|
|
sequenceId = (await Uploads.UploadAsync(editor, photo, $"IMG_{i + 1:0000}.JPG", sessionKey: "roof")).SequenceId;
|
|
}
|
|
return sequenceId;
|
|
}
|
|
}
|