using Microsoft.AspNetCore.Http.Metadata; using Chronos.Core.Model; using Chronos.Protocol; using Chronos.Server.Security; using Chronos.Server.Storage; namespace Chronos.Server.Api; /// /// /api/v1/uploads (BRIEF §14.4). Chunk, state and cancel calls also serve render nodes uploading their output, /// which start and complete through the node endpoints. POST /uploads/cards takes the reports of a card import a /// client streams through these uploads and tells every connected client (BRIEF §14.3 cardEvent). /// public static class UploadEndpoints { private const int MaxCardName = 200; /// The largest chunk size a server can be set to (). 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 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)); } /// /// A card import's start, progress or end, published as a naming who imports it; 204, also for /// progress dropped because it came within a second of the last (). /// 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()); } /// /// Chunks and proxies () are the only large request bodies; every other endpoint keeps /// Kestrel's small default limit. Routing raises it for this route (), 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. /// private static async Task 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)); } /// /// 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). /// private sealed class ChunkBodyLimit : IRequestSizeLimitMetadata { public long? MaxRequestBodySize => MaxChunkBytes; } }