Files
Anubis/src/Anubis.Server/Endpoints.cs
T
Alby96andClaude Opus 5.5 992467ff04
ci / test (postgres) (push) Successful in 2m23s
ci / test (sqlite) (push) Successful in 2m5s
ci / image (push) Successful in 30s
ci / test (postgres) (pull_request) Successful in 2m14s
ci / test (sqlite) (pull_request) Successful in 1m58s
ci / image (pull_request) Successful in 9s
Bundle the Instrument Sans typeface (refs #13)
The user allowed the download, so the interface now uses the typeface
of the mockups instead of the system one. The variable file (weights
400-700) and its SIL OFL licence are embedded and served by the app
itself, never fetched from the internet; source and SHA-256 are in
API-NOTES. The typeface is slightly wider, so top-bar labels and
buttons move to 13 px as in the mockup, keeping the date line whole at
1440 px.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-10 14:07:47 +01:00

327 lines
14 KiB
C#

using System.Net.WebSockets;
using System.Reflection;
using System.Security.Cryptography;
using System.Text;
using System.Text.Json;
using Anubis.Access;
using Anubis.Core;
using Anubis.Db;
using Anubis.Platform;
using Microsoft.AspNetCore.Antiforgery;
namespace Anubis.Server;
/// <summary>Answer of <c>GET /health</c>.</summary>
internal sealed record HealthResponse(string Status, string Name, string Version, string? Mode = null, IReadOnlyDictionary<string, string>? Checks = null);
internal sealed record SettingBody(string Value);
/// <summary>
/// The REST and WebSocket skeleton (issue #12) and the form actions of the service pages. The API answers JSON with
/// Italian messages, needs a session, and every request that changes something carries the CSRF token in a header.
/// </summary>
internal static partial class Endpoints
{
public const string CsrfHeader = "X-Anubis-Csrf";
private static readonly JsonSerializerOptions _json = new(JsonSerializerDefaults.Web);
public static void Map(WebApplication app)
{
app.MapGet("/health", HealthAsync).AllowAnonymous();
app.MapGet("/brand/{file}", Brand).AllowAnonymous();
app.MapGet("/assets/{file}", Asset).AllowAnonymous();
app.MapGet("/favicon.ico", () => Brand("anubis.ico")).AllowAnonymous();
MapApi(app);
app.Map("/ws", StatusSocketAsync).RequireAuthorization();
Forms.Map(app);
}
// Healthy only when the database answers and the scheduler loop is alive (SPEC 15.2); the body says why not.
private static async Task<IResult> HealthAsync(AnubisHost host, CancellationToken cancellationToken)
{
var status = host.Status;
var checks = new Dictionary<string, string>(StringComparer.Ordinal) { ["mode"] = status.Mode.ToString() };
var healthy = status.Mode == HostMode.Ready;
if (host.Services is { } services)
{
try
{
using var timeout = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
timeout.CancelAfter(TimeSpan.FromSeconds(5));
await services.Db.PingAsync(timeout.Token).ConfigureAwait(false);
checks["database"] = "ok";
}
catch (Exception ex) when (ex is not OperationCanceledException || !cancellationToken.IsCancellationRequested)
{
checks["database"] = "non risponde";
healthy = false;
}
checks["scheduler"] = host.SchedulerRunning ? "ok" : "fermo";
healthy &= host.SchedulerRunning;
}
var body = new HealthResponse(healthy ? "ok" : "unavailable", AnubisInfo.Name, AnubisInfo.Version, status.Mode.ToString(), checks);
return Results.Json(body, _json, statusCode: healthy ? StatusCodes.Status200OK : StatusCodes.Status503ServiceUnavailable);
}
// The logo comes only from docs/design/logo, embedded at build time (ADR 0005).
private static IResult Brand(string file) => Embedded("Anubis.Server.Brand." + file, file);
private static IResult Asset(string file) => Embedded("Anubis.Server.Assets." + file, file);
private static IResult Embedded(string resource, string file)
{
var stream = Assembly.GetExecutingAssembly().GetManifestResourceStream(resource);
if (stream is null)
{
return Results.NotFound();
}
var type = Path.GetExtension(file) switch
{
".svg" => "image/svg+xml",
".png" => "image/png",
".ico" => "image/x-icon",
".css" => "text/css; charset=utf-8",
".js" => "text/javascript; charset=utf-8",
".ttf" => "font/ttf",
".txt" => "text/plain; charset=utf-8",
_ => "application/octet-stream",
};
return Results.Stream(stream, type);
}
private static void MapApi(WebApplication app)
{
var api = app.MapGroup("/api").RequireAuthorization().AddEndpointFilter(CsrfFilterAsync);
api.MapGet("/antiforgery", (HttpContext context, IAntiforgery antiforgery) =>
{
var tokens = antiforgery.GetAndStoreTokens(context);
return Results.Json(new { header = CsrfHeader, token = tokens.RequestToken }, _json);
});
api.MapGet("/status", async (AnubisHost host, ShellData shell, CancellationToken ct) => Results.Json(await shell.SnapshotAsync(ct).ConfigureAwait(false), _json));
api.MapGet("/me", (HttpContext context) => Results.Json(new
{
username = context.User.Identity?.Name,
mustChangePassword = CurrentUser.MustChangePassword(context.User),
hasSecondFactor = CurrentUser.HasSecondFactor(context.User),
}, _json));
api.MapGet("/settings", async (AnubisHost host, CancellationToken ct) =>
{
var services = host.Services!;
var values = new List<SettingValue>();
foreach (var definition in SettingsStore.All)
{
values.Add(await services.Settings.GetAsync(definition.Key, ct).ConfigureAwait(false));
}
return Results.Json(values, _json);
});
api.MapPut("/settings/{key}", async (string key, SettingBody body, AnubisHost host, HttpContext context, CancellationToken ct) =>
{
if (key == SettingsStore.BotState.Key)
{
return Error(StatusCodes.Status400BadRequest, "usa_i_comandi", "Lo stato del bot si cambia con pausa, ripresa e Ferma tutto.");
}
return await SetSettingAsync(host, key, body.Value, context, ct).ConfigureAwait(false);
});
api.MapGet("/settings/history", async (AnubisHost host, CancellationToken ct) =>
Results.Json(await host.Services!.Settings.HistoryAsync(null, 100, ct).ConfigureAwait(false), _json));
// Only whether a secret is set and where it comes from: the value never leaves the server (SPEC 15.4).
api.MapGet("/secrets/{name}", async (string name, AnubisHost host, CancellationToken ct) =>
Results.Json(await host.Services!.Secrets.StatusAsync(name, ct).ConfigureAwait(false), _json));
api.MapPost("/bot/{command}", async (string command, AnubisHost host, HttpContext context, CancellationToken ct) =>
{
var (ok, message) = await BotCommandAsync(host, command, context, ct).ConfigureAwait(false);
return ok ? Results.Json(new { state = message }, _json) : Error(StatusCodes.Status409Conflict, "comando_non_ammesso", message);
});
api.MapGet("/jobs", async (AnubisHost host, CancellationToken ct) =>
{
var services = host.Services!;
var last = await services.Db.ReadAsync(s => s.QueryAsync(
"SELECT name, description, last_due_at, last_finished_at, last_outcome, last_error FROM jobs ORDER BY name",
r => new
{
name = r.Text("name"),
description = r.Text("description"),
lastDue = r.MomentOrNull("last_due_at"),
lastFinished = r.MomentOrNull("last_finished_at"),
outcome = r.TextOrNull("last_outcome"),
error = r.TextOrNull("last_error")
}), ct).ConfigureAwait(false);
return Results.Json(new { upcoming = services.Scheduler.Upcoming(20), last }, _json);
});
}
internal static IResult Error(int status, string code, string message) => Results.Json(new ApiError(code, message), _json, statusCode: status);
private static async ValueTask<object?> CsrfFilterAsync(EndpointFilterInvocationContext context, EndpointFilterDelegate next)
{
var http = context.HttpContext;
if (!HttpMethods.IsGet(http.Request.Method) && !HttpMethods.IsHead(http.Request.Method))
{
var antiforgery = http.RequestServices.GetRequiredService<IAntiforgery>();
if (!await antiforgery.IsRequestValidAsync(http).ConfigureAwait(false))
{
return Error(StatusCodes.Status400BadRequest, "csrf", "Richiesta senza il gettone di sicurezza: ricarica la pagina e riprova.");
}
}
return await next(context).ConfigureAwait(false);
}
internal static async Task<IResult> SetSettingAsync(AnubisHost host, string key, string value, HttpContext context, CancellationToken ct)
{
try
{
await host.Services!.Settings.SetAsync(key, value, context.User.Identity?.Name ?? "utente", ct).ConfigureAwait(false);
return Results.NoContent();
}
catch (ReadOnlySettingException ex)
{
return Error(StatusCodes.Status409Conflict, "sola_lettura", ex.Message);
}
catch (ArgumentException ex)
{
return Error(StatusCodes.Status400BadRequest, "valore_non_valido", ex.Message);
}
}
/// <summary>
/// Pause blocks new entries and keeps stops and exits; "Ferma tutto" is the switch of SPEC 9.3 (its full effect
/// arrives with the engine). Resume works only from a pause, never after "Ferma tutto" (SPEC 14).
/// </summary>
internal static async Task<(bool Ok, string Message)> BotCommandAsync(AnubisHost host, string command, HttpContext context, CancellationToken ct)
{
var settings = host.Services!.Settings;
var current = (await settings.GetAsync(SettingsStore.BotState.Key, ct).ConfigureAwait(false)).Value;
var target = command switch
{
"pause" or "pausa" when current == "active" => "paused",
"resume" or "riprendi" when current == "paused" => "active",
"stop" or "ferma" => "stopped",
"restart" or "riattiva" when current == "stopped" => "active",
_ => null,
};
if (target is null)
{
return (false, current == "stopped"
? "Dopo \"Ferma tutto\" il bot non riprende da solo: riattivalo dalla pagina Rischio."
: "Comando non ammesso nello stato attuale del bot.");
}
await settings.SetAsync(SettingsStore.BotState.Key, target, context.User.Identity?.Name ?? "utente", ct).ConfigureAwait(false);
return (true, target);
}
// Live status (SPEC 13.4): one message on connect, one at every change and a heartbeat every few seconds, so the
// page can tell how old its data are and warn when the link drops.
private static async Task StatusSocketAsync(HttpContext context, AnubisHost host, ShellData shell, EventBus bus)
{
if (!context.WebSockets.IsWebSocketRequest)
{
context.Response.StatusCode = StatusCodes.Status400BadRequest;
return;
}
// Cross-site WebSocket hijacking: the page must come from this same server.
var origin = context.Request.Headers.Origin.ToString();
if (origin.Length > 0 && (!Uri.TryCreate(origin, UriKind.Absolute, out var originUri) ||
!string.Equals(originUri.Authority, context.Request.Host.Value, StringComparison.OrdinalIgnoreCase)))
{
context.Response.StatusCode = StatusCodes.Status403Forbidden;
return;
}
using var socket = await context.WebSockets.AcceptWebSocketAsync().ConfigureAwait(false);
using var settings = bus.Subscribe<SettingChanged>(16);
using var modes = bus.Subscribe<HostChanged>(16);
var aborted = context.RequestAborted;
var receive = DrainAsync(socket, aborted);
try
{
while (socket.State == WebSocketState.Open && !aborted.IsCancellationRequested)
{
var snapshot = await shell.SnapshotAsync(aborted).ConfigureAwait(false);
var bytes = JsonSerializer.SerializeToUtf8Bytes(new { type = "status", status = snapshot }, _json);
await socket.SendAsync(bytes, WebSocketMessageType.Text, true, aborted).ConfigureAwait(false);
using var wait = CancellationTokenSource.CreateLinkedTokenSource(aborted);
wait.CancelAfter(TimeSpan.FromSeconds(5));
var changed = Task.WhenAny(Next(settings, wait.Token), Next(modes, wait.Token));
await Task.WhenAny(changed, receive, Task.Delay(Timeout.Infinite, wait.Token)).ConfigureAwait(false);
// Stop the reader that lost, or it would swallow the next event of its kind.
await wait.CancelAsync().ConfigureAwait(false);
if (receive.IsCompleted)
{
break;
}
}
}
catch (Exception ex) when (ex is OperationCanceledException or WebSocketException)
{
}
// Answer the client's close, or start ours. Output only: the drain loop may still be receiving.
if (socket.State is WebSocketState.Open or WebSocketState.CloseReceived)
{
try
{
using var closing = new CancellationTokenSource(TimeSpan.FromSeconds(2));
await socket.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, null, closing.Token).ConfigureAwait(false);
}
catch (Exception ex) when (ex is OperationCanceledException or WebSocketException)
{
}
}
await Task.WhenAny(receive, Task.Delay(TimeSpan.FromSeconds(2), CancellationToken.None)).ConfigureAwait(false);
}
private static async Task Next<T>(EventSubscription<T> subscription, CancellationToken cancellationToken)
{
await foreach (var _ in subscription.ReadAllAsync(cancellationToken).ConfigureAwait(false))
{
return;
}
}
private static async Task DrainAsync(WebSocket socket, CancellationToken cancellationToken)
{
var buffer = new byte[1024];
try
{
while (socket.State == WebSocketState.Open)
{
var result = await socket.ReceiveAsync(buffer, cancellationToken).ConfigureAwait(false);
if (result.MessageType == WebSocketMessageType.Close)
{
return;
}
}
}
catch (Exception ex) when (ex is OperationCanceledException or WebSocketException)
{
}
}
/// <summary>Compares two secrets in constant time.</summary>
internal static bool SameSecret(string? given, string? expected) =>
given is not null && expected is not null &&
CryptographicOperations.FixedTimeEquals(SHA256.HashData(Encoding.UTF8.GetBytes(given)), SHA256.HashData(Encoding.UTF8.GetBytes(expected)));
}