From 0a9a8a38ecd5469f8cd347265ea7e82a05d2c705 Mon Sep 17 00:00:00 2001 From: Alberto Balbo Date: Sun, 15 Nov 2026 11:41:31 +0100 Subject: [PATCH 1/5] Print the PostgreSQL service log at the end of the CI job (refs #98) 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 --- .gitea/workflows/ci.yml | 4 + tools/Anubis.Tasks/Program.cs | 2 + tools/Anubis.Tasks/ServiceLog.cs | 126 +++++++++++++++++++++++++++++++ 3 files changed, 132 insertions(+) create mode 100644 tools/Anubis.Tasks/ServiceLog.cs diff --git a/.gitea/workflows/ci.yml b/.gitea/workflows/ci.yml index 5e424b3..42c74c1 100644 --- a/.gitea/workflows/ci.yml +++ b/.gitea/workflows/ci.yml @@ -45,6 +45,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/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..e672490 --- /dev/null +++ b/tools/Anubis.Tasks/ServiceLog.cs @@ -0,0 +1,126 @@ +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"])}"); + + 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"])}"); + } + + 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"; + } +} -- 2.54.1 From 72f4cbe0a5fe9311e22b57027a1b26e02f3befca Mon Sep 17 00:00:00 2001 From: Alberto Balbo Date: Sun, 15 Nov 2026 12:13:47 +0100 Subject: [PATCH 2/5] TEMPORARY: run the PostgreSQL suite three times on one server, push only (refs #98) 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 --- .gitea/workflows/ci.yml | 10 ++++++++-- tools/Anubis.Tasks/ServiceLog.cs | 18 ++++++++++++++++++ 2 files changed, 26 insertions(+), 2 deletions(-) diff --git a/.gitea/workflows/ci.yml b/.gitea/workflows/ci.yml index 42c74c1..cb0abb4 100644 --- a/.gitea/workflows/ci.yml +++ b/.gitea/workflows/ci.yml @@ -9,13 +9,14 @@ on: jobs: test: + if: github.event_name == 'push' # TEMPORARY (issue #98): stress run, three suites on one server runs-on: ubuntu-latest container: image: mcr.microsoft.com/dotnet/sdk:10.0 strategy: fail-fast: false matrix: - db: [sqlite, postgres] + db: [postgres] # TEMPORARY (issue #98) services: postgres: image: postgres:18 @@ -44,13 +45,18 @@ jobs: git -c http.extraHeader="Authorization: token ${{ github.token }}" fetch -q --depth 1 origin "${{ github.sha }}" git checkout -q FETCH_HEAD - name: Check - run: sh ./tasks.sh check + # TEMPORARY (issue #98): the PostgreSQL suite three times on the same server. + run: | + status=0 + for i in 1 2 3; do echo "== round $i"; sh ./tasks.sh test -c Release || status=1; done + exit $status # 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: + if: false # TEMPORARY (issue #98) needs: test runs-on: ubuntu-latest # Registry settings for phase 9 (issue #70): declared here, not used before then. diff --git a/tools/Anubis.Tasks/ServiceLog.cs b/tools/Anubis.Tasks/ServiceLog.cs index e672490..17ddff3 100644 --- a/tools/Anubis.Tasks/ServiceLog.cs +++ b/tools/Anubis.Tasks/ServiceLog.cs @@ -83,6 +83,24 @@ internal static class ServiceLog 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(); -- 2.54.1 From 6ea303e1dcede4810ce4ae6e7e9659737d5daf1a Mon Sep 17 00:00:00 2001 From: Alberto Balbo Date: Sun, 15 Nov 2026 13:03:44 +0100 Subject: [PATCH 3/5] Run the test PostgreSQL behind an init and let pg_isready give up before Docker (refs #98) 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 --- .gitea/workflows/ci.yml | 7 ++- docker-compose.yml | 7 ++- .../0015-postgresql-con-init-nei-container.md | 46 +++++++++++++++++++ tools/Anubis.Tasks/ServiceLog.cs | 3 +- 4 files changed, 58 insertions(+), 5 deletions(-) create mode 100644 docs/adr/0015-postgresql-con-init-nei-container.md diff --git a/.gitea/workflows/ci.yml b/.gitea/workflows/ci.yml index cb0abb4..0951124 100644 --- a/.gitea/workflows/ci.yml +++ b/.gitea/workflows/ci.yml @@ -24,10 +24,13 @@ jobs: POSTGRES_DB: anubis POSTGRES_USER: anubis POSTGRES_PASSWORD: anubis-ci + # --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 }} 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..2a0b2ca --- /dev/null +++ b/docs/adr/0015-postgresql-con-init-nei-container.md @@ -0,0 +1,46 @@ +# 0015 — PostgreSQL nei container con un processo init e un controllo di salute che non si interrompe a metà + +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), `pg_database_size` del campionatore e il `CREATE`/`DROP DATABASE` dei test in sé: quelli rendono il server lento, non lo fanno ripartire. + +## 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. **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 due misure si coprono a vicenda: ognuna da sola basta a togliere la causa. + +## 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. +- **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/ServiceLog.cs b/tools/Anubis.Tasks/ServiceLog.cs index 17ddff3..bad0daf 100644 --- a/tools/Anubis.Tasks/ServiceLog.cs +++ b/tools/Anubis.Tasks/ServiceLog.cs @@ -74,7 +74,8 @@ internal static class ServiceLog 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"])}"); + 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) { -- 2.54.1 From 73f234504754fe947166d904efc67bd6a933eefc Mon Sep 17 00:00:00 2001 From: Alberto Balbo Date: Sun, 15 Nov 2026 14:25:59 +0100 Subject: [PATCH 4/5] Back to the normal CI jobs after the stress run (refs #98) 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 --- .gitea/workflows/ci.yml | 10 ++-------- 1 file changed, 2 insertions(+), 8 deletions(-) diff --git a/.gitea/workflows/ci.yml b/.gitea/workflows/ci.yml index 0951124..856b53c 100644 --- a/.gitea/workflows/ci.yml +++ b/.gitea/workflows/ci.yml @@ -9,14 +9,13 @@ on: jobs: test: - if: github.event_name == 'push' # TEMPORARY (issue #98): stress run, three suites on one server runs-on: ubuntu-latest container: image: mcr.microsoft.com/dotnet/sdk:10.0 strategy: fail-fast: false matrix: - db: [postgres] # TEMPORARY (issue #98) + db: [sqlite, postgres] services: postgres: image: postgres:18 @@ -48,18 +47,13 @@ jobs: git -c http.extraHeader="Authorization: token ${{ github.token }}" fetch -q --depth 1 origin "${{ github.sha }}" git checkout -q FETCH_HEAD - name: Check - # TEMPORARY (issue #98): the PostgreSQL suite three times on the same server. - run: | - status=0 - for i in 1 2 3; do echo "== round $i"; sh ./tasks.sh test -c Release || status=1; done - exit $status + 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: - if: false # TEMPORARY (issue #98) needs: test runs-on: ubuntu-latest # Registry settings for phase 9 (issue #70): declared here, not used before then. -- 2.54.1 From 74809068afbbeb190ee0bea98f2728b81af36db7 Mon Sep 17 00:00:00 2001 From: Alberto Balbo Date: Sun, 15 Nov 2026 15:27:48 +0100 Subject: [PATCH 5/5] Turn off disk syncs on the CI test PostgreSQL (refs #98) 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 --- .gitea/workflows/ci.yml | 3 +++ .../0015-postgresql-con-init-nei-container.md | 22 +++++++++++++++---- 2 files changed, 21 insertions(+), 4 deletions(-) diff --git a/.gitea/workflows/ci.yml b/.gitea/workflows/ci.yml index 856b53c..1e7aa75 100644 --- a/.gitea/workflows/ci.yml +++ b/.gitea/workflows/ci.yml @@ -23,6 +23,9 @@ 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: >- diff --git a/docs/adr/0015-postgresql-con-init-nei-container.md b/docs/adr/0015-postgresql-con-init-nei-container.md index 2a0b2ca..90f6c89 100644 --- a/docs/adr/0015-postgresql-con-init-nei-container.md +++ b/docs/adr/0015-postgresql-con-init-nei-container.md @@ -1,4 +1,4 @@ -# 0015 — PostgreSQL nei container con un processo init e un controllo di salute che non si interrompe a metà +# 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 @@ -29,18 +29,32 @@ Spiega anche gli altri indizi: - 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), `pg_database_size` del campionatore e il `CREATE`/`DROP DATABASE` dei test in sé: quelli rendono il server lento, non lo fanno ripartire. +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. **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. +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 due misure si coprono a vicenda: ognuna da sola basta a togliere la causa. +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.54.1