Sync: - A server frame that has not been hashed is known by content only once it is downloaded: one this PC deleted (or holds as its replacement) is now deleted from staging instead of filed again, which also dropped its tombstone. - An unhashed local original that turns out to be a photo the server deleted is not uploaded, and the archive verify then writes the hashes into the index, so the row settles instead of offering Upload for good. - A tombstone leaves a photo out of the comparison only when its side no longer holds that content, so a tombstone left beside a held copy does not keep the other side's copy missing forever. Uploads: - StartUploadRequest.Restore (optional, never sent by sync or older clients) lets an explicit user upload file a photo deleted from the sequence again, also after the trash was emptied; the completion repeats it with ?restore=true and the ingest drops the tombstone. - The completion checks the tombstone again: a photo deleted while its bytes were on the way is not filed (409 photo_removed, upload cancelled); the protocol client reports that as not sent. - A tombstone of content a frame of the target still holds refuses no repair. - Hidden dot names (AppleDouble "._" files) are refused, as the archive scanner leaves them out. Web upload dialog: - Upload again on rows marked Deleted before; the tooltip no longer promises a trash restore that may be impossible. - Sends a capture time: the Exif DateTimeOriginal of a JPEG or TIFF-based file (minimal in-house reader, capture-time.js), else the file's time, so photos without Exif keep their order. - Esc is stopped at keydown during a run (Chromium allows one prevented cancel per activation); hidden dot files are left out; a completion refused while another one files the upload waits for it; the same photo picked under two names waits for its first copy. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit d051bcfc351f5a08500ca864a6508576a95492a4)
82 lines
5.2 KiB
C#
82 lines
5.2 KiB
C#
using Microsoft.AspNetCore.Http.Metadata;
|
|
using Chronos.Core.Model;
|
|
using Chronos.Protocol;
|
|
using Chronos.Server.Security;
|
|
using Chronos.Server.Storage;
|
|
|
|
namespace Chronos.Server.Api;
|
|
|
|
/// <summary>
|
|
/// <c>/api/v1/uploads</c> (BRIEF §14.4). Chunk, state and cancel calls also serve render nodes uploading their output,
|
|
/// which start and complete through the node endpoints. <c>POST /uploads/cards</c> takes the reports of a card import a
|
|
/// client streams through these uploads and tells every connected client (BRIEF §14.3 <c>cardEvent</c>).
|
|
/// </summary>
|
|
public static class UploadEndpoints
|
|
{
|
|
private const int MaxCardName = 200;
|
|
|
|
/// <summary>The largest chunk size a server can be set to (<see cref="Configuration.ServerOptions.ChunkSizeBytes"/>).</summary>
|
|
private const long MaxChunkBytes = 64L * 1024 * 1024;
|
|
|
|
public static void Map(RouteGroupBuilder api)
|
|
{
|
|
var uploads = api.MapGroup("/uploads").Requires(Permissions.Upload | Permissions.RenderNode);
|
|
uploads.MapPost("", StartAsync).Requires(Permissions.Upload);
|
|
uploads.MapPut("/{id:guid}/chunks/{index:int}", ChunkAsync).WithMetadata(new ChunkBodyLimit());
|
|
uploads.MapGet("/{id:guid}", async (HttpContext context, Caller caller, Guid id, UploadService service) =>
|
|
(await service.GetStateAsync(caller, id, context.RequestAborted)).ToResult(context, s => Results.Json(s, ProtocolJson.Default.UploadState)));
|
|
uploads.MapDelete("/{id:guid}", async (HttpContext context, Caller caller, Guid id, UploadService service) =>
|
|
(await service.CancelAsync(caller, id, context.RequestAborted)).ToResult(context, _ => Results.NoContent()));
|
|
// ?restore=true repeats the start's StartUploadRequest.Restore: a photo deleted from the sequence meanwhile is filed anyway.
|
|
uploads.MapPost("/{id:guid}/complete", async (HttpContext context, Caller caller, Guid id, bool? restore, UploadService service) =>
|
|
(await service.CompleteAsync(caller, id, restore == true)).ToResult(context, r => Results.Json(r, ProtocolJson.Default.CompleteUploadResponse)))
|
|
.Requires(Permissions.Upload);
|
|
uploads.MapPost("/cards", ReportCard).Requires(Permissions.Upload);
|
|
}
|
|
|
|
private static async Task<IResult> StartAsync(HttpContext context, Caller caller, StartUploadRequest request, UploadService service)
|
|
{
|
|
var outcome = await service.StartAsync(caller, request, context.RequestAborted);
|
|
return outcome.ToResult(context, r => Results.Json(r, ProtocolJson.Default.StartUploadResponse,
|
|
statusCode: r.AlreadyExists ? StatusCodes.Status200OK : StatusCodes.Status201Created));
|
|
}
|
|
|
|
/// <summary>
|
|
/// A card import's start, progress or end, published as a <see cref="CardEvent"/> naming who imports it; 204, also for
|
|
/// progress dropped because it came within a second of the last (<see cref="UploadService.PublishCard"/>).
|
|
/// </summary>
|
|
private static IResult ReportCard(HttpContext context, Caller caller, CardImportReport report, UploadService service)
|
|
{
|
|
if (report.ImportId == Guid.Empty) return ApiErrors.BadRequest(context, "bad_request", "importId");
|
|
var card = report.Card?.Trim();
|
|
if (string.IsNullOrEmpty(card) || card.Length > MaxCardName || card.Any(char.IsControl)) return ApiErrors.BadRequest(context, "bad_request", "card");
|
|
if (!CardImportStates.IsKnown(report.State)) return ApiErrors.BadRequest(context, "bad_request", "state");
|
|
if (report.Total < 0 || report.Done < 0 || report.Done > report.Total || report.Failed < 0 || report.Failed > report.Total)
|
|
return ApiErrors.BadRequest(context, "bad_request", "done");
|
|
return service.PublishCard(caller, new CardEvent(report.ImportId, card, report.State, report.Done, report.Total, report.Failed, caller.User.Username,
|
|
caller.ClientName)).ToResult(context, _ => Results.NoContent());
|
|
}
|
|
|
|
/// <summary>
|
|
/// Chunks and proxies (<see cref="FileEndpoints"/>) are the only large request bodies; every other endpoint keeps
|
|
/// Kestrel's small default limit. Routing raises it for this route (<see cref="ChunkBodyLimit"/>), and the service
|
|
/// keeps it at least at the chunk size of this upload (fixed when it started) and of this server, so a body left
|
|
/// unread by any answer can still be drained.
|
|
/// </summary>
|
|
private static async Task<IResult> ChunkAsync(HttpContext context, Caller caller, Guid id, int index, UploadService service)
|
|
{
|
|
var outcome = await service.ReceiveChunkAsync(caller, id, index, context.Request, context.RequestAborted);
|
|
return outcome.ToResult(context, r => Results.Json(r, ProtocolJson.Default.ChunkReceived));
|
|
}
|
|
|
|
/// <summary>
|
|
/// The chunk route's body limit, applied by routing as it selects the endpoint, before authentication can answer 401
|
|
/// or 403 with the chunk unread. Kestrel drains an unread body only within the limit; above it, it closes the connection
|
|
/// and the client sees a network error instead of the answer (an Uploader would retry rather than ask to sign in).
|
|
/// </summary>
|
|
private sealed class ChunkBodyLimit : IRequestSizeLimitMetadata
|
|
{
|
|
public long? MaxRequestBodySize => MaxChunkBytes;
|
|
}
|
|
}
|