diff --git a/.gitea/workflows/ci.yml b/.gitea/workflows/ci.yml
index 5e424b3..1e7aa75 100644
--- a/.gitea/workflows/ci.yml
+++ b/.gitea/workflows/ci.yml
@@ -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
diff --git a/docker-compose.yml b/docker-compose.yml
index f78ab76..0f233c9 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -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
diff --git a/docs/adr/0015-postgresql-con-init-nei-container.md b/docs/adr/0015-postgresql-con-init-nei-container.md
new file mode 100644
index 0000000..90f6c89
--- /dev/null
+++ b/docs/adr/0015-postgresql-con-init-nei-container.md
@@ -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.
diff --git a/tools/Anubis.Tasks/Program.cs b/tools/Anubis.Tasks/Program.cs
index 25c9906..cc54098 100644
--- a/tools/Anubis.Tasks/Program.cs
+++ b/tools/Anubis.Tasks/Program.cs
@@ -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;
diff --git a/tools/Anubis.Tasks/ServiceLog.cs b/tools/Anubis.Tasks/ServiceLog.cs
new file mode 100644
index 0000000..bad0daf
--- /dev/null
+++ b/tools/Anubis.Tasks/ServiceLog.cs
@@ -0,0 +1,145 @@
+using System.Globalization;
+using System.Net.Http.Headers;
+using System.Net.Sockets;
+using System.Text;
+using System.Text.Json.Nodes;
+
+///
+/// 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).
+///
+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() ?? "";
+ if (!image.StartsWith(imagePrefix, StringComparison.Ordinal))
+ {
+ continue;
+ }
+
+ found++;
+ var id = container!["Id"]!.GetValue();
+ 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() ?? 0) / 1_000_000_000} s");
+
+ if (state?["Running"]?.GetValue() == 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() ?? "", 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() is not { } action
+ || !(action.StartsWith("exec_", StringComparison.Ordinal) || action == "health_status: healthy"))
+ .Select(e => $" {DateTimeOffset.FromUnixTimeSeconds(e?["time"]?.GetValue() ?? 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×tamps=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() ?? 0;
+ return value == 0 ? "nessuno" : (value / 1048576.0).ToString("0", CultureInfo.InvariantCulture) + " MiB";
+ }
+}