Files
Chronos/tests/Titano.Server.Tests/Api/AdminTests.cs
T
Alby96andClaude Opus 5.5 43b6871cdc feat: jobs run one at a time, parallelism per photo and a priority queue
Owner review 1, phase 2 (docs/requests/2026-10-15-owner-review-1.md, R2).

Jobs now run one at a time on the desktop and on the server. Parallelism
(Settings > Rendering, TITANO_PARALLELISM) is how many photos the running
job processes at once: thumbnail and proxy passes draw that many photos
together and still write the pack and checkpoints in frame order, decode
tiers are probed that many at a time, the deep analysis measures that many
frames and a render decodes that many ahead. Wherever originals are
developed whole (TIFF, PNG, RAW without a usable preview), fewer run at
once within the memory budget, which the running job now has whole; the
server's frame window is sized to the host instead of 1 GiB.

A new job waits its turn and pausing the running job starts the next one.
An optional priority queue gives each job kind a level (renders, imports
and downloads high, verifies and proxies low by default): a queued job of
a higher level pauses the running one without asking, and that job goes
back to the queue with its checkpoint and resumes by itself afterwards.
Jobs of the same level, and a job's own follow-ups, never interrupt it.
The Jobs screen and the admin panel show the parallelism and the queue;
Settings > Rendering and the admin panel's Settings set them, at once.

TITANO_WORKERS and the Workers key of server.json still set the
parallelism (1 to 64, with a warning at start for the variable).
Titano.Tools gains i18n prune, which removed the renamed keys from the 36
machine-translated languages; the new strings are translated in all 38.

Found while testing: uploads and imports failed when a pass read the
sidecar while they wrote it (atomic writes now retry the rename while a
reader holds the file, and never for a read-only one), and taking a lease
just released while another process read it failed on Windows (the create
now waits for the reader). Five adversarial review rounds checked the
phase before this commit.

Also updates BRIEF (12.8, 14.6, 14.8, 14.9, 24), DECISIONS, CHANGELOG,
ARCHITECTURE, STATUS, the request file and the compose/Unraid templates.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 14:56:24 +02:00

254 lines
15 KiB
C#

using System.Net;
using System.Net.Http.Json;
using System.Text.Json.Nodes;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using Titano.Core.Model;
using Titano.Data.Jobs;
using Titano.Protocol;
using Titano.Server.Configuration;
using Titano.Server.Hosting;
using Titano.Testing;
namespace Titano.Server.Tests.Api;
[Category("server")]
public sealed class AdminTests(TestContext context)
{
[Test]
public async Task TheDashboardSummarisesTheServer()
{
await using var server = await TestServer.StartAsync(context, o => o.ServerName = "Studio NAS");
var (editor, _, _) = await server.UserAsync("alberto", "editor");
await Uploads.UploadAsync(editor, Uploads.Photo(4000, 61));
var admin = await server.AdminAsync();
using var response = await admin.GetAsync("/api/v1/server/dashboard");
await response.ExpectAsync(HttpStatusCode.OK);
var dashboard = await response.ReadAsync(ProtocolJson.Default.DashboardDto);
Assert.Equal(("Studio NAS", 2, 1L, 1L), (dashboard.ServerName, dashboard.Users, dashboard.Archive.Sequences, dashboard.Archive.Photos));
Assert.True(dashboard.Database.StartsWith("SQLite ", StringComparison.Ordinal), dashboard.Database);
Assert.Equal(1L, dashboard.Uploads.Single().Frames);
Assert.Contains(dashboard.Activity, a => a.Action == "user_created");
Assert.True(dashboard.Archive.CapacityBytes > 0);
}
[Test]
public async Task SettingsAreSavedAndRestartOnlyValuesFlagged()
{
await using var server = await TestServer.StartAsync(context);
var admin = await server.AdminAsync();
using var read = await admin.GetAsync("/api/v1/server/settings");
var settings = await read.ReadAsync(ProtocolJson.Default.ServerSettingsDto);
Assert.False(settings.RestartRequired);
var edited = settings with { ServerName = "Rooftop", Discovery = true, HttpPort = 18080, HttpsPort = 18443 };
using (var saved = await admin.PutAsJsonAsync("/api/v1/server/settings", edited, ProtocolJson.Default.ServerSettingsDto))
Assert.True((await saved.ReadAsync(ProtocolJson.Default.ServerSettingsDto)).RestartRequired);
// Name and discovery apply at once; ports wait for the restart.
Assert.Equal(("Rooftop", true, 0), (server.Options.ServerName, server.Options.Discovery, server.Options.HttpPort));
using (var again = await admin.GetAsync("/api/v1/server/settings"))
Assert.Equal(18080, (await again.ReadAsync(ProtocolJson.Default.ServerSettingsDto)).HttpPort);
var file = JsonNode.Parse(await File.ReadAllTextAsync(server.Options.SettingsFile))!.AsObject();
Assert.Equal(("Rooftop", 18080), (file["ServerName"]!.GetValue<string>(), file["HttpPort"]!.GetValue<int>()));
Assert.False(file.ContainsKey("AdminPassword"));
using var invalid = await admin.PutAsJsonAsync("/api/v1/server/settings", edited with { Language = "tlh" }, ProtocolJson.Default.ServerSettingsDto);
Assert.Equal("Language", (await invalid.ExpectErrorAsync(HttpStatusCode.BadRequest, "invalid_setting")).Details);
}
[Test]
public async Task TheParallelismAndThePriorityQueueApplyAtOnce()
{
// Owner review 1 (R2): jobs run one at a time; the parallelism (photos at once) and the priority queue need no restart.
await using var server = await TestServer.StartAsync(context);
var admin = await server.AdminAsync();
using var read = await admin.GetAsync("/api/v1/server/settings");
var settings = await read.ReadAsync(ProtocolJson.Default.ServerSettingsDto);
Assert.Equal((2, false), (settings.Parallelism, settings.PriorityQueue));
Assert.Equal(ServerSettingsStore.Kinds.Count, settings.JobPriorities.Count);
Assert.Equal(("render", "high"), (settings.JobPriorities[0].Kind, settings.JobPriorities[0].Level));
Assert.Equal("low", settings.JobPriorities.Single(p => p.Kind == "verify").Level);
Assert.DoesNotContain("download", settings.JobPriorities.Select(p => p.Kind));
// The test server listens on ports the system chose (0), which no request may set.
var edited = settings with
{
HttpPort = 18080,
HttpsPort = 18443,
Parallelism = 3,
PriorityQueue = true,
JobPriorities = [.. settings.JobPriorities.Select(p => p.Kind == "scan" ? p with { Level = "high" } : p)],
};
using (var saved = await admin.PutAsJsonAsync("/api/v1/server/settings", edited, ProtocolJson.Default.ServerSettingsDto))
await saved.ExpectAsync(HttpStatusCode.OK);
// Applied at once, while the ports wait for the restart.
Assert.Equal((3, true, 0), (server.Options.Parallelism, server.Options.PriorityQueue, server.Options.HttpPort));
var queue = ServerSettingsStore.PriorityQueue(server.Options);
Assert.True(queue.Enabled);
Assert.Equal((JobKindPriority.High, JobKindPriority.High), (queue.LevelOf(JobKind.Scan), queue.LevelOf(JobKind.Render)));
// Only the level that differs from the defaults is stored.
var file = JsonNode.Parse(await File.ReadAllTextAsync(server.Options.SettingsFile))!.AsObject();
Assert.Equal((3, true), (file["Parallelism"]!.GetValue<int>(), file["PriorityQueue"]!.GetValue<bool>()));
Assert.Equal("""{"scan":"high"}""", file["JobPriorities"]!.ToJsonString());
Assert.False(file.ContainsKey("Workers"));
using (var dashboard = await admin.GetAsync("/api/v1/server/dashboard"))
{
var d = await dashboard.ReadAsync(ProtocolJson.Default.DashboardDto);
Assert.Equal((3, true), (d.Parallelism, d.PriorityQueue));
}
foreach (var (invalid, setting) in new (ServerSettingsDto, string)[]
{
(edited with { Parallelism = 0 }, "Parallelism"),
(edited with { JobPriorities = [new JobPriorityDto("download", "high")] }, "JobPriorities"),
(edited with { JobPriorities = [new JobPriorityDto("scan", "urgent")] }, "JobPriorities"),
})
{
using var refused = await admin.PutAsJsonAsync("/api/v1/server/settings", invalid, ProtocolJson.Default.ServerSettingsDto);
Assert.Equal(setting, (await refused.ExpectErrorAsync(HttpStatusCode.BadRequest, "invalid_setting")).Details);
}
}
[Test]
public async Task LogsAreReadableButOnlyByName()
{
await using var server = await TestServer.StartAsync(context, o => o.LogLevel = Microsoft.Extensions.Logging.LogLevel.Information);
var admin = await server.AdminAsync();
using var tail = await admin.GetAsync("/api/v1/logs?lines=20");
var lines = await tail.ReadAsync(ProtocolJson.Default.LogTailDto);
Assert.NotEmpty(lines.Lines);
Assert.True(lines.Lines.Count <= 20);
using var files = await admin.GetAsync("/api/v1/logs/files");
var name = (await files.ReadAsync(ProtocolJson.Default.ListLogFileDto)).First().Name;
using (var download = await admin.GetAsync($"/api/v1/logs/files/{name}")) await download.ExpectAsync(HttpStatusCode.OK);
using var traversal = await admin.GetAsync("/api/v1/logs/files/..%2Fserver.json");
await traversal.ExpectErrorAsync(HttpStatusCode.NotFound, "not_found");
}
[Test]
public async Task TheCurrentLogDownloadsWhileTheServerKeepsLogging()
{
await using var server = await TestServer.StartAsync(context, o => o.LogLevel = Microsoft.Extensions.Logging.LogLevel.Information);
var admin = await server.AdminAsync();
using var files = await admin.GetAsync("/api/v1/logs/files");
var name = (await files.ReadAsync(ProtocolJson.Default.ListLogFileDto)).First().Name;
// Jobs, uploads and sign-ins keep writing to the file an administrator downloads: a log of a few megabytes takes
// a while to send, and a line lands about every millisecond meanwhile. Only to the file and never in a tight loop:
// engine code of every test server in this process logs through the last one started, so this server's console
// and file lock are shared with the tests running alongside.
var logger = server.Services.GetServices<ILoggerProvider>().OfType<FileLoggerProvider>().Single().CreateLogger("Titano.Server.Tests");
var block = new string('x', 64 * 1024);
for (var i = 0; i < 32; i++) logger.LogInformation("{Block}", block);
using var stop = new CancellationTokenSource();
var logging = Task.Factory.StartNew(() =>
{
while (!stop.IsCancellationRequested)
{
logger.LogInformation("Busy");
Thread.Sleep(1);
}
}, TaskCreationOptions.LongRunning);
try
{
for (var i = 0; i < 5; i++)
{
using var download = await admin.GetAsync($"/api/v1/logs/files/{name}");
await download.ExpectAsync(HttpStatusCode.OK);
Assert.Equal(download.Content.Headers.ContentLength, (await download.Content.ReadAsByteArrayAsync()).LongLength);
}
}
finally
{
await stop.CancelAsync();
await logging;
}
}
[Test]
public async Task ArchiveSettingsValidateTemplatesAndJobsNeedHandlers()
{
await using var server = await TestServer.StartAsync(context);
var admin = await server.AdminAsync();
using var read = await admin.GetAsync("/api/v1/archive/settings");
var archive = await read.ReadAsync(ProtocolJson.Default.ArchiveSettingsDto);
Assert.Equal(Path.GetFullPath(server.Options.ArchivePath), archive.RootPath);
using (var bad = await admin.PutAsJsonAsync("/api/v1/archive/settings", archive with { FolderTemplate = "{year/{date" }, ProtocolJson.Default.ArchiveSettingsDto))
Assert.Equal("folderTemplate", (await bad.ExpectErrorAsync(HttpStatusCode.BadRequest, "invalid_template")).Details);
using (var good = await admin.PutAsJsonAsync("/api/v1/archive/settings", archive with { Name = "Studio", ProxyLongEdge = 2560 }, ProtocolJson.Default.ArchiveSettingsDto))
{
var saved = await good.ReadAsync(ProtocolJson.Default.ArchiveSettingsDto);
Assert.Equal(("Studio", 2560), (saved.Name, saved.ProxyLongEdge));
}
using var scan = await admin.PostAsync("/api/v1/archive/scan", null);
await scan.ExpectErrorAsync(HttpStatusCode.Conflict, "job_unavailable");
using var stats = await admin.GetAsync("/api/v1/archive/stats");
await stats.ExpectAsync(HttpStatusCode.OK);
}
[Test]
public async Task ArchiveSettingsAreWrittenToArchiveJsonAndSurviveARestart()
{
await using var server = await TestServer.StartAsync(context);
var admin = await server.AdminAsync();
using var read = await admin.GetAsync("/api/v1/archive/settings");
var archive = await read.ReadAsync(ProtocolJson.Default.ArchiveSettingsDto);
var changed = archive with { Name = "Studio", FolderTemplate = "{year}/{camera}", FileTemplate = "{name}", ProxyLongEdge = -1 };
using (var put = await admin.PutAsJsonAsync("/api/v1/archive/settings", changed, ProtocolJson.Default.ArchiveSettingsDto))
await put.ExpectAsync(HttpStatusCode.OK);
// archive.json is the truth (BRIEF §7): the proxy jobs read it, and the next start registers the archive from it.
var manifest = Titano.Core.Archiving.ManifestStore.ReadArchive(new Titano.Core.Archiving.ArchivePaths(server.Options.ArchivePath).ManifestPath);
Assert.Equal(("Studio", "{year}/{camera}", "{name}", -1), (manifest.Name, manifest.LayoutTemplates.Folder, manifest.LayoutTemplates.File, manifest.ProxyPolicy.LongEdge));
var restarted = await Titano.Server.Storage.ServerArchive.OpenAsync(server.Database, server.Options, context.Cancellation);
Assert.Equal(("Studio", "{name}", -1), (restarted.Current.Name, restarted.Current.FileTemplate, restarted.Current.ProxyLongEdge));
using var again = await admin.GetAsync("/api/v1/archive/settings");
Assert.Equal(changed, await again.ReadAsync(ProtocolJson.Default.ArchiveSettingsDto));
// The archive drive is gone: nothing is written and the admin hears why.
var path = new Titano.Core.Archiving.ArchivePaths(server.Options.ArchivePath).ManifestPath;
File.Move(path, path + ".away");
try
{
using var offline = await admin.PutAsJsonAsync("/api/v1/archive/settings", changed with { ProxyLongEdge = 1280 }, ProtocolJson.Default.ArchiveSettingsDto);
await offline.ExpectErrorAsync(HttpStatusCode.ServiceUnavailable, "archive_offline");
}
finally
{
File.Move(path + ".away", path);
}
Assert.Equal(-1, Titano.Core.Archiving.ManifestStore.ReadArchive(path).ProxyPolicy.LongEdge);
// A damaged archive.json is reported as such (not as an internal error) and left as it is.
var saved = await File.ReadAllBytesAsync(path, context.Cancellation);
await File.WriteAllTextAsync(path, "{ not json", context.Cancellation);
try
{
using var damaged = await admin.PutAsJsonAsync("/api/v1/archive/settings", changed with { ProxyLongEdge = 1280 }, ProtocolJson.Default.ArchiveSettingsDto);
await damaged.ExpectErrorAsync(HttpStatusCode.Conflict, "archive_manifest");
Assert.Equal("{ not json", await File.ReadAllTextAsync(path, context.Cancellation));
}
finally
{
await File.WriteAllBytesAsync(path, saved, context.Cancellation);
}
// A policy this form cannot set, written out of range by another tool, is named so the admin can correct the file.
var current = Titano.Core.Archiving.ManifestStore.ReadArchive(path);
foreach (var (odd, property) in new[]
{
(current with { ThumbnailPolicy = new Titano.Core.Archiving.ThumbnailPolicy { LongEdge = 2048 } }, "thumbnailPolicy"),
(current with { ProxyPolicy = current.ProxyPolicy with { Quality = 0 } }, "proxyPolicy"),
})
{
Titano.Core.Archiving.ManifestStore.WriteArchive(path, odd);
var before = await File.ReadAllBytesAsync(path, context.Cancellation);
using var refused = await admin.PutAsJsonAsync("/api/v1/archive/settings", changed with { ProxyLongEdge = 1280 }, ProtocolJson.Default.ArchiveSettingsDto);
Assert.Equal(property, (await refused.ExpectErrorAsync(HttpStatusCode.Conflict, "archive_policy")).Details);
Assert.SequenceEqual(before, await File.ReadAllBytesAsync(path, context.Cancellation));
}
await File.WriteAllBytesAsync(path, saved, context.Cancellation);
}
}