Files
Chronos/tests/Titano.Server.Tests/Storage/ProxyUploadTests.cs
T
Claude 93054ba5de fix(server): proxy uploads carry their body limit before any early answer
PUT /api/v1/frames/{id}/proxy raised Kestrel's 1 MiB limit only inside the
handler, after its 404 and 422 answers and after authentication's 401 and
403. A proxy above 1 MiB left unread then closed the connection, and the
client retried a network error instead of reading the answer. The route now
carries IRequestSizeLimitMetadata (ArchiveImages.MaxProxyBytes) like the
chunk route, so routing applies it before anything answers.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
2026-10-12 19:00:39 +00:00

224 lines
13 KiB
C#
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
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");
}
[Test]
public async Task AnswersThatLeaveALargeProxyUnreadReachTheClient()
{
// A full-size proxy is far above the 1 MiB other requests may send: more than the connection buffers while the
// server reads nothing.
await using var server = await TestServer.StartAsync(context, services: ArchiveModule.Register);
var (editor, _, _) = await server.UserAsync("alberto", "editor");
var heif = await Uploads.UploadAsync(editor, Heif(1), "IMG_0001.HEIC", sessionKey: "roof");
var jpeg = await Uploads.UploadAsync(editor, Proxy(new DateTime(2026, 9, 28, 18, 2, 12)), "IMG_0002.JPG", sessionKey: "roof");
var large = Uploads.Photo(24 * 1024 * 1024, 7);
// The handler answers before reading the body: a frame deleted since the manifest, and one the server decodes itself.
using (var missing = await PutAsync(editor, Guid.CreateVersion7(), large))
Assert.Equal("frame", (await missing.ExpectErrorAsync(HttpStatusCode.NotFound, "not_found")).Details);
using (var unwanted = await PutAsync(editor, jpeg.FrameId, large))
await unwanted.ExpectErrorAsync(HttpStatusCode.UnprocessableEntity, "proxy_not_wanted");
// A body that may be the proxy is read whole, past the 1 MiB, before it is judged.
using (var invalid = await PutAsync(editor, heif.FrameId, large))
await invalid.ExpectErrorAsync(HttpStatusCode.UnprocessableEntity, "invalid_proxy");
// Authentication answers before the endpoint runs: an account that lost the Edit role, and a session signed out meanwhile.
var (viewer, _, _) = await server.UserAsync("vera", "viewer");
using (var forbidden = await PutAsync(viewer, heif.FrameId, large))
await forbidden.ExpectErrorAsync(HttpStatusCode.Forbidden, "forbidden");
using (var logout = await editor.PostAsync("/api/v1/auth/logout", null))
await logout.ExpectAsync(HttpStatusCode.NoContent);
using var revoked = await PutAsync(editor, heif.FrameId, large);
await revoked.ExpectErrorAsync(HttpStatusCode.Unauthorized, "unauthorized");
}
/// <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);
}
}