7 Commits
Author SHA1 Message Date
Alby96andClaude Opus 5.5 63ae9d580a Merge main into ci-postgres (refs #98)
ci / test (postgres) (push) Successful in 4m8s
ci / test (sqlite) (push) Successful in 5m16s
ci / test (postgres) (pull_request) Successful in 3m44s
ci / test (sqlite) (pull_request) Failing after 5m38s
ci / image (pull_request) Skipped
ci / image (push) Successful in 1m6s
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-15 15:59:26 +01:00
Alby96 a66e3439d8 Merge pull request 'Fase 7: raccolta, collegamento e primo giudizio delle notizie, con il classificatore ONNX' (#97) from fase-7 into main
ci / test (postgres) (push) Failing after 7m44s
ci / test (sqlite) (push) Successful in 5m36s
ci / image (push) Skipped
2026-11-15 15:34:38 +01:00
Alby96andClaude Opus 5.5 74809068af Turn off disk syncs on the CI test PostgreSQL (refs #98)
ci / test (postgres) (push) Successful in 3m13s
ci / test (sqlite) (push) Successful in 4m23s
ci / test (postgres) (pull_request) Successful in 3m41s
ci / test (sqlite) (pull_request) Successful in 4m28s
ci / image (push) Successful in 1m46s
ci / image (pull_request) Successful in 1m1s
With the restarts gone, a rerun still failed 7 tests on read timeouts. The
server log shows why: every DROP DATABASE of the tests forces an immediate
checkpoint, one at a time, and on the runner's disk the sync alone took up
to 37 seconds, so queued drops passed the client's 30-second timeout. The
service is a throwaway, so initdb now sets fsync, synchronous_commit and
full_page_writes off. docker-compose.yml and real databases keep them on.
ADR 0015 updated.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-15 15:27:48 +01:00
Alby96andClaude Opus 5.5 73f2345047 Back to the normal CI jobs after the stress run (refs #98)
ci / test (sqlite) (push) Successful in 4m34s
ci / test (sqlite) (pull_request) Successful in 4m56s
ci / test (postgres) (push) Failing after 9m37s
ci / image (push) Skipped
ci / test (postgres) (pull_request) Successful in 8m44s
ci / image (pull_request) Successful in 1m21s
Reverts the temporary three-round job. With --init and the shorter pg_isready,
three PostgreSQL suites on one server passed with no restart (run 321), where
the same run without them restarted the server four times (run 315). The
Docker events in the service log step stay.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-15 14:25:59 +01:00
Alby96andClaude Opus 5.5 6ea303e1dc Run the test PostgreSQL behind an init and let pg_isready give up before Docker (refs #98)
ci / test (postgres) (pull_request) Skipped
ci / image (pull_request) Waiting for needed jobs
ci / test (postgres) (push) Successful in 23m7s
ci / image (push) Skipped
The server log of a failing job shows every restart as 'untracked child
process exited with exit code 2'. A health check that outlives its 3-second
timeout leaves pg_isready to PostgreSQL, which is PID 1 in its container;
when pg_isready exits the postmaster takes it for a crashed backend and
restarts every connection. --init reaps such orphans, and pg_isready -t 5
under a 15-second timeout is never cut off. Same change in docker-compose.yml.
ADR 0015.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-15 13:03:44 +01:00
Alby96andClaude Opus 5.5 72f4cbe0a5 TEMPORARY: run the PostgreSQL suite three times on one server, push only (refs #98)
ci / test (postgres) (pull_request) Skipped
ci / image (pull_request) Waiting for needed jobs
ci / test (postgres) (push) Failing after 11m1s
ci / image (push) Skipped
Two clean runs did not show the restart. This collects the server log of a
failure sooner and lists Docker's events for the service container (oom, kill,
die). Reverted before the merge.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-15 12:13:47 +01:00
Alby96andClaude Opus 5.5 0a9a8a38ec Print the PostgreSQL service log at the end of the CI job (refs #98)
ci / test (postgres) (push) Successful in 8m16s
ci / test (sqlite) (push) Successful in 5m16s
ci / test (postgres) (pull_request) Successful in 11m38s
ci / test (sqlite) (pull_request) Successful in 4m58s
ci / image (push) Successful in 1m42s
ci / image (pull_request) Successful in 47s
The job log shows the tests losing every connection but not why the server
went into recovery. A new tasks command reads the service container's log,
state and memory through the Docker socket the runner mounts in the job.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-15 11:41:31 +01:00
5 changed files with 224 additions and 4 deletions

No files matched your search

+12 -2
View File
@@ -23,10 +23,16 @@ jobs:
POSTGRES_DB: anubis
POSTGRES_USER: anubis
POSTGRES_PASSWORD: anubis-ci
# A throwaway server on a slow disk: without syncs to disk, the checkpoint that every DROP DATABASE of the
# tests forces takes milliseconds instead of up to 37 seconds (ADR 0015). Never for a real database.
POSTGRES_INITDB_ARGS: "--no-sync -c fsync=off -c synchronous_commit=off -c full_page_writes=off"
# --init and a pg_isready that gives up before Docker does (ADR 0015, issue #98). Without them a health
# check that outlives its timeout leaves pg_isready to PostgreSQL as PID 1, and its exit restarts the server.
options: >-
--health-cmd "pg_isready -U anubis -d anubis"
--init
--health-cmd "pg_isready -U anubis -d anubis -t 5"
--health-interval 3s
--health-timeout 3s
--health-timeout 15s
--health-retries 20
env:
ANUBIS_TEST_DB: ${{ matrix.db }}
@@ -45,6 +51,10 @@ jobs:
git checkout -q FETCH_HEAD
- name: Check
run: sh ./tasks.sh check
# The log of the PostgreSQL service, read through the Docker socket the runner mounts in the job (issue #98).
- name: PostgreSQL log
if: always() && matrix.db == 'postgres'
run: sh ./tasks.sh ci-service-log postgres
image:
needs: test
+5 -2
View File
@@ -31,6 +31,9 @@ services:
postgres:
image: postgres:18
# An init as PID 1 and a pg_isready that gives up before Docker does (ADR 0015): otherwise a slow health check
# leaves pg_isready to PostgreSQL, and its exit makes the server restart every connection.
init: true
environment:
POSTGRES_DB: anubis
POSTGRES_USER: anubis
@@ -38,9 +41,9 @@ services:
ports:
- "127.0.0.1:55432:5432"
healthcheck:
test: ["CMD-SHELL", "pg_isready -U anubis -d anubis"]
test: ["CMD-SHELL", "pg_isready -U anubis -d anubis -t 5"]
interval: 3s
timeout: 3s
timeout: 15s
retries: 20
volumes:
- postgres-data:/var/lib/postgresql
@@ -0,0 +1,60 @@
# 0015 — PostgreSQL nei container con un processo init; nella CI, senza sincronizzazioni su disco
Data: 2026-11-15 · Stato: accettata · Precisa la CI (SPEC 15.5, ADR 0007) e il `docker-compose.yml` di sviluppo, issue #98, senza componenti esterni nuovi
## Contesto
Dal 14 novembre 2026 il lavoro `test (postgres)` della CI falliva spesso, ma non sempre. Dopo uno-cinque minuti di test, il PostgreSQL di servizio chiudeva tutte le connessioni. I test rimasti fallivano con `57P03: the database system is in recovery mode` o con `EndOfStreamException`. Rilanciando il lavoro passava. In locale la suite passava sempre.
Il registro del lavoro non mostrava quello del server. Per vederlo, la CI ora stampa a fine lavoro registro, stato e memoria del contenitore PostgreSQL (`tasks ci-service-log`). Li legge dal socket di Docker che l'esecutore monta nel lavoro, senza il client `docker` né altro da installare.
In una prova con la suite ripetuta tre volte sullo stesso server, il server si è riavviato quattro volte. Ogni volta il registro dice la stessa cosa:
```
LOG: untracked child process (PID 248) exited with exit code 2
LOG: terminating any other active server processes
LOG: all server processes terminated; reinitializing
```
Nessun processo ucciso per memoria (`OOMKilled false`, nessun evento `oom` di Docker) e nessun segnale. Il processo "sconosciuto" che esce con codice 2 è `pg_isready`. Il codice 2 vuol dire "il server non ha risposto".
Che cosa succede:
1. Docker esegue il controllo di salute dentro il contenitore come `/bin/sh -c "pg_isready …"`.
2. Sull'esecutore di Unraid il disco è lento. Ogni `DROP DATABASE` dei test forza un checkpoint immediato, con fino a 21 secondi di scrittura sul disco. In quei momenti il server può metterci più di 3 secondi a rispondere.
3. Passato il tempo massimo del controllo (`--health-timeout 3s`), Docker chiude la shell. `pg_isready` resta senza genitore e il sistema lo affida al processo 1 del contenitore. L'immagine `postgres` non ha un processo init, quindi il processo 1 è PostgreSQL stesso.
4. Quando `pg_isready` si arrende ed esce, PostgreSQL vede morire un figlio che non conosce. Per prudenza lo tratta come un suo processo andato in crash: chiude tutte le connessioni e rifà il recupero dal registro delle scritture.
Spiega anche gli altri indizi:
- capita solo a volte, perché serve un server lento proprio mentre scade il controllo;
- si vede da quando la suite è cresciuta con il commit della raccolta dei dati (issue #95), cioè più database creati e cancellati;
- in locale non capita, perché il disco è veloce.
Non c'entrano la memoria, `/dev/shm` (64 MiB, il server ne usa poco) e `pg_database_size` del campionatore. Il `CREATE`/`DROP DATABASE` dei test rende il server lento, ma da solo non lo fa ripartire.
**Seconda causa, vista dopo la prima correzione.** In un'esecuzione con la correzione il server non è più ripartito, ma 7 test sono falliti lo stesso:
- `Timeout during reading attempt` dopo circa 1 minuto e 18 secondi;
- `/primo-avvio?errore=database` nel test del primo avvio desktop, lo stesso errore visto il 14 novembre nell'esecuzione 304.
Il registro del server mostra il motivo:
- ogni `DROP DATABASE` forza un checkpoint immediato, e i checkpoint passano uno alla volta;
- sul disco dell'esecutore la sola sincronizzazione su disco ha richiesto fino a 37 secondi (`sync=36.849 s`);
- i `DROP DATABASE` in coda hanno superato i 30 secondi di attesa del client (`canceling statement due to user request`);
- il test desktop non ha avuto la connessione nei 5 secondi dell'applicazione.
Il server era vivo, ma fermo ad aspettare il disco.
## Decisione
1. **Un processo init davanti a PostgreSQL.** Il servizio `postgres` della CI parte con `--init`, e quello di `docker-compose.yml` con `init: true`. Il processo 1 diventa il piccolo init di Docker: raccoglie lui i processi rimasti senza genitore, e PostgreSQL non li vede più.
2. **`pg_isready` si arrende prima di Docker.** Il controllo è `pg_isready -U anubis -d anubis -t 5` con `--health-timeout 15s`. Così Docker non chiude mai la shell mentre `pg_isready` sta ancora aspettando. L'intervallo resta di 3 secondi, quindi l'avvio non rallenta.
3. **Nella CI il PostgreSQL dei test non sincronizza su disco.** Il servizio nasce con `POSTGRES_INITDB_ARGS: "--no-sync -c fsync=off -c synchronous_commit=off -c full_page_writes=off"` (l'opzione `-c` di `initdb` esiste da PostgreSQL 16). Così il checkpoint forzato da ogni `DROP DATABASE` scrive solo nella memoria del sistema e dura millisecondi. È ammesso solo perché quel server vive per un lavoro e poi si butta. Non vale per `docker-compose.yml` né per nessun database vero: lì un'interruzione di corrente senza `fsync` può rovinare i dati.
4. **Il registro del server resta nella CI.** Il passo `PostgreSQL log` gira sempre a fine lavoro `test (postgres)`. Mostra anche se l'init è attivo e com'è il controllo di salute. Il prossimo problema del server si legge lì, senza rilanciare alla cieca.
Le misure 1 e 2 si coprono a vicenda: ognuna da sola basta a togliere la prima causa. La 3 toglie la seconda, e rende anche più raro un controllo di salute lento.
## Conseguenze
- Il lavoro `test (postgres)` non perde più il server a metà. Rilanciarlo per farlo passare nascondeva la causa, e ora non serve più.
- Nessun test e nessuna parte di Anubis cambia: il difetto era nel modo in cui gira il contenitore, non nel bot.
- I test su PostgreSQL nella CI non provano la durata dei dati dopo un'interruzione. Non lo facevano neanche prima: quella è una proprietà di PostgreSQL, non di Anubis.
- **Per l'installazione su Unraid:** se il PostgreSQL che usa Anubis gira in un container con un controllo di salute basato su `pg_isready` e senza init, ha lo stesso rischio sotto carico. Il rimedio è lo stesso: l'opzione `--init` (in Unraid, "Extra Parameters") oppure un controllo con `-t` più breve del suo tempo massimo. Il template `deploy/unraid/anubis.xml` non installa PostgreSQL, quindi lì non cambia niente.
+2
View File
@@ -19,6 +19,7 @@ return command switch
"seed-demo" => Run("dotnet", ["run", "--project", "src/Anubis.Server", "-c", "Release", "--", "--demo", .. rest]),
"screenshots" => Screenshots(rest),
"release-win" => ReleaseWindows(),
"ci-service-log" => ServiceLog.Print(rest.Length > 0 ? rest[0] : "postgres"),
"desktop-win" => NotYet("desktop-win", 10),
_ => Help(),
};
@@ -237,6 +238,7 @@ int Help()
tasks seed-demo avvia la modalità dimostrativa (dati dell'appendice F, database a parte)
tasks screenshots fotografa le schermate dimostrative a 1440 e 390 pixel
tasks release-win zip di prova per Windows in artifacts/release (ADR 0013)
tasks ci-service-log nella CI: registro e memoria del PostgreSQL dei test
tasks desktop-win installatore Windows (Fase 10)
""");
return command == "help" ? 0 : 1;
+145
View File
@@ -0,0 +1,145 @@
using System.Globalization;
using System.Net.Http.Headers;
using System.Net.Sockets;
using System.Text;
using System.Text.Json.Nodes;
/// <summary>
/// Prints what the CI cannot see from inside the job: the log, state and memory of the service containers next to this
/// one (the PostgreSQL of the tests). It talks to the Docker Engine API through the socket the runner mounts in the job
/// container, so it needs neither the docker client nor anything else to install (ADR 0004).
/// </summary>
internal static class ServiceLog
{
private const string Socket = "/var/run/docker.sock";
public static int Print(string imagePrefix)
{
if (!File.Exists(Socket))
{
Console.WriteLine($"Nessun {Socket}: il registro dei servizi si legge solo nella CI.");
return 0;
}
using var http = new HttpClient(new SocketsHttpHandler
{
ConnectCallback = async (_, token) =>
{
var socket = new System.Net.Sockets.Socket(AddressFamily.Unix, SocketType.Stream, ProtocolType.Unspecified);
await socket.ConnectAsync(new UnixDomainSocketEndPoint(Socket), token).ConfigureAwait(false);
return new NetworkStream(socket, ownsSocket: true);
},
})
{
BaseAddress = new Uri("http://docker/"),
Timeout = TimeSpan.FromMinutes(2),
};
var info = Json(http, "info");
Console.WriteLine($"Host: {info["Name"]}, {info["NCPU"]} CPU, {Mib(info["MemTotal"])} di memoria, kernel {info["KernelVersion"]}");
var self = Json(http, $"containers/{Uri.EscapeDataString(Environment.MachineName)}/json");
var networks = self["NetworkSettings"]?["Networks"]?.AsObject().Select(pair => pair.Key).ToList() ?? [];
var found = 0;
foreach (var network in networks)
{
var filter = Uri.EscapeDataString($$"""{"network":["{{network}}"]}""");
foreach (var container in Json(http, $"containers/json?all=1&filters={filter}").AsArray())
{
var image = container?["Image"]?.GetValue<string>() ?? "";
if (!image.StartsWith(imagePrefix, StringComparison.Ordinal))
{
continue;
}
found++;
var id = container!["Id"]!.GetValue<string>();
Describe(http, id, image);
}
}
if (found == 0)
{
Console.WriteLine($"Nessun contenitore '{imagePrefix}*' sulle reti {string.Join(", ", networks)}.");
}
return 0;
}
private static void Describe(HttpClient http, string id, string image)
{
var inspect = Json(http, $"containers/{id}/json");
var state = inspect["State"];
var host = inspect["HostConfig"];
Console.WriteLine();
Console.WriteLine($"== {image} {id[..12]}");
Console.WriteLine($"Stato: {state?["Status"]}, avviato {state?["StartedAt"]}, riavvii {inspect["RestartCount"]}, OOMKilled {state?["OOMKilled"]}, uscita {state?["ExitCode"]}");
Console.WriteLine($"Limiti: memoria {Mib(host?["Memory"])}, /dev/shm {Mib(host?["ShmSize"])}, init {host?["Init"]?.ToString() ?? "no"}");
Console.WriteLine($"Controllo di salute: {inspect["Config"]?["Healthcheck"]?["Test"]?.ToJsonString()}, timeout {(inspect["Config"]?["Healthcheck"]?["Timeout"]?.GetValue<long>() ?? 0) / 1_000_000_000} s");
if (state?["Running"]?.GetValue<bool>() == true)
{
var stats = Json(http, $"containers/{id}/stats?stream=false");
var memory = stats["memory_stats"];
Console.WriteLine($"Memoria ora: {Mib(memory?["usage"])}, limite visto dal contenitore {Mib(memory?["limit"])}, massimo {Mib(memory?["max_usage"])}");
}
// Out-of-memory kills and signals as Docker saw them, from the container's start until now.
var since = DateTimeOffset.Parse(state?["StartedAt"]?.GetValue<string>() ?? "", CultureInfo.InvariantCulture).ToUnixTimeSeconds();
var until = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
var events = Uri.EscapeDataString($$"""{"container":["{{id}}"]}""");
using (var answer = http.GetAsync(new Uri($"events?since={since}&until={until}&filters={events}", UriKind.Relative)).GetAwaiter().GetResult())
{
answer.EnsureSuccessStatusCode();
var lines = answer.Content.ReadAsStringAsync().GetAwaiter().GetResult()
.Split('\n', StringSplitOptions.RemoveEmptyEntries)
.Select(line => JsonNode.Parse(line))
.Where(e => e?["Action"]?.GetValue<string>() is not { } action
|| !(action.StartsWith("exec_", StringComparison.Ordinal) || action == "health_status: healthy"))
.Select(e => $" {DateTimeOffset.FromUnixTimeSeconds(e?["time"]?.GetValue<long>() ?? 0):O} {e?["Action"]}")
.ToList();
Console.WriteLine($"Eventi di Docker: {(lines.Count == 0 ? "nessuno" : "")}");
lines.ForEach(Console.WriteLine);
}
Console.WriteLine("-- registro");
using var response = http.GetAsync(new Uri($"containers/{id}/logs?stdout=1&stderr=1&timestamps=1", UriKind.Relative)).GetAwaiter().GetResult();
response.EnsureSuccessStatusCode();
var bytes = response.Content.ReadAsByteArrayAsync().GetAwaiter().GetResult();
var raw = response.Content.Headers.ContentType?.MediaType == "application/vnd.docker.raw-stream";
Console.Write(raw ? Encoding.UTF8.GetString(bytes) : Demultiplex(bytes));
Console.WriteLine("-- fine del registro");
}
// Without a terminal the log arrives in frames: one byte for the stream, three zeros, four bytes of length.
private static string Demultiplex(byte[] bytes)
{
var text = new StringBuilder();
var at = 0;
while (at + 8 <= bytes.Length)
{
var length = (bytes[at + 4] << 24) | (bytes[at + 5] << 16) | (bytes[at + 6] << 8) | bytes[at + 7];
var size = Math.Min(length, bytes.Length - at - 8);
text.Append(Encoding.UTF8.GetString(bytes, at + 8, size));
at += 8 + length;
}
return text.ToString();
}
private static JsonNode Json(HttpClient http, string path)
{
using var request = new HttpRequestMessage(HttpMethod.Get, new Uri(path, UriKind.Relative));
request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
using var response = http.Send(request);
response.EnsureSuccessStatusCode();
using var stream = response.Content.ReadAsStream();
return JsonNode.Parse(stream) ?? new JsonObject();
}
private static string Mib(JsonNode? bytes)
{
var value = bytes?.GetValue<long>() ?? 0;
return value == 0 ? "nessuno" : (value / 1048576.0).ToString("0", CultureInfo.InvariantCulture) + " MiB";
}
}