- ArchiveImages.IsProxyOf compares capture times to the microsecond the index
keeps (sidecars and Exif keep 100 ns ticks), and for frames read through
proxies also applies the policy's size rule, so the proxy pass, uploads,
thumbnails, renders, analyses, tiers, manifests and downloads agree.
- Proxy headers are cached per file while length and write time are unchanged
(and the file has settled), so manifests cost a stat per proxy.
- FrameTiers.RecordAsync checks proxy presence when it writes the sidecar and
returns the sequence's frames as they are, so a deep analysis or render that
ran while proxies arrived no longer flags the frames preview-only again, and
the analysis advises from the current flags.
- Server manifests ignore ProxiesBuilt for frames the server cannot decode, so
frames added since the last proxy pass are asked for their proxies.
- GET /sequences/{id}/analysis/report answers 404 for a report that found
frames unreadable before their proxies arrived (DeepReports.ReadCurrentAsync).
- The deep checkpoint key marks only frames read from proxies, so checkpoints
written by earlier versions still resume.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
194 lines
11 KiB
C#
194 lines
11 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.Core.Model;
|
||
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 FramesAddedAfterEveryProxyArrivedAreAskedForTheirs()
|
||
{
|
||
await using var server = await TestServer.StartAsync(context, services: ArchiveModule.Register);
|
||
var (editor, _, _) = await server.UserAsync("alberto", "editor");
|
||
var first = await Uploads.UploadAsync(editor, Heif(1), "IMG_0001.HEIC", sessionKey: "roof");
|
||
var frame = Assert.NotNull(await server.Database.Frames.GetAsync(first.FrameId));
|
||
using (var stored = await PutAsync(editor, frame.Id, Proxy(frame.CapturedAt!.Value)))
|
||
await stored.ExpectAsync(HttpStatusCode.NoContent);
|
||
|
||
// A frame comes after the proxy pass found every proxy there: until the next pass the status still says so, yet
|
||
// the new frame is asked for its proxy and the first keeps its own.
|
||
var second = await Uploads.UploadAsync(editor, Heif(2), "IMG_0002.HEIC", sessionKey: "roof");
|
||
Assert.Equal(first.SequenceId, second.SequenceId);
|
||
await server.Database.Sequences.UpdateStatusAsync(first.SequenceId, SequenceStatus.ProxiesBuilt, SequenceStatus.None, context.Cancellation);
|
||
var frames = (await ManifestAsync(editor, first.SequenceId)).Frames;
|
||
Assert.Equal((false, true), Wanted(frames.Single(f => f.Id == first.FrameId)));
|
||
Assert.Equal((true, false), Wanted(frames.Single(f => f.Id == second.FrameId)));
|
||
}
|
||
|
||
[Test]
|
||
public async Task AProxyTheServerMadeIsServedForAFrameTimedToTheTick()
|
||
{
|
||
await using var server = await TestServer.StartAsync(context, services: ArchiveModule.Register);
|
||
var (editor, _, _) = await server.UserAsync("alberto", "editor");
|
||
// Seven sub-second digits: the sidecar, and the proxy made from it, keep them all; the index keeps six.
|
||
var upload = await Uploads.UploadAsync(editor, Proxy(new DateTime(2026, 9, 28, 18, 2, 11).AddTicks(1_234_567)), "IMG_0001.JPG", sessionKey: "roof");
|
||
|
||
// The proxy pass the upload queued makes the frame's proxy, and the server serves it.
|
||
var until = DateTime.UtcNow + TimeSpan.FromSeconds(30);
|
||
while (true)
|
||
{
|
||
using var proxy = await editor.GetAsync($"/api/v1/frames/{upload.FrameId}/proxy");
|
||
if (proxy.StatusCode == HttpStatusCode.OK) break;
|
||
Assert.True(DateTime.UtcNow < until, $"proxy not served: {(int)proxy.StatusCode}");
|
||
await Task.Delay(100);
|
||
}
|
||
}
|
||
|
||
[Test]
|
||
public async Task AReportThatFoundAFrameUnreadableBeforeItsProxyCameIsNotServed()
|
||
{
|
||
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));
|
||
// A deep analysis ran before the proxy came and found no pixels in the HEIF original.
|
||
var path = new Core.Archiving.ArchivePaths(server.Options.ArchivePath).Sequence(sequence.Folder).AnalysisPath;
|
||
Directory.CreateDirectory(Path.GetDirectoryName(path)!);
|
||
Reports.Minimal(1, undecodable: 0).Save(path);
|
||
var url = $"/api/v1/sequences/{sequence.Id}/analysis/report";
|
||
using (var before = await editor.GetAsync(url))
|
||
await before.ExpectAsync(HttpStatusCode.OK);
|
||
|
||
// Once the frame is read from its proxy, that verdict and its advice to exclude the frame no longer hold, even
|
||
// before a light analysis has dropped the deep status.
|
||
using (var stored = await PutAsync(editor, frame.Id, Proxy(frame.CapturedAt!.Value)))
|
||
await stored.ExpectAsync(HttpStatusCode.NoContent);
|
||
using var after = await editor.GetAsync(url);
|
||
Assert.Equal("analysis", (await after.ExpectErrorAsync(HttpStatusCode.NotFound, "not_found")).Details);
|
||
}
|
||
|
||
[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);
|
||
}
|
||
}
|