- Renders, analyses, the server's manifests and proxy downloads take a proxy only when its Exif capture time is the frame's (ArchiveImages.IsProxyOf); one left at the index by a frame renumbered since counts as missing and is asked for again (V-24). - A frame whose original the host reads through its proxy (HEIF on the server) is preview-only only while it has none: the light analysis and the proxy pass keep the flag, the preview-only count, the light finding and the advisor's output cap in step with the proxies, and an arriving proxy queues a light analysis on the server (V-1, V-25). - The deep checkpoint's content key includes whether each frame is read from its original or its proxy, and analysis.json lists the frames measured from proxies; an unreadable verdict on a frame now read from its proxy makes the report stale (V-26). - Thumbnails drawn from proxies are compared with the archive's thumbnail size instead of 320 px (V-27). - A resumed thumbnail or proxy pass sets ThumbsBuilt/ProxiesBuilt only when the frames an earlier run did still have theirs, and the proxy pass logs frames waiting for a client's proxy apart from unreadable ones (V-28). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
130 lines
7.2 KiB
C#
130 lines
7.2 KiB
C#
using System.Net;
|
||
using System.Net.Http.Headers;
|
||
using Titano.Core.Codecs.Jpeg;
|
||
using Titano.Core.Imaging;
|
||
using Titano.Core.Metadata;
|
||
using Titano.Protocol;
|
||
using Titano.Server.Storage;
|
||
using Titano.Testing;
|
||
|
||
namespace Titano.Server.Tests.Storage;
|
||
|
||
/// <summary>
|
||
/// Proxies of originals the server cannot decode (BRIEF §2.3: HEIF) arrive from clients and render nodes through
|
||
/// <c>PUT /api/v1/frames/{id}/proxy</c> and become the frame's proxy and thumbnail.
|
||
/// </summary>
|
||
[Category("server")]
|
||
public sealed class ProxyUploadTests(TestContext context)
|
||
{
|
||
[Test]
|
||
public async Task AProxySentForAFrameTheServerCannotDecodeIsCheckedKeptAndThumbnailed()
|
||
{
|
||
await using var server = await TestServer.StartAsync(context, services: ArchiveModule.Register);
|
||
var (editor, _, _) = await server.UserAsync("alberto", "editor");
|
||
var (viewer, _, _) = await server.UserAsync("vera", "viewer");
|
||
var upload = await Uploads.UploadAsync(editor, Heif(1), "IMG_0001.HEIC", sessionKey: "roof");
|
||
var frame = Assert.NotNull(await server.Database.Frames.GetAsync(upload.FrameId));
|
||
Assert.Equal(ImageFileFormat.Heif, frame.Format);
|
||
|
||
var manifest = await ManifestAsync(editor, upload.SequenceId);
|
||
Assert.Equal((true, false), (manifest.Frames.Single().WantsProxy, manifest.Frames.Single().HasProxy));
|
||
Assert.Equal(new ProxySpec(1920, 92), manifest.Proxies);
|
||
|
||
using (var garbage = await PutAsync(editor, frame.Id, "not a photo"u8.ToArray()))
|
||
await garbage.ExpectErrorAsync(HttpStatusCode.UnprocessableEntity, "invalid_proxy");
|
||
using (var other = await PutAsync(editor, frame.Id, Proxy(frame.CapturedAt!.Value.AddSeconds(1))))
|
||
await other.ExpectErrorAsync(HttpStatusCode.UnprocessableEntity, "proxy_mismatch");
|
||
var proxy = Proxy(frame.CapturedAt!.Value);
|
||
using (var refused = await PutAsync(viewer, frame.Id, proxy))
|
||
await refused.ExpectErrorAsync(HttpStatusCode.Forbidden, "forbidden");
|
||
using (var missing = await PutAsync(editor, Guid.CreateVersion7(), proxy))
|
||
await missing.ExpectErrorAsync(HttpStatusCode.NotFound, "not_found");
|
||
using (var stored = await PutAsync(editor, frame.Id, proxy))
|
||
await stored.ExpectAsync(HttpStatusCode.NoContent);
|
||
|
||
await Http.BytesEqualAsync(proxy, editor.GetByteArrayAsync($"/api/v1/frames/{frame.Id}/proxy"));
|
||
var after = (await ManifestAsync(editor, upload.SequenceId)).Frames.Single();
|
||
Assert.Equal((false, true), (after.WantsProxy, after.HasProxy));
|
||
|
||
// The thumbnail job the proxy queued draws the frame from it.
|
||
var until = DateTime.UtcNow + TimeSpan.FromSeconds(30);
|
||
while (true)
|
||
{
|
||
using var thumb = await editor.GetAsync($"/api/v1/frames/{frame.Id}/thumb");
|
||
if (thumb.StatusCode == HttpStatusCode.OK)
|
||
{
|
||
var jpeg = await thumb.Content.ReadAsByteArrayAsync();
|
||
Assert.Equal((320, 240), (JpegDecoder.ReadInfo(jpeg).Width, JpegDecoder.ReadInfo(jpeg).Height));
|
||
break;
|
||
}
|
||
Assert.True(DateTime.UtcNow < until, $"thumbnail not built: {(int)thumb.StatusCode}");
|
||
await Task.Delay(100);
|
||
}
|
||
}
|
||
|
||
[Test]
|
||
public async Task AnotherPhotosProxyInTheFramesPlaceIsAskedForAgainAndNeverServed()
|
||
{
|
||
await using var server = await TestServer.StartAsync(context, services: ArchiveModule.Register);
|
||
var (editor, _, _) = await server.UserAsync("alberto", "editor");
|
||
var upload = await Uploads.UploadAsync(editor, Heif(1), "IMG_0001.HEIC", sessionKey: "roof");
|
||
var frame = Assert.NotNull(await server.Database.Frames.GetAsync(upload.FrameId));
|
||
var sequence = Assert.NotNull(await server.Database.Sequences.GetAsync(upload.SequenceId));
|
||
// Proxies are named by frame index: after a frame was inserted before this one, its place holds another photo's.
|
||
var path = new Core.Archiving.ArchivePaths(server.Options.ArchivePath).Sequence(sequence.Folder).Proxy(frame.Index);
|
||
Directory.CreateDirectory(Path.GetDirectoryName(path)!);
|
||
await File.WriteAllBytesAsync(path, Proxy(frame.CapturedAt!.Value.AddSeconds(-10)));
|
||
|
||
Assert.Equal((true, false), Wanted((await ManifestAsync(editor, upload.SequenceId)).Frames.Single()));
|
||
using (var served = await editor.GetAsync($"/api/v1/frames/{frame.Id}/proxy"))
|
||
Assert.Equal("asset_missing", (await served.ExpectErrorAsync(HttpStatusCode.NotFound, "not_found")).Details);
|
||
|
||
// The frame's own proxy takes its place.
|
||
var proxy = Proxy(frame.CapturedAt!.Value);
|
||
using (var stored = await PutAsync(editor, frame.Id, proxy))
|
||
await stored.ExpectAsync(HttpStatusCode.NoContent);
|
||
Assert.Equal((false, true), Wanted((await ManifestAsync(editor, upload.SequenceId)).Frames.Single()));
|
||
await Http.BytesEqualAsync(proxy, editor.GetByteArrayAsync($"/api/v1/frames/{frame.Id}/proxy"));
|
||
}
|
||
|
||
[Test]
|
||
public async Task FramesTheServerDecodesAskForNoProxy()
|
||
{
|
||
await using var server = await TestServer.StartAsync(context, services: ArchiveModule.Register);
|
||
var (editor, _, _) = await server.UserAsync("alberto", "editor");
|
||
var upload = await Uploads.UploadAsync(editor, Proxy(new DateTime(2026, 9, 28, 18, 2, 11)), "IMG_0001.JPG", sessionKey: "roof");
|
||
|
||
Assert.False((await ManifestAsync(editor, upload.SequenceId)).Frames.Single().WantsProxy);
|
||
// Nor takes one: renders and remote views keep the proxy the server makes itself.
|
||
using var refused = await PutAsync(editor, upload.FrameId, Proxy(new DateTime(2026, 9, 28, 18, 2, 11)));
|
||
await refused.ExpectErrorAsync(HttpStatusCode.UnprocessableEntity, "proxy_not_wanted");
|
||
}
|
||
|
||
/// <summary>A HEIF file as far as signature sniffing goes (an <c>ftyp</c> box naming heic), with no pixels the server can read.</summary>
|
||
private static byte[] Heif(int seed) => [0, 0, 0, 24, .. "ftypheic"u8, 0, 0, 0, 0, .. "mif1heic"u8, .. Uploads.Photo(2000, seed)];
|
||
|
||
/// <summary>A 320 × 240 JPEG with <paramref name="captured"/> in its Exif, as a client makes a proxy.</summary>
|
||
private static byte[] Proxy(DateTime captured)
|
||
{
|
||
using var image = new ImageBuffer(320, 240);
|
||
for (var c = 0; c < 3; c++) image.Plane(c).Fill(0.3f + c * 0.1f);
|
||
var exif = ExifWriter.BuildJpegApp1(new FrameMetadata { CapturedAt = captured, Software = "Titano" });
|
||
return JpegEncoder.Encode(image, new JpegEncodeOptions { Quality = 85, App1Segments = [exif[4..]] });
|
||
}
|
||
|
||
private static (bool WantsProxy, bool HasProxy) Wanted(ManifestFrame frame) => (frame.WantsProxy, frame.HasProxy);
|
||
|
||
private static Task<HttpResponseMessage> PutAsync(HttpClient client, Guid frameId, byte[] body)
|
||
{
|
||
var content = new ByteArrayContent(body);
|
||
content.Headers.ContentType = new MediaTypeHeaderValue("image/jpeg");
|
||
return client.PutAsync($"/api/v1/frames/{frameId}/proxy", content);
|
||
}
|
||
|
||
private static async Task<SequenceManifest> ManifestAsync(HttpClient client, Guid sequenceId)
|
||
{
|
||
using var response = await client.GetAsync($"/api/v1/sequences/{sequenceId}/manifest");
|
||
return await response.ReadAsync(ProtocolJson.Default.SequenceManifest);
|
||
}
|
||
}
|