The server publishes one account's card progress at most once a second (sooner reports are taken and dropped) and at most 120 card events of an account a minute (429 rate_limited beyond), so an upload-only account can no longer push job and sequence events out of every client's queue. On the client, the end of a card import waits at most two seconds for its reports to reach the server, then cancels whatever is still on its way, so a cancelled import or one that lost its server ends at once. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
65 lines
4.0 KiB
C#
65 lines
4.0 KiB
C#
using Titano.Core.Model;
|
|
using Titano.Protocol;
|
|
using Titano.Server.Security;
|
|
using Titano.Server.Storage;
|
|
|
|
namespace Titano.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;
|
|
|
|
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);
|
|
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()));
|
|
uploads.MapPost("/{id:guid}/complete", async (HttpContext context, Caller caller, Guid id, UploadService service) =>
|
|
(await service.CompleteAsync(caller, id)).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 are the only large request bodies; every other endpoint keeps Kestrel's small default limit. The service
|
|
/// raises it to the chunk size of this upload (fixed when it started) before it reads the body.
|
|
/// </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));
|
|
}
|
|
}
|