using System.Net; using System.Net.Http.Json; using System.Text.Json; using Microsoft.Extensions.DependencyInjection; using Chronos.Core.Archiving; using Chronos.Core.Project; using Chronos.Data; using Chronos.Data.Archiving; using Chronos.Data.Processing; using Chronos.Data.Repositories; using Chronos.Protocol; using Chronos.Protocol.Client; using Chronos.Server.Api; using Chronos.Server.Jobs; using Chronos.Server.Storage; using Chronos.Testing; namespace Chronos.Server.Tests.Jobs; [Category("server")] public sealed class RenderNodeTests(TestContext context) { internal static readonly string HevcJob = JsonSerializer.Serialize( new RenderJobParameters("4K HEVC", """{"codec":"hevc","bitrate":60}""", "hevc", 3840, 2160, UseProxies: false, null), ProtocolJson.Default.RenderJobParameters); [Test] public async Task NodesClaimWhatTheyCanEncodeAndLoseJobsWhenSilent() { var clock = new ManualTimeProvider(); await using var server = await TestServer.StartAsync(context, o => o.NodeTimeoutSeconds = 60, s => s.AddSingleton(clock)); var (editor, _, _) = await server.UserAsync("alberto", "editor", renderNode: true); var frame = await Uploads.UploadAsync(editor, Uploads.Photo(5000, 51), "IMG_0001.CR3"); var job = await JobApiTests.CreateAsync(editor, "render", frame.SequenceId, HevcJob); var studio = await RegisterAsync(editor, "studio-pc", "hevc", 8192); var laptop = await RegisterAsync(editor, "laptop", "h264", 4096); var spare = await RegisterAsync(editor, "spare-pc", "HEVC", 0); using (var none = await editor.PostAsync($"/api/v1/nodes/{laptop.Id}/claim", null)) await none.ExpectAsync(HttpStatusCode.NoContent); ClaimedJob claimed; using (var claim = await editor.PostAsync($"/api/v1/nodes/{studio.Id}/claim", null)) { await claim.ExpectAsync(HttpStatusCode.OK); claimed = await claim.ReadAsync(ProtocolJson.Default.ClaimedJob); } Assert.Equal((job.Id, frame.SequenceId, "running"), (claimed.Job.Id, claimed.SequenceId, claimed.Job.State)); Assert.Equal(frame.FrameId, claimed.Frames.Single().Id); Assert.Equal(studio.Id.ToString(), claimed.Job.NodeId); using (var second = await editor.PostAsync($"/api/v1/nodes/{spare.Id}/claim", null)) await second.ExpectAsync(HttpStatusCode.NoContent); using (var progress = await editor.PostAsJsonAsync($"/api/v1/nodes/{studio.Id}/jobs/{job.Id}/progress", new NodeProgress(120, 3600, 40, "encoding"), ProtocolJson.Default.NodeProgress)) await progress.ExpectAsync(HttpStatusCode.NoContent); Assert.Equal(120L, (await JobApiTests.GetAsync(editor, job.Id)).ProgressDone); // studio-pc goes silent; the others keep heart-beating. clock.Advance(TimeSpan.FromSeconds(90)); foreach (var alive in new[] { laptop, spare }) using (var beat = await editor.PostAsync($"/api/v1/nodes/{alive.Id}/heartbeat", null)) await beat.ExpectAsync(HttpStatusCode.NoContent); await server.Services.GetRequiredService().SweepAsync(context.Cancellation); var requeued = await JobApiTests.GetAsync(editor, job.Id); Assert.Equal("queued", requeued.State); Assert.Contains("studio-pc stopped responding", requeued.LogTail); using (var nodes = await editor.GetAsync("/api/v1/nodes")) { var states = (await nodes.ReadAsync(ProtocolJson.Default.ListRenderNodeDto)).ToDictionary(n => n.ClientName, n => n.State); Assert.Equal(("offline", "idle"), (states["studio-pc"], states["laptop"])); } using (var late = await editor.PostAsJsonAsync($"/api/v1/nodes/{studio.Id}/jobs/{job.Id}/progress", new NodeProgress(200, 3600, 40, null), ProtocolJson.Default.NodeProgress)) await late.ExpectErrorAsync(HttpStatusCode.Conflict, "job_not_assigned"); using (var reassigned = await editor.PostAsync($"/api/v1/nodes/{spare.Id}/claim", null)) { var again = await reassigned.ReadAsync(ProtocolJson.Default.ClaimedJob); Assert.Equal((job.Id, 2), (again.Job.Id, again.Job.Attempts)); } } [Test] public async Task EachEncoderTakesOnlyJobsWithinItsOwnSizeLimit() { await using var server = await TestServer.StartAsync(context); var (editor, _, _) = await server.UserAsync("alberto", "editor", renderNode: true); var sequence = await JobApiTests.CreateSequenceAsync(editor); // The software H.264 encoder stops at 4096 px although the node's MJPEG encoder writes far larger frames. using var registered = await editor.PostAsJsonAsync("/api/v1/nodes/register", new RegisterNodeRequest("studio-pc", [new NodeEncoder("h264", "H.264 Encoder MFT", false, false, 4096, 2304), new NodeEncoder("mjpeg", "Managed MJPEG", false, false, 65535, 65535)], 65535, 65535), ProtocolJson.Default.RegisterNodeRequest); var node = await registered.ReadAsync(ProtocolJson.Default.RenderNodeDto); Assert.Equal((4096, 2304), (node.Encoders[0].MaxWidth, node.Encoders[0].MaxHeight)); await JobApiTests.CreateAsync(editor, "render", sequence, H264Job(6144, 3456)); using (var none = await editor.PostAsync($"/api/v1/nodes/{node.Id}/claim", null)) await none.ExpectAsync(HttpStatusCode.NoContent); var uhd = await JobApiTests.CreateAsync(editor, "render", sequence, H264Job(3840, 2160)); using var claim = await editor.PostAsync($"/api/v1/nodes/{node.Id}/claim", null); Assert.Equal(uhd.Id, (await claim.ReadAsync(ProtocolJson.Default.ClaimedJob)).Job.Id); } /// /// Owner review 1, phase 4: a node that does not announce its settings format (an older Chronos) reads format 1, and is /// never given a job it would render otherwise than asked: settings of format 2 (a turn), the chosen proportions in a /// fixed-size preset (4K at 9:16 = 2160×3840), or a sequence's settings changed to format 2 after the job was queued. A /// node of format 2 takes them, a portrait UHD frame on an encoder announced as 4096×2304 included. /// [Test] public async Task OnlyNodesThatReadTheSettingsFormatTakeTheJobsThatNeedIt() { await using var server = await TestServer.StartAsync(context); var (editor, _, _) = await server.UserAsync("alberto", "editor", renderNode: true); using var old = await editor.PostAsync("/api/v1/nodes/register", new StringContent( """{"clientName":"old-pc","encoders":[{"codec":"h264","name":"H.264 Encoder MFT","hardware":false,"tenBit":false}],"maxWidth":4096,"maxHeight":4096}""", System.Text.Encoding.UTF8, "application/json")); var older = await old.ReadAsync(ProtocolJson.Default.RenderNodeDto); var stored = Assert.NotNull(Dto.Capabilities(Assert.NotNull(await server.Database.RenderNodes.GetAsync(older.Id)))); Assert.Equal(1, stored.SettingsFormat); var sequence = await JobApiTests.CreateSequenceAsync(editor); var turned = new ProjectSettings { Camera = new CameraSettings { Rotate = 90 } }.ToJson(); var portrait = new ProjectSettings { Camera = new CameraSettings { Aspect = new Auto().WithManual("9:16") } }.ToJson(); var v2 = await JobApiTests.CreateAsync(editor, "render", sequence, WithSettings(H264Job(3840, 2160), turned)); var proportions = await JobApiTests.CreateAsync(editor, "render", sequence, WithSettings(H264Job(3840, 2160), portrait)); var routed = ProcessingJobs.ReadRender((await server.Database.Jobs.GetAsync(proportions.Id))!.ParametersJson).Parameters; Assert.Equal((2160, 3840, 2), (routed.Width, routed.Height, routed.RequiredSettingsFormat), "the server sized the job posted at the preset's size"); // Queued as format 1, then the sequence's own settings took a turn. var plain = await JobApiTests.CreateAsync(editor, "render", sequence, H264Job(3840, 2160)); Assert.Equal(1, ProcessingJobs.ReadRender((await server.Database.Jobs.GetAsync(plain.Id))!.ParametersJson).Parameters.RequiredSettingsFormat); var row = (await server.Database.Sequences.GetAsync(sequence))!; await server.Database.Sequences.EditAsync(sequence, new SequenceEdit { SettingsJson = turned }, row.SettingsVersion); using (var none = await editor.PostAsync($"/api/v1/nodes/{older.Id}/claim", null)) await none.ExpectAsync(HttpStatusCode.NoContent); // The software H.264 encoder takes portrait UHD as a long edge × short edge, on a node that knows it. using var registered = await editor.PostAsJsonAsync("/api/v1/nodes/register", new RegisterNodeRequest("studio-pc", [new NodeEncoder("h264", "H.264 Encoder MFT", false, false, 4096, 2304)], 4096, 2304, SettingsFormat: 2), ProtocolJson.Default.RegisterNodeRequest); var newer = await registered.ReadAsync(ProtocolJson.Default.RenderNodeDto); var claimed = new List(); for (var i = 0; i < 3; i++) { using var claim = await editor.PostAsync($"/api/v1/nodes/{newer.Id}/claim", null); claimed.Add((await claim.ReadAsync(ProtocolJson.Default.ClaimedJob)).Job.Id); } Assert.SequenceEqual(new[] { v2.Id, proportions.Id, plain.Id }.Order(), claimed.Order()); } /// /// An encoder's limit is a long edge × short edge on a node of format 2 (its encoders take portrait UHD within 4096×2304); /// an older node shrinks a frame to the limit as announced, so it is held to that. /// [Test] public void APortraitFrameFitsALandscapeLimitOnlyOnANodeThatKnowsIt() { var job = new RenderJobParameters("4K", "{}", "h264", 2160, 3840, UseProxies: false, null, RequiredSettingsFormat: 2); NodeEncoder[] software = [new("h264", "H.264 Encoder MFT", false, false, 4096, 2304)]; var older = new RegisterNodeRequest("old-pc", software, 4096, 2304); var newer = older with { ClientName = "studio-pc", SettingsFormat = 2 }; Assert.False(RenderNodeService.CanEncode(older, job)); Assert.True(RenderNodeService.CanEncode(newer, job)); Assert.True(RenderNodeService.Renders(newer, job)); Assert.False(RenderNodeService.Renders(older, job with { Width = 1080, Height = 1920 }), "format 2 is never sent to a format-1 node"); Assert.True(RenderNodeService.Renders(older, job with { Width = 3840, Height = 2160, RequiredSettingsFormat = 1 })); Assert.False(RenderNodeService.CanEncode(newer, job with { Width = 2400 }), "both edges above the short limit"); } /// A job waits for a node only while one online could render it: one of an older settings format cannot. [Test] public async Task AJobDoesNotWaitForNodesThatCannotReadItsSettings() { await using var server = await TestServer.StartAsync(context, o => o.NodeTimeoutSeconds = 60); var (editor, _, _) = await server.UserAsync("alberto", "editor", renderNode: true); await RegisterAsync(editor, "old-pc", "h264", 4096); var sequence = await JobApiTests.CreateSequenceAsync(editor); var turned = new ProjectSettings { Camera = new CameraSettings { Rotate = 90 } }.ToJson(); var created = await JobApiTests.CreateAsync(editor, "render", sequence, WithSettings(H264Job(1920, 1080), turned)); var queued = (await server.Database.Jobs.GetAsync(created.Id))!; var parameters = ProcessingJobs.ReadRender(queued.ParametersJson).Parameters; Assert.Equal(2, parameters.RequiredSettingsFormat); // Waited longer than a node may stay silent: only an online node that renders it keeps it waiting. var job = queued with { Created = DateTimeOffset.UtcNow - TimeSpan.FromSeconds(61) }; RenderNodeAvailability Availability() => new(server.Database, server.Options, TimeProvider.System); Assert.True(await Availability().AwaitsNodeAsync(queued with { Created = DateTimeOffset.UtcNow }, parameters, context.Cancellation), "a node may be reconnecting"); Assert.False(await Availability().AwaitsNodeAsync(job, parameters, context.Cancellation), "only a node of format 1 is online"); Assert.True(await Availability().AwaitsNodeAsync(job, parameters with { RequiredSettingsFormat = 1 }, context.Cancellation), "it renders a job of format 1"); using (var registered = await editor.PostAsJsonAsync("/api/v1/nodes/register", new RegisterNodeRequest("studio-pc", [new NodeEncoder("h264", "NVENC", true, false)], 4096, 4096, SettingsFormat: 2), ProtocolJson.Default.RegisterNodeRequest)) await registered.ExpectAsync(HttpStatusCode.OK); Assert.True(await Availability().AwaitsNodeAsync(job, parameters, context.Cancellation), "a node of format 2 is online"); } [Test] public async Task TheOutputUploadBecomesARenderAndFinishesTheJob() { await using var server = await TestServer.StartAsync(context, o => o.ChunkSizeBytes = 64 * 1024); var (editor, _, token) = await server.UserAsync("alberto", "editor", renderNode: true); var frame = await Uploads.UploadAsync(editor, Uploads.Photo(5000, 52), "IMG_0001.CR3"); var job = await JobApiTests.CreateAsync(editor, "render", frame.SequenceId, HevcJob); using var client = new ChronosClient(server.HttpBase, new CertificatePinning([]), "studio-pc") { Token = token }; var node = await client.RegisterNodeAsync(new RegisterNodeRequest("studio-pc", [new NodeEncoder("hevc", "NVENC HEVC", true, true)], 8192, 8192)); var claimed = Assert.NotNull(await client.ClaimAsync(node.Id)); await client.ReportNodeProgressAsync(node.Id, claimed.Job.Id, new NodeProgress(3600, 3600, 50, "muxing")); var output = Path.Combine(context.CreateTempDirectory("render"), "Harbour sunset - 4K HEVC.mp4"); var video = Uploads.Photo(150_000, 53); await File.WriteAllBytesAsync(output, video); var render = await client.UploadRenderResultAsync(node.Id, job.Id, output, new RenderResultRequest(Path.GetFileName(output), video.Length, Uploads.Sha(video), "4K HEVC", "hevc", 3840, 2160, 25, 144)); Assert.Equal(("4K HEVC", "studio-pc", (long)video.Length), (render.PresetName, render.ProducedBy, render.Bytes)); var done = await JobApiTests.GetAsync(editor, job.Id); Assert.Equal("done", done.State); var sequence = (await server.Database.Sequences.GetAsync(frame.SequenceId))!; Assert.Equal(1, sequence.RenderedCount); var file = Path.Combine(server.Options.ArchivePath, sequence.Folder, "exports", "Harbour sunset - 4K HEVC.mp4"); await Http.BytesEqualAsync(video, File.ReadAllBytesAsync(file)); using var renders = await editor.GetAsync($"/api/v1/sequences/{sequence.Id}/renders"); Assert.Equal(render.Id, (await renders.ReadAsync(ProtocolJson.Default.ListRenderDto)).Single().Id); } [Test] public async Task ARenderThatCannotBeFiledForNowIsCompletedAgain() { // The archive engine with a short lease wait: a sequence another writer holds refuses the filing at once. await using var server = await TestServer.StartAsync(context, o => o.ChunkSizeBytes = 64 * 1024, s => s.AddSingleton(sp => new ArchiveService(sp.GetRequiredService(), new ArchiveServiceOptions { Owner = ArchiveModule.Owner, LeaseWait = TimeSpan.FromMilliseconds(200) }))); var (editor, _, _) = await server.UserAsync("alberto", "editor", renderNode: true); var frame = await Uploads.UploadAsync(editor, Uploads.Photo(5000, 54), "IMG_0001.CR3"); var job = await JobApiTests.CreateAsync(editor, "render", frame.SequenceId, HevcJob); var node = await RegisterAsync(editor, "studio-pc", "hevc", 8192); using (var claim = await editor.PostAsync($"/api/v1/nodes/{node.Id}/claim", null)) await claim.ExpectAsync(HttpStatusCode.OK); // A render node's output, and a render a client sends of the same sequence, both fully received. var output = Uploads.Photo(3000, 55); var result = new RenderResultRequest("Roof - 4K HEVC.mp4", output.Length, Uploads.Sha(output), "4K HEVC", "hevc", 3840, 2160, 25, 120); Guid fromNode; using (var started = await editor.PostAsJsonAsync($"/api/v1/nodes/{node.Id}/jobs/{job.Id}/result", result, ProtocolJson.Default.RenderResultRequest)) { await started.ExpectAsync(HttpStatusCode.Created); fromNode = Assert.NotNull((await started.ReadAsync(ProtocolJson.Default.StartUploadResponse)).UploadId); } using (var put = await Uploads.PutChunkAsync(editor, fromNode, 0, output)) await put.ExpectAsync(HttpStatusCode.OK); var sent = Uploads.Photo(2000, 56); var offered = new RenderUploadRequest(Guid.CreateVersion7(), "Roof.mp4", sent.Length, Uploads.Sha(sent), "1080p", "h264", 1920, 1080, 30, 10, null); Guid fromClient; using (var started = await editor.PostAsJsonAsync($"/api/v1/sequences/{frame.SequenceId}/renders", offered, ProtocolJson.Default.RenderUploadRequest)) { await started.ExpectAsync(HttpStatusCode.Created); fromClient = Assert.NotNull((await started.ReadAsync(ProtocolJson.Default.StartUploadResponse)).UploadId); } using (var put = await Uploads.PutChunkAsync(editor, fromClient, 0, sent)) await put.ExpectAsync(HttpStatusCode.OK); var completions = new[] { $"/api/v1/nodes/{node.Id}/jobs/{job.Id}/result/complete", $"/api/v1/sequences/{frame.SequenceId}/renders/{fromClient}/complete" }; var paths = new ArchivePaths(server.Options.ArchivePath); async Task RefusedAsync(string code) { foreach (var complete in completions) { using var refused = await editor.PostAsync(complete, null); await refused.ExpectErrorAsync(HttpStatusCode.ServiceUnavailable, code); } // Nothing filed, nothing staged: both uploads receive again with their chunks, and the node keeps its job. foreach (var upload in new[] { fromNode, fromClient }) { Assert.Equal(Chronos.Data.Repositories.UploadState.Receiving, (await server.Database.Uploads.GetAsync(upload))!.State); Assert.True(server.Services.GetRequiredService().Exists(upload)); } Assert.False(Directory.Exists(server.Options.StagingPath) && Directory.EnumerateFiles(server.Options.StagingPath).Any()); Assert.Equal(0, (await server.Database.Sequences.GetAsync(frame.SequenceId))!.RenderedCount); var waiting = await JobApiTests.GetAsync(editor, job.Id); Assert.Equal(("running", node.Id.ToString()), (waiting.State, waiting.NodeId)); } // Another writer holds the sequence past the lease wait (a Reorganize step, a photo deletion). using (Assert.NotNull(LeaseFile.TryAcquire(paths.LocksDirectory, $"seq-{frame.SequenceId:N}", "tests"))) await RefusedAsync("sequence_busy"); // The archive drive is gone. File.Move(paths.ManifestPath, paths.ManifestPath + ".away"); try { await RefusedAsync("archive_offline"); } finally { File.Move(paths.ManifestPath + ".away", paths.ManifestPath); } // A desktop sharing the archive moved the sequence's folder: this server's index has it at the old place until its // next scan, and nothing is filed there meanwhile. var folder = (await server.Database.Sequences.GetAsync(frame.SequenceId))!.Folder; var left = paths.FromRelative(folder); Directory.Move(left, paths.FromRelative(folder + " moved")); await RefusedAsync("folder_moved"); Assert.False(Directory.Exists(left), "the folder it left is not created again"); // The next scan finds it where it is now (moved here as a scan moves it: this composition writes no sidecars), and the // renders are filed there. await using (var tx = await server.Database.BeginAsync(context.Cancellation)) { await tx.Sequences.RelocateAsync(frame.SequenceId, folder + " moved", null, context.Cancellation); await tx.CommitAsync(context.Cancellation); } foreach (var complete in completions) { using var filed = await editor.PostAsync(complete, null); await filed.ExpectAsync(HttpStatusCode.OK); } Assert.Equal("done", (await JobApiTests.GetAsync(editor, job.Id)).State); var sequence = (await server.Database.Sequences.GetAsync(frame.SequenceId))!; Assert.Equal(2, sequence.RenderedCount); await Http.BytesEqualAsync(output, File.ReadAllBytesAsync(Path.Combine(server.Options.ArchivePath, sequence.Folder, "exports", "Roof - 4K HEVC.mp4"))); await Http.BytesEqualAsync(sent, File.ReadAllBytesAsync(Path.Combine(server.Options.ArchivePath, sequence.Folder, "exports", "Roof.mp4"))); } [Test] public async Task NodesReportFailuresAndNeedTheRight() { await using var server = await TestServer.StartAsync(context); var (editor, _, _) = await server.UserAsync("alberto", "editor", renderNode: true); var (plain, _, _) = await server.UserAsync("giulia", "editor"); var sequence = await JobApiTests.CreateSequenceAsync(editor); var job = await JobApiTests.CreateAsync(editor, "render", sequence, HevcJob); var node = await RegisterAsync(editor, "studio-pc", "hevc", 8192); using (var claim = await editor.PostAsync($"/api/v1/nodes/{node.Id}/claim", null)) await claim.ExpectAsync(HttpStatusCode.OK); using (var failed = await editor.PostAsJsonAsync($"/api/v1/nodes/{node.Id}/jobs/{job.Id}/failed", new NodeJobFailure("NVENC session limit reached"), ProtocolJson.Default.NodeJobFailure)) await failed.ExpectAsync(HttpStatusCode.NoContent); var state = await JobApiTests.GetAsync(editor, job.Id); Assert.Equal(("failed", "NVENC session limit reached"), (state.State, state.Error)); using var refused = await plain.PostAsJsonAsync("/api/v1/nodes/register", new RegisterNodeRequest("giulia-pc", [new NodeEncoder("hevc", "QSV", true, false)], 0, 0), ProtocolJson.Default.RegisterNodeRequest); await refused.ExpectErrorAsync(HttpStatusCode.Forbidden, "forbidden"); using var foreign = await plain.PostAsync($"/api/v1/nodes/{node.Id}/heartbeat", null); await foreign.ExpectErrorAsync(HttpStatusCode.Forbidden, "forbidden"); } private static string H264Job(int width, int height) => JsonSerializer.Serialize( new RenderJobParameters("H.264", """{"preset":{"isAuto":false,"manual":"4k-h264"}}""", "h264", width, height, UseProxies: false, null), ProtocolJson.Default.RenderJobParameters); /// Render job parameters with embedded. private static string WithSettings(string parametersJson, string settingsJson) => JsonSerializer.Serialize( JsonSerializer.Deserialize(parametersJson, ProtocolJson.Default.RenderJobParameters)! with { SettingsJson = settingsJson }, ProtocolJson.Default.RenderJobParameters); internal static async Task RegisterAsync(HttpClient client, string name, string codec, int maxWidth) { using var response = await client.PostAsJsonAsync("/api/v1/nodes/register", new RegisterNodeRequest(name, [new NodeEncoder(codec, codec.ToUpperInvariant() + " encoder", true, false)], maxWidth, maxWidth), ProtocolJson.Default.RegisterNodeRequest); await response.ExpectAsync(HttpStatusCode.OK); return await response.ReadAsync(ProtocolJson.Default.RenderNodeDto); } }