feat(server): route renders by settings format and adapted size; gate older servers
Owner review 1, phase 4 (P5). A render job now carries the output size its settings give (RenderSize, proportions win) and the settings format it needs, resolved on the server before the job is split, so only nodes that read that format and whose encoder takes the frame claim it, and a job no online node can read no longer waits for one. Nodes and the server announce the format they read; settings of a newer Chronos fail saying so. Encoder size limits are read as long edge x short edge: Media Foundation's software H.264 encoder, announced as 4096x2304, accepts portrait 2160x3840 (probed on this PC), so EncoderSelector and the provider take either orientation and cap a portrait frame against the turned limit. On the desktop, Sync and Send-and-render are disabled with the NeedsNewerServer tooltip while the server reads an older format than the working settings need. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
1 parent
e4364c4f25
commit
fca6c8dfea
27 files changed
+663
-47
No files matched your search
@@ -498,6 +498,42 @@ public sealed class ProjectTests(TestContext context)
|
||||
Assert.Contains(ServerCapabilities.Projects, (await client.GetInfoAsync(context.Cancellation)).Capabilities);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Owner review 1, phase 4: the server announces the settings format it reads, and takes the versions of the formats it
|
||||
/// reads (1, and 2 with a turn or a look), refusing a newer one with 422 <c>newer_format</c>, nothing stored.
|
||||
/// </summary>
|
||||
[Test]
|
||||
public async Task TheServerTakesTheSettingsFormatsItAnnounces()
|
||||
{
|
||||
await using var server = await TestServer.StartAsync(context, services: ArchiveModule.Register);
|
||||
using (var anonymous = new ChronosClient(server.HttpBase, new CertificatePinning([]), "tests"))
|
||||
Assert.Equal(ProjectSettings.CurrentVersion, (await anonymous.GetInfoAsync(context.Cancellation)).SettingsFormat);
|
||||
Assert.Equal(2, ProjectSettings.CurrentVersion);
|
||||
|
||||
var (http, _, token) = await server.UserAsync("alberto", "editor");
|
||||
using var alberto = Client(server, token);
|
||||
var sid = await SequenceAsync(server, token, 2);
|
||||
var main = (await alberto.ListProjectsAsync(sid)).Single(p => p.IsMain);
|
||||
var head = await alberto.GetProjectHeadAsync(sid, main.Id);
|
||||
var home = ProjectWire.ToHomeFrames(await alberto.GetProjectFramesAsync(sid));
|
||||
|
||||
var plain = Version(head, new ProjectSettings { Exposure = new ExposureSettings { ExposureOffsetEv = 0.3 } }, home);
|
||||
Assert.Equal(1, plain.SettingsFormat);
|
||||
var v2 = Assert.NotNull((await alberto.PushProjectVersionAsync(sid, main.Id, plain)).Version);
|
||||
var turned = Version(v2, new ProjectSettings { Camera = new CameraSettings { Rotate = 90, Mirror = true }, Look = new LookSettings { Filter = "sepia" } }, home);
|
||||
Assert.Equal(2, turned.SettingsFormat);
|
||||
var v3 = Assert.NotNull((await alberto.PushProjectVersionAsync(sid, main.Id, turned)).Version);
|
||||
Assert.Equal(2, ProjectContent.FormatOf(v3.SettingsJson));
|
||||
var mirrored = ProjectSettings.FromJson(Assert.NotNull((await server.Database.Sequences.GetAsync(sid))!.SettingsJson));
|
||||
Assert.Equal((90, true, "sepia"), (mirrored.Camera.Rotate, mirrored.Camera.Mirror, mirrored.Look?.Filter), "Main's head is the sequence's settings");
|
||||
|
||||
const string future = """{"version":3,"camera":{"rotate":90}}""";
|
||||
var newer = Version(v3, new ProjectSettings(), home) with { SettingsJson = future, ContentHash = ProjectContent.Hash(future), SettingsFormat = 3 };
|
||||
using (var raw = await http.PostAsJsonAsync($"/api/v1/sequences/{sid}/projects/{main.Id}/versions", newer, ProtocolJson.Default.ProjectVersionDto))
|
||||
await raw.ExpectErrorAsync(HttpStatusCode.UnprocessableEntity, ProjectErrors.NewerFormat);
|
||||
Assert.Equal(3, (await alberto.GetProjectAsync(sid, main.Id)).HeadNumber);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task TheFramesOfAHomeAreOfOneFramesVersionWithTheAliasesOfItsConversions()
|
||||
{
|
||||
|
||||
@@ -132,6 +132,9 @@ public sealed class RenderNodeClientTests(TestContext context)
|
||||
Assert.SequenceEqual(["apng", "gif", "mjpeg"], registered.Encoders.Select(e => e.Codec).Order(StringComparer.Ordinal));
|
||||
// Each encoder announces its own largest output, so the server matches job sizes per codec.
|
||||
Assert.True(registered.Encoders.All(e => (e.MaxWidth, e.MaxHeight) == (65535, 65535)), "per-encoder limits");
|
||||
// And the settings format it renders (owner review 1, phase 4), so the server gives it only jobs it renders as asked.
|
||||
var stored = Assert.NotNull(Chronos.Server.Api.Dto.Capabilities(Assert.NotNull(await server.Database.RenderNodes.GetAsync(id))));
|
||||
Assert.Equal(ProjectSettings.CurrentVersion, stored.SettingsFormat);
|
||||
}
|
||||
|
||||
[Test]
|
||||
|
||||
@@ -3,10 +3,14 @@ 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;
|
||||
@@ -94,6 +98,96 @@ public sealed class RenderNodeTests(TestContext context)
|
||||
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 }, 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()
|
||||
{
|
||||
@@ -244,6 +338,10 @@ public sealed class RenderNodeTests(TestContext context)
|
||||
new RenderJobParameters("H.264", """{"preset":{"isAuto":false,"manual":"4k-h264"}}""", "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",
|
||||
|
||||
Reference in new issue
Block a user