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 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
214 lines
12 KiB
C#
214 lines
12 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 Mp4JobsNoRenderNodeCanTakeAreRenderedAsMjpegAndTheLogSaysSo()
|
|
{
|
|
var clock = new ManualTimeProvider();
|
|
await using var server = await TestServer.StartAsync(context, o => o.NodeTimeoutSeconds = 60, s =>
|
|
{
|
|
Production(s);
|
|
s.AddSingleton<TimeProvider>(clock);
|
|
});
|
|
var engine = server.Services.GetRequiredService<JobEngineHost>().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<string>().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()
|
|
{
|
|
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;
|
|
}
|
|
}
|