CI / Build and test (push) Successful in 8m19s
CI / Windows tests and installer (push) Skipped
CI / YAML check (push) Successful in 7s
Release / Build, test and publish (push) Successful in 12m9s
CI / PostgreSQL 16 integration (push) Successful in 7m49s
CI / PostgreSQL 17 integration (push) Successful in 7m19s
CI / Docker image (push) Successful in 46s
Release / Server image (push) Successful in 1m14s
Owner review 1 R5 + R6. Camera rotation, mirror, flip, straighten and crop handles locked to the output; an Exposure Look group; Export output size ("proportions win"); settings format 2 with older-node gates. Also fixes project text and hashes differing between Windows and Linux.
Closes #19
Closes #20
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: Alberto Balbo <alberto.balbo.96@gmail.com>
368 lines
25 KiB
C#
368 lines
25 KiB
C#
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<TimeProvider>(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<RenderNodeMonitor>().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);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 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.
|
||
/// </summary>
|
||
[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<string>().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<Guid>();
|
||
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());
|
||
}
|
||
|
||
/// <summary>
|
||
/// 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.
|
||
/// </summary>
|
||
[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");
|
||
}
|
||
|
||
/// <summary>A job waits for a node only while one online could render it: one of an older settings format cannot.</summary>
|
||
[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, SettingsJson = null }, context.Cancellation),
|
||
"it renders a job of format 1");
|
||
Assert.False(await Availability().AwaitsNodeAsync(job, parameters with { RequiredSettingsFormat = 1 }, context.Cancellation),
|
||
"a job queued as format 1 whose settings route it to format 2 is never claimed by that node, so it does not wait for it");
|
||
|
||
// Queued as format 1 on the sequence's own settings, which then took a turn: the claim skips the older node, and so
|
||
// does the wait, so the server's own engine takes the job.
|
||
var plain = (await server.Database.Jobs.GetAsync((await JobApiTests.CreateAsync(editor, "render", sequence, H264Job(1920, 1080))).Id))!;
|
||
var plainParameters = ProcessingJobs.ReadRender(plain.ParametersJson).Parameters;
|
||
var waited = plain with { Created = DateTimeOffset.UtcNow - TimeSpan.FromSeconds(61) };
|
||
Assert.Equal(1, plainParameters.RequiredSettingsFormat);
|
||
Assert.True(await Availability().AwaitsNodeAsync(waited, plainParameters, context.Cancellation), "plain settings: the older node renders it");
|
||
var row = (await server.Database.Sequences.GetAsync(sequence))!;
|
||
await server.Database.Sequences.EditAsync(sequence, new SequenceEdit { SettingsJson = turned }, row.SettingsVersion);
|
||
Assert.False(await Availability().AwaitsNodeAsync(waited, plainParameters, context.Cancellation), "the turn needs a node of format 2");
|
||
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<ChronosDatabase>(), 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<UploadStore>().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"},"overrides":{"width":{{{width}}},"height":{{{height}}}}}""", "h264", width, height,
|
||
UseProxies: false, null),
|
||
ProtocolJson.Default.RenderJobParameters);
|
||
|
||
/// <summary>Render job parameters <paramref name="parametersJson"/> with <paramref name="settingsJson"/> embedded.</summary>
|
||
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<RenderNodeDto> 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);
|
||
}
|
||
}
|