CI aziendale: prove con dati sintetici, installatore e immagine a ogni push, scansioni e pulizia #2

Merged
Alby96 merged 17 commits from ci/pipeline-aziendale into main 2026-10-20 18:04:52 +02:00
37 changed files with 2703 additions and 75 deletions

No files matched your search

+4
View File
@@ -0,0 +1,4 @@
# Proprietari del codice: Gitea chiede la loro revisione a ogni richiesta di unione che tocca i file indicati.
# In Gitea le regole sono espressioni regolari di Go, non schemi alla maniera di .gitignore (docs.gitea.com, «Code Owners»).
# Alberto è il proprietario di tutto il repository.
.* @Alby96
+5
View File
@@ -0,0 +1,5 @@
blank_issues_enabled: true
contact_links:
- name: Guida di Febe
url: https://gitea.encke-hake.ts.net/Alby96/Febe/wiki
about: Installazione, primo collegamento, limiti, problemi comuni e sicurezza
+36
View File
@@ -0,0 +1,36 @@
---
name: Difetto
about: Febe fa qualcosa di sbagliato, o non fa ciò che dovrebbe
title: "Difetto: "
---
<!--
Mai in una segnalazione: password, cookie, gettoni (Telegram, registro), codici di verifica, campioni grezzi della
sonda o corpi di risposta di Instagram. Il registro di Febe non li contiene: se ne incolli un pezzo, controlla
comunque prima di inviare.
-->
## Che cosa succede
<!-- Che cosa vedi, con il testo esatto dei messaggi. -->
## Che cosa ti aspettavi
## Come rifarlo
1.
2.
## Dove
- Veste: Docker (Unraid, Compose) / Windows (installato, portabile)
- Versione di Febe (Impostazioni ▸ Informazioni, o etichetta dell'immagine):
- Profilo di prudenza:
- Contro Instagram vero o contro il sito di prova:
## Registro
<!-- Le righe del registro intorno al problema (/dati/registro/febe-AAAA-MM-GG.log o %LOCALAPPDATA%\Febe\registro). -->
```text
```
+23
View File
@@ -0,0 +1,23 @@
---
name: Proposta
about: Una funzione nuova o un cambiamento di comportamento
title: "Proposta: "
---
## Il problema
<!-- Che cosa non riesci a fare oggi, o che cosa ti costa troppo. -->
## La proposta
## Regole di §2 toccate
<!-- Una proposta che chiede di contattare Instagram fuori dal browser, di cambiare il browser, di scavalcare una
verifica, di scrivere su Instagram o di aggiungere una dipendenza va discussa prima di tutto (docs/SPECIFICA.md, §2). -->
- [ ] Nessuna
- [ ] Sì, quali e perché:
## Come capiremo che è fatta
-
+67
View File
@@ -0,0 +1,67 @@
<!--
Una richiesta di unione per ramo, piccola quanto basta per leggerla tutta. Titolo in italiano: che cosa cambia.
Si unisce in main solo con la verifica verde sull'ultimo commit (docs/processo.md). Togli i commenti che non servono.
-->
## Sintesi
<!-- Che cosa fa questa richiesta, in due o tre frasi. -->
## Perché
<!-- Il problema, la richiesta di Alberto o la segnalazione (#numero) da cui nasce. -->
## Che cosa cambia
<!-- Per punti: comportamento, parti toccate, scelte nuove (con la riga in docs/decisioni.md), effetti su Docker o Windows. -->
-
## Come è stato provato
<!-- Comandi e risultati, copiati così come sono usciti. Poi, con la stessa franchezza, che cosa NON è stato provato e perché. -->
```text
dotnet build Febe.slnx -warnaserror
dotnet test tests/Febe.Tests
```
Non provato:
-
## Rischi e ritorno indietro
<!-- Che cosa può andare storto, come ce ne si accorge, come si torna indietro (di solito: annullare il commit di unione con git revert -m 1). Dati, migrazioni, impostazioni o segreti da sistemare a mano. -->
## Controlli prima di unire
Le regole di §2 della specifica (docs/SPECIFICA.md), che valgono sempre:
- [ ] 1. Verso Instagram parla solo il browser di Febe: nessuna connessione verso domini di Instagram o Meta, salvo il CDN alle condizioni di §6.5
- [ ] 2. Il browser si usa così com'è: niente stealth, user agent, impronta, fuso o lingua cambiati, headless, intestazioni riscritte, proxy, più account; comandi CDP solo dall'elenco di §6.1
- [ ] 3. Niente scavalcamenti: CAPTCHA, verifiche e codici non si risolvono in automatico, Febe si ferma e avvisa
- [ ] 4. Un account, una rete, un motore; i cookie non si copiano da una macchina all'altra
- [ ] 5. Sola lettura: niente mi piace, segui, commenti, messaggi, reazioni
- [ ] 6. Solo ciò che l'account di Alberto vede già
- [ ] 7. Ogni azione del motore verso il sito passa dal Governatore (IGovernor)
- [ ] 8. Al primo segnale di §7.6 ci si ferma, senza nuovi tentativi automatici
- [ ] 9. Nessuna prova, script o verifica contatta Instagram (solo tools/Febe.SitoDiProva) e nessuno apre i campioni grezzi della sonda (solo le copie ripulite di tests/campioni)
- [ ] 10. Nessun formato di risposta inventato: i lettori si scrivono su campioni reali ripuliti
- [ ] 11. Mai password, cookie, gettoni, tasti o corpi di risposta nei registri, nei messaggi di errore o nell'output della CI; i campioni grezzi fuori da git
- [ ] 12. La libreria non cancella e non sostituisce file da sola
- [ ] 13. Nessuna dipendenza fuori dall'elenco chiuso di §3 (Directory.Packages.props), se Alberto non l'ha approvata
- [ ] 14. Resoconto onesto: ciò che non è stato verificato è scritto qui sopra
E le convenzioni:
- [ ] La verifica è verde sull'ultimo commit: controlli, prove (nessuna saltata), installatore, immagine
- [ ] Nel motore niente DateTime.Now, Task.Delay o Random diretti (IClock, IRandomSource)
- [ ] Codice e commenti in inglese; interfaccia, documenti e messaggi in italiano
- [ ] Ogni scelta tecnica nuova ha la sua riga in docs/decisioni.md
- [ ] Una schermata cambiata è stata confrontata con il suo mockup (§10.7)
- [ ] Le righe per CHANGELOG.md e docs/stato.md sono scritte qui sotto (le aggiunge chi integra)
### Per CHANGELOG.md e docs/stato.md
-
+36
View File
@@ -0,0 +1,36 @@
#!/usr/bin/env bash
# Prepara il contenitore Debian del lavoro «prove» (node:24-trixie: Debian 13 con Node, che serve alle azioni) perché
# nessuna prova si salti: Chromium vero della distribuzione (su Ubuntu è uno snap, che nei contenitori non va) con le
# sue lingue, Xvfb, ffmpeg e ffprobe, makensis (NSIS) e zip, la lingua it_IT.UTF-8, fusi orari, ICU e gli stessi
# caratteri dell'immagine di Febe. Node c'è già (prova della pagina di accesso); setpriv, getent e l'utente nobody
# (65534) vengono con Debian (prove dell'avvio del contenitore).
#
# .gitea/scripts/ambiente-prove.sh
set -euo pipefail
sudo=""
[[ "$(id -u)" == 0 ]] || sudo="sudo"
export DEBIAN_FRONTEND=noninteractive
$sudo apt-get update -qq
$sudo apt-get install -y -qq --no-install-recommends \
chromium chromium-l10n \
xvfb \
ffmpeg \
nsis zip \
locales tzdata libicu76 ca-certificates \
fonts-noto-color-emoji fonts-liberation fonts-dejavu-core \
util-linux procps > /dev/null
$sudo sed -i 's/^# *\(it_IT.UTF-8 UTF-8\)/\1/' /etc/locale.gen
$sudo locale-gen > /dev/null
echo "== Strumenti delle prove"
chromium --version
command -v Xvfb
ffmpeg -version | head -n 1 || true
ffprobe -version | head -n 1 || true
echo "makensis $(makensis -VERSION)"
echo "node $(node --version)"
locale -a | grep -i '^it_IT\.utf8$'
for strumento in setpriv getent stat chown sh; do command -v "$strumento" > /dev/null || { echo "Manca $strumento." >&2; exit 1; }; done
getent passwd 65534 > /dev/null && getent group 65534 > /dev/null || { echo "Mancano l'utente o il gruppo 65534 (nobody)." >&2; exit 1; }
+89
View File
@@ -0,0 +1,89 @@
#!/usr/bin/env bash
# Controlli veloci prima di compilare (lavoro «controlli» della CI): pochi secondi, e fermano subito gli errori che
# altrimenti si scoprirebbero dopo mezz'ora di prove. Si lanciano anche a mano, dalla radice del repository:
#
# bash .gitea/scripts/controlli.sh
#
# 1. ogni script di shell del repository è sintassi valida (bash -n; sh -n per quelli in sh) e ha le righe Unix;
# 2. i flussi della CI non hanno tabulazioni (YAML non le accetta come rientro);
# 3. nessun file contiene segni di conflitto rimasti da un'unione;
# 4. la versione di Directory.Build.props è nella forma x.y.z[-qualcosa], quella che installer/costruisci.sh accetta;
# 5. ogni progetto elencato in Febe.slnx esiste;
# 6. ogni file JSON del repository si legge (configurazioni, campioni ripuliti, criteri di Chromium).
set -uo pipefail
radice="$(git rev-parse --show-toplevel)" || exit 2
cd "$radice" || exit 2
errori=0
errore() {
echo "ERRORE: $*" >&2
errori=$((errori + 1))
}
echo "== Script di shell"
quanti=0
while IFS= read -r -d '' script; do
quanti=$((quanti + 1))
bash -n "$script" || errore "$script: sintassi bash non valida."
if head -n 1 "$script" | grep -Eq '^#!(/usr/bin/env )?/?(bin/)?sh( |$)'; then
sh -n "$script" || errore "$script: sintassi sh non valida."
fi
if grep -q $'\r' "$script"; then
errore "$script ha righe Windows (CR): bash non le regge (.gitattributes chiede eol=lf)."
fi
done < <(git ls-files -z -- '*.sh')
echo " $quanti script controllati"
echo "== Flussi della CI"
while IFS= read -r -d '' flusso; do
if grep -n $'\t' "$flusso" > /dev/null; then
errore "$flusso contiene tabulazioni: in YAML il rientro si fa con gli spazi."
fi
done < <(git ls-files -z -- '.gitea/workflows/*.yml' '.gitea/workflows/*.yaml')
echo "== Segni di conflitto"
if conflitti=$(git grep -n -I -E '^(<{7}|>{7})( |$)' -- . ':!*.png' ':!*.jpg'); then
errore "segni di conflitto rimasti:"
echo "$conflitti" >&2
fi
echo "== Versione"
versione=$(sed -n 's:.*<Version>\(.*\)</Version>.*:\1:p' Directory.Build.props)
if [[ "$(printf '%s\n' "$versione" | grep -c .)" != "1" ]]; then
errore "Directory.Build.props deve avere una sola <Version>."
elif [[ ! "$versione" =~ ^[0-9]+\.[0-9]+\.[0-9]+([-+][0-9A-Za-z.-]+)?$ ]]; then
errore "versione «$versione» non valida: serve x.y.z, eventualmente con -qualcosa."
else
echo " $versione"
fi
echo "== Progetti della soluzione"
while IFS= read -r progetto; do
[[ -f "$progetto" ]] || errore "Febe.slnx elenca $progetto, che non esiste."
done < <(sed -n 's:.*<Project Path="\([^"]*\)".*:\1:p' Febe.slnx)
echo " $(grep -c '<Project Path=' Febe.slnx) progetti"
echo "== File JSON"
if command -v node > /dev/null; then
# Un solo processo per tutti i file; stampa i file che non si leggono, uno per riga.
guasti=$(git ls-files -z -- '*.json' | node -e '
const fs = require("fs");
const files = fs.readFileSync(0, "utf8").split("\0").filter(Boolean);
for (const f of files) {
try { JSON.parse(fs.readFileSync(f, "utf8").replace(/^/, "")); } catch (e) { console.log(f + ": " + e.message); }
}
console.error(" " + files.length + " file controllati");')
if [[ -n "$guasti" ]]; then
errore "JSON non valido:"
echo "$guasti" >&2
fi
else
errore "manca node: i file JSON non si possono controllare."
fi
if ((errori > 0)); then
echo "Controlli falliti: $errori." >&2
exit 1
fi
echo "Controlli superati."
+48
View File
@@ -0,0 +1,48 @@
#!/usr/bin/env bash
# Costruzione dell'immagine Docker di Febe con il builder buildx dell'esecuzione (docker-container), sempre con gli
# stessi argomenti e le stesse etichette: la costruzione che si pubblica esce intera dalla cache di quella che si è
# provata e scansionata, quindi gli strati sono gli stessi.
#
# costruisci-immagine.sh archivio <file.tar> <nome locale> archivio dell'immagine, per docker load e per Trivy
# costruisci-immagine.sh pubblica <nome:etichetta>... spinta sul registro da buildx: le credenziali sono
# già nella configurazione del client, il demone non
# parla mai con il registro (proverebbe HTTPS)
#
# Variabili richieste: BUILDER, VERSIONE, GIT_COMMIT, FLUSSO (verifica o rilascio), ESECUZIONE (gitea.run_id).
# Le etichette febe.ci.* dicono quale flusso, esecuzione, ramo e commit hanno costruito l'immagine. Non servono alla
# pulizia: stanno anche nelle immagini pubblicate e Docker le copia in ogni contenitore creato da quelle, anche in un
# Febe vero. Per questo qui non si mette mai febe.ci.prova, il segno dei soli contenitori di prova (prova-immagine.sh):
# lo controlla PipelineTests.
set -euo pipefail
modo="${1:?Indica il modo: archivio o pubblica.}"
shift
cd "$(git rev-parse --show-toplevel)"
comuni=(--builder "${BUILDER:?}" -f docker/Dockerfile
--build-arg "VERSION=${VERSIONE:?}" --build-arg "GIT_COMMIT=${GIT_COMMIT:?}"
--label "febe.ci.workflow=${FLUSSO:?}" --label "febe.ci.run=${ESECUZIONE:?}"
--label "febe.ci.ref=${GITHUB_REF_NAME:-}" --label "febe.ci.commit=${GITHUB_SHA:-}")
case "$modo" in
archivio)
archivio="${1:?Indica il file .tar da scrivere.}"
nome="${2:?Indica il nome locale, per esempio febe-ci:123.}"
mkdir -p "$(dirname "$archivio")"
docker buildx build "${comuni[@]}" --output "type=docker,name=$nome,dest=$archivio" .
echo "Archivio dell'immagine: $archivio ($(du -h "$archivio" | cut -f1))"
;;
pubblica)
(($# > 0)) || { echo "Indica almeno un nome:etichetta da pubblicare." >&2; exit 2; }
etichette=()
for nome in "$@"; do
etichette+=(-t "$nome")
done
docker buildx build "${comuni[@]}" "${etichette[@]}" --push .
printf 'Pubblicata: %s\n' "$@"
;;
*)
echo "Modo sconosciuto: «$modo» (archivio o pubblica)." >&2
exit 2
;;
esac
+87
View File
@@ -0,0 +1,87 @@
#!/usr/bin/env bash
# Prova dell'immagine appena costruita, sul demone Docker del runner. Ogni contenitore gira SENZA RETE
# (--network none): Febe non può raggiungere alcun sito, tanto meno Instagram (regola 1), e il controllo di salute
# passa dalla rete interna del contenitore.
# Ogni contenitore porta l'etichetta febe.ci.prova=<esecuzione>, messa qui con «docker run --label» e mai in
# un'immagine: è il segno con cui pulizia-docker.sh riconosce un contenitore di prova, insieme al nome
# febe-prova-<esecuzione>. Le etichette febe.ci.* dell'immagine non bastano: Docker le copia in ogni contenitore, anche
# in un Febe vero avviato da un'immagine pubblicata.
#
# .gitea/scripts/prova-immagine.sh <immagine> [esecuzione]
#
# 1. Chromium della distribuzione risponde e i criteri di Febe (niente password salvate) sono al loro posto;
# 2. la lingua it_IT.UTF-8 è generata;
# 3. il contenitore parte come dice la guida (profilo seccomp di Febe, password dell'interfaccia, PUID/PGID
# predefiniti), il controllo di salute dell'immagine diventa «healthy» e «febe --controllo-salute» risponde;
# 4. allo stop si ferma da solo, entro i 30 secondi che la guida concede.
# La password è casuale, vive solo nell'ambiente del client Docker e non si stampa mai.
set -euo pipefail
immagine="${1:?Indica quale immagine provare.}"
esecuzione="${2:-${ESECUZIONE:-locale}}"
radice="$(git rev-parse --show-toplevel)"
etichette=(--label "febe.ci.prova=$esecuzione")
nome="febe-prova-$esecuzione"
# Toglie il contenitore di prova di questa esecuzione (anche quello di un tentativo precedente), ma solo se porta il
# segno della prova: un contenitore con lo stesso nome e senza segno resta, e «docker run --name» si ferma.
togli() {
local segno
segno=$(docker container inspect -f '{{index .Config.Labels "febe.ci.prova"}}' "$nome" 2> /dev/null) || return 0
if [[ "$segno" == "$esecuzione" ]]; then
docker rm -f -v "$nome" > /dev/null 2>&1 || true
fi
}
trap togli EXIT
togli
echo "== Chromium e criteri di Febe"
docker run --rm --network none "${etichette[@]}" --entrypoint /usr/bin/chromium "$immagine" --version
docker run --rm --network none "${etichette[@]}" --entrypoint sh "$immagine" -c \
'test -s /etc/chromium/policies/managed/febe.json && test -s /usr/share/febe/seccomp.json && echo "criteri di Chromium e profilo seccomp presenti"'
echo "== Lingua italiana"
docker run --rm --network none "${etichette[@]}" --entrypoint sh "$immagine" -c 'locale -a | grep -i "^it_IT\.utf8$"'
echo "== Avvio, salute e arresto"
FEBE_PASSWORD="$(head -c 32 /dev/urandom | base64 | tr -dc 'A-Za-z0-9')"
export FEBE_PASSWORD
docker run -d --name "$nome" --network none "${etichette[@]}" \
--security-opt "seccomp=$radice/docker/chromium/seccomp.json" \
--stop-timeout 30 -e FEBE_PASSWORD "$immagine" > /dev/null
unset FEBE_PASSWORD
# Il primo controllo di salute dell'immagine arriva 30 secondi dopo l'avvio (HEALTHCHECK --interval=30s): fino a 3 minuti.
stato=""
for _ in $(seq 1 36); do
if [[ "$(docker inspect -f '{{.State.Running}}' "$nome")" != "true" ]]; then
echo "Il contenitore si è fermato da solo (codice $(docker inspect -f '{{.State.ExitCode}}' "$nome")). Registro:" >&2
docker logs --tail 80 "$nome" >&2 || true
exit 1
fi
stato="$(docker inspect -f '{{if .State.Health}}{{.State.Health.Status}}{{end}}' "$nome")"
[[ "$stato" == "healthy" || "$stato" == "unhealthy" ]] && break
sleep 5
done
if [[ "$stato" != "healthy" ]]; then
echo "Il controllo di salute dice «${stato:-niente}» invece di «healthy». Registro:" >&2
docker logs --tail 80 "$nome" >&2 || true
exit 1
fi
if ! docker exec "$nome" /app/febe --controllo-salute > /dev/null; then
echo "febe --controllo-salute non risponde «ok» dentro il contenitore. Registro:" >&2
docker logs --tail 80 "$nome" >&2 || true
exit 1
fi
echo "salute: healthy, e febe --controllo-salute risponde"
inizio=$(date +%s)
docker stop -t 30 "$nome" > /dev/null
durata=$(($(date +%s) - inizio))
codice="$(docker inspect -f '{{.State.ExitCode}}' "$nome")"
echo "arresto in ${durata} s (codice di uscita $codice)"
if ((durata >= 30)); then
echo "Febe non si è fermato da solo entro 30 secondi: Docker l'ha dovuto uccidere. Registro:" >&2
docker logs --tail 80 "$nome" >&2 || true
exit 1
fi
+226
View File
@@ -0,0 +1,226 @@
#!/usr/bin/env bash
# Pulizia di ciò che la CI di Febe lascia sul demone Docker del runner. È lo stesso demone che costruisce Encelado,
# Mimante e gli altri progetti di Alberto, e ci può girare anche un Febe vero: si tocca solo ciò che si può provare
# creato dalla CI, più le immagini senza nome («dangling») più vecchie di tre giorni. Mai altro, e mai la cache di
# costruzione del demone (è condivisa).
#
# Le etichette febe.ci.workflow, febe.ci.run, febe.ci.ref e febe.ci.commit dicono da dove viene un'immagine, ma NON
# scelgono che cosa togliere: stanno anche nelle immagini pubblicate (:main, :sha-, :X.Y.Z, :latest), e Docker le copia
# in ogni contenitore creato da quelle immagini, quindi le porta anche un Febe vero. Ciò che si toglie si riconosce così:
# - contenitori di prova: l'etichetta febe.ci.prova=<esecuzione>, che mette solo prova-immagine.sh con
# «docker run --label» e che nessuna immagine porta (lo controlla PipelineTests), E il nome esatto
# febe-prova-<la stessa esecuzione> (gli altri contenitori della prova, senza nome, girano con --rm e Docker li
# toglie da sé appena finiscono);
# - immagini provate: il nome locale febe-ci:<esecuzione>, tolto per nome, mai per identificativo e mai con -f. Se la
# stessa immagine ha anche un nome del registro, si toglie solo febe-ci:<esecuzione>; se un contenitore la usa, resta;
# - builder buildx: il contenitore buildx_buildkit_febe-ci-<esecuzione>0, con l'immagine moby/buildkit, e il suo
# volume …_state, che contengono la cache di costruzione di quell'esecuzione;
# - l'immagine febe:ci lasciata dal vecchio flusso di verifica (prima del 20 ottobre 2026), se nessuno la usa.
#
# pulizia-docker.sh esecuzione <id> tutto ciò che ha creato l'esecuzione <id> (all'inizio e alla fine del suo
# lavoro «immagine», sempre)
# pulizia-docker.sh residui [minuti] i resti di esecuzioni interrotte, più vecchi di N minuti (predefinito 90: un
# lavoro dura al massimo 60 minuti, quindi nessuno di essi è ancora vivo)
# pulizia-docker.sh settimanale residui, febe:ci, immagini senza nome più vecchie di 72 ore (flusso «pulizia»)
#
# Nei modi «residui» e «settimanale» un contenitore di prova si toglie solo se è fermo. Uno ancora acceso dopo 90 minuti
# (il suo lavoro è stato ucciso proprio durante la prova del contenitore) resta dov'è: lo si segnala, con il comando per
# toglierlo a mano. I builder sono l'eccezione: sono sempre accesi e la loro cache se ne va solo togliendo il
# contenitore; si riconoscono dal nome esatto e dall'immagine di buildkit, mai da un'etichetta.
#
# Un oggetto già sparito non è un errore: la pulizia si può ripetere. Nei modi «esecuzione» e «residui» un problema
# diventa un avviso (un lavoro verde non diventa rosso per la pulizia, che il flusso settimanale ripete); nel modo
# «settimanale» fa fallire il lavoro, perché qualcuno lo guardi.
set -uo pipefail
modo="${1:-}"
problemi=0
avviso() {
echo "::warning::$*"
problemi=$((problemi + 1))
}
# Minuti trascorsi da un istante RFC 3339 (il campo Created di docker inspect). Se non si legge, 0: nel dubbio
# l'oggetto è giovane e resta.
eta_minuti() {
local creato="${1%%.*}"
creato="${creato%Z}"
local secondi
secondi=$(date -u -d "${creato}Z" +%s 2>/dev/null) || { echo 0; return; }
echo $((($(date -u +%s) - secondi) / 60))
}
# I contenitori di prova della CI, uno per riga «id nome»: l'etichetta febe.ci.prova (dell'esecuzione indicata, o di
# qualunque se il primo argomento è vuoto) e il nome esatto febe-prova-<valore dell'etichetta>. Gli stati che seguono
# restringono la scelta (Docker li unisce in OR). Esce con 1 se Docker non risponde.
contenitori_di_prova() {
local run="$1"
shift
local stati=() stato elenco id nome valore
for stato in "$@"; do stati+=(--filter "status=$stato"); done
elenco=$(docker ps -a --no-trunc --filter "label=febe.ci.prova${run:+=$run}" "${stati[@]}" \
--format '{{.ID}} {{.Names}} {{.Label "febe.ci.prova"}}') || return 1
while read -r id nome valore; do
[[ -n "${id:-}" && "${valore:-}" =~ ^[0-9]+$ && "${nome:-}" == "febe-prova-$valore" ]] || continue
[[ -z "$run" || "$valore" == "$run" ]] || continue
echo "$id $nome"
done <<< "$elenco"
}
# Toglie un contenitore con i suoi volumi anonimi. Con «forza» anche se è acceso: solo per quelli dell'esecuzione
# stessa e per i builder.
togli_contenitore() {
local id="$1" nome="$2" opzioni=(-v)
[[ "${3:-}" == forza ]] && opzioni=(-f -v)
if docker rm "${opzioni[@]}" "$id" > /dev/null 2>&1; then
echo " contenitore $nome tolto"
elif docker container inspect "$id" > /dev/null 2>&1; then
avviso "Non riesco a togliere il contenitore $nome."
fi
}
# Toglie il nome locale febe-ci:<esecuzione>, mai l'immagine per identificativo e mai con -f: se l'immagine ha anche un
# altro nome (del registro, per esempio) quello resta; se un contenitore la usa, resta tutto.
togli_immagine() {
local riferimento="$1" nomi
[[ "$riferimento" =~ ^febe-ci:[0-9]+$ ]] || { avviso "Nome di immagine inatteso: «$riferimento»."; return 0; }
nomi=$(docker image inspect -f '{{len .RepoTags}}' "$riferimento" 2>/dev/null) || return 0
if [[ "$nomi" == 1 && -n "$(docker ps -a -q --filter "ancestor=$riferimento")" ]]; then
echo " immagine $riferimento in uso da un contenitore: resta"
return 0
fi
if docker image rm "$riferimento" > /dev/null 2>&1; then
echo " immagine $riferimento tolta"
else
avviso "Non riesco a togliere l'immagine $riferimento."
fi
}
# Un builder buildx della CI: prima con buildx (se questo client lo conosce), poi contenitore e volume per nome, perché
# un lavoro diverso da quello che l'ha creato non ne ha la configurazione. Il contenitore si toglie solo se gira
# l'immagine di buildkit, e il volume solo quando il contenitore non c'è più.
togli_builder() {
local builder="$1"
[[ "$builder" =~ ^febe-ci-[0-9]+$ ]] || { avviso "Nome di builder inatteso: «$builder»."; return 0; }
docker buildx rm -f "$builder" > /dev/null 2>&1 && echo " builder $builder tolto"
local contenitore="buildx_buildkit_${builder}0" immagine
if immagine=$(docker container inspect -f '{{.Config.Image}}' "$contenitore" 2>/dev/null); then
if [[ "$immagine" != *moby/buildkit* ]]; then
avviso "Il contenitore $contenitore non è un builder buildx (immagine «$immagine»): resta."
return 0
fi
togli_contenitore "$contenitore" "$contenitore" forza
docker container inspect "$contenitore" > /dev/null 2>&1 && return 0
fi
if docker volume inspect "${contenitore}_state" > /dev/null 2>&1; then
if docker volume rm -f "${contenitore}_state" > /dev/null 2>&1; then
echo " volume ${contenitore}_state tolto"
else
avviso "Non riesco a togliere il volume ${contenitore}_state."
fi
fi
}
esecuzione() {
local run="${1:-}"
[[ "$run" =~ ^[0-9]+$ ]] || { echo "Indica il numero dell'esecuzione (gitea.run_id), non «$run»." >&2; exit 2; }
echo "== Pulizia dell'esecuzione $run"
local elenco id nome
if elenco=$(contenitori_di_prova "$run"); then
while read -r id nome; do
[[ -n "${id:-}" ]] && togli_contenitore "$id" "$nome" forza
done <<< "$elenco"
else
avviso "Non riesco a elencare i contenitori di prova dell'esecuzione $run."
fi
togli_immagine "febe-ci:$run"
togli_builder "febe-ci-$run"
}
residui() {
local minuti="${1:-90}"
[[ "$minuti" =~ ^[0-9]+$ ]] || { echo "I minuti devono essere un numero, non «$minuti»." >&2; exit 2; }
echo "== Resti di esecuzioni interrotte, più vecchi di $minuti minuti"
local elenco id nome eta riferimento
# Contenitori di prova fermi: si tolgono. Senza -f: se nel frattempo uno ripartisse, Docker lo lascia stare.
if elenco=$(contenitori_di_prova "" exited created dead); then
while read -r id nome; do
[[ -n "${id:-}" ]] || continue
eta=$(eta_minuti "$(docker container inspect -f '{{.Created}}' "$id" 2>/dev/null)")
((eta >= minuti)) && togli_contenitore "$id" "$nome"
done <<< "$elenco"
else
avviso "Non riesco a elencare i contenitori di prova fermi."
fi
# Contenitori di prova ancora accesi: non si toccano, si segnalano.
if elenco=$(contenitori_di_prova "" running restarting paused); then
while read -r id nome; do
[[ -n "${id:-}" ]] || continue
eta=$(eta_minuti "$(docker container inspect -f '{{.Created}}' "$id" 2>/dev/null)")
if ((eta >= minuti)); then
avviso "Il contenitore di prova $nome è acceso da $eta minuti: il suo lavoro si è interrotto durante la prova. La pulizia non toglie contenitori accesi; se nessuna esecuzione lo usa più, toglilo a mano: docker rm -f -v $nome"
fi
done <<< "$elenco"
else
avviso "Non riesco a elencare i contenitori di prova accesi."
fi
# Immagini provate: solo i nomi febe-ci:<esecuzione>.
if elenco=$(docker image ls --filter "reference=febe-ci" --format '{{.Repository}}:{{.Tag}}'); then
while read -r riferimento; do
[[ "${riferimento:-}" =~ ^febe-ci:[0-9]+$ ]] || continue
eta=$(eta_minuti "$(docker image inspect -f '{{.Created}}' "$riferimento" 2>/dev/null)")
((eta >= minuti)) && togli_immagine "$riferimento"
done <<< "$elenco"
else
avviso "Non riesco a elencare le immagini febe-ci."
fi
# Builder buildx. Il filtro per nome di Docker cerca una parte del nome: il nome esatto si controlla qui.
if elenco=$(docker ps -a --no-trunc --filter "name=buildx_buildkit_febe-ci-" --format '{{.ID}} {{.Names}}'); then
while read -r id nome; do
[[ -n "${id:-}" ]] || continue
nome="${nome#/}"
[[ "$nome" =~ ^buildx_buildkit_(febe-ci-[0-9]+)0$ ]] || continue
eta=$(eta_minuti "$(docker container inspect -f '{{.Created}}' "$id" 2>/dev/null)")
((eta >= minuti)) && togli_builder "${BASH_REMATCH[1]}"
done <<< "$elenco"
else
avviso "Non riesco a elencare i builder buildx."
fi
}
settimanale() {
residui 90
echo "== Immagine febe:ci del vecchio flusso di verifica"
if docker image inspect febe:ci > /dev/null 2>&1; then
# Senza -f: se un contenitore la usa resta dov'è.
docker image rm febe:ci > /dev/null 2>&1 && echo " febe:ci tolta" || echo " febe:ci è in uso: resta"
fi
echo "== Immagini senza nome più vecchie di 72 ore"
docker image prune -f --filter "until=72h" || avviso "La pulizia delle immagini senza nome non è riuscita."
}
command -v docker > /dev/null || { echo "Manca il client Docker: niente da pulire." >&2; exit 2; }
case "$modo" in
esecuzione) esecuzione "${2:-}" ;;
residui) residui "${2:-90}" ;;
settimanale)
docker system df || true
settimanale
docker system df || true
;;
*)
echo "Uso: $0 esecuzione <id> | residui [minuti] | settimanale" >&2
exit 2
;;
esac
if ((problemi > 0)); then
echo "Pulizia finita con $problemi avvisi."
[[ "$modo" == settimanale ]] && exit 1
fi
exit 0
+106
View File
@@ -0,0 +1,106 @@
#!/usr/bin/env bash
# Riepilogo dei risultati delle prove (file .trx di «dotnet test --logger trx»): superate, fallite e saltate per ogni
# file, i nomi delle fallite e i motivi delle saltate. Lo scrive nel registro e, se il runner lo offre, nel riepilogo
# del lavoro (GITHUB_STEP_SUMMARY). Nessun corpo di risposta né dato personale: solo nomi di prove e messaggi.
#
# .gitea/scripts/riepilogo-prove.sh <cartella dei .trx> [saltate ammesse]
#
# Esce con 1 se una prova è fallita, se le saltate sono più di quelle ammesse (predefinito 0: nella CI ci sono
# Chromium, Xvfb, ffmpeg, NSIS e Node, quindi nessuna prova ha motivo di saltarsi) o se non c'è nessun risultato.
set -euo pipefail
cartella="${1:?Indica la cartella con i file .trx.}"
ammesse="${2:-${PROVE_SALTATE_AMMESSE:-0}}"
[[ "$ammesse" =~ ^[0-9]+$ ]] || { echo "Il numero di prove saltate ammesse deve essere un intero, non «$ammesse»." >&2; exit 2; }
shopt -s nullglob
file=("$cartella"/*.trx)
if (( ${#file[@]} == 0 )); then
echo "Nessun risultato delle prove in $cartella: le prove non sono partite." >&2
exit 1
fi
riepilogo="$(mktemp)"
trap 'rm -f "$riepilogo"' EXIT
fallite_totali=0
saltate_totali=0
{
echo "### Prove"
echo
echo "| Risultati | Totale | Superate | Fallite | Saltate |"
echo "|---|---:|---:|---:|---:|"
} > "$riepilogo"
for trx in "${file[@]}"; do
nome="$(basename "$trx")"
# Un risultato per riga (i .trx sono XML su più righe), poi nome, esito e primo messaggio di ciascuno.
righe="$(tr '\r\n' ' ' < "$trx" | sed 's/<UnitTestResult /\n<UnitTestResult /g' | awk '
function attributo(testo, chiave, inizio) {
if (match(testo, chiave "=\"[^\"]*\"")) {
return substr(testo, RSTART + length(chiave) + 2, RLENGTH - length(chiave) - 3)
}
return ""
}
function testo_xml(s) {
gsub(/&#xD;/, "", s); gsub(/&#xA;/, " ", s); gsub(/&apos;/, "\047", s); gsub(/&quot;/, "\"", s)
gsub(/&lt;/, "<", s); gsub(/&gt;/, ">", s); gsub(/&amp;/, "\\&", s); gsub(/[ \t]+/, " ", s)
return s
}
/^<UnitTestResult / {
testata = $0
sub(/>.*/, "", testata)
messaggio = ""
if (match($0, /<Message>[^<]*<\/Message>/)) {
messaggio = substr($0, RSTART + 9, RLENGTH - 19)
}
printf "%s\t%s\t%s\n", attributo(testata, "outcome"), testo_xml(attributo(testata, "testName")), testo_xml(messaggio)
}')"
totale=0; superate=0; fallite=0; saltate=0
if [[ -n "$righe" ]]; then
totale=$(printf '%s\n' "$righe" | wc -l)
superate=$(printf '%s\n' "$righe" | awk -F'\t' '$1 == "Passed"' | wc -l)
fallite=$(printf '%s\n' "$righe" | awk -F'\t' '$1 == "Failed" || $1 == "Error" || $1 == "Timeout" || $1 == "Aborted"' | wc -l)
fi
saltate=$((totale - superate - fallite))
fallite_totali=$((fallite_totali + fallite))
saltate_totali=$((saltate_totali + saltate))
echo "== $nome: totale $totale · superate $superate · fallite $fallite · saltate $saltate"
echo "| \`$nome\` | $totale | $superate | $fallite | $saltate |" >> "$riepilogo"
if (( fallite > 0 )); then
echo " Fallite:"
# Le righe in più si leggono e si scartano (niente «head»: con pipefail il SIGPIPE fermerebbe lo script).
printf '%s\n' "$righe" | awk -F'\t' '$1 == "Failed" || $1 == "Error" || $1 == "Timeout" || $1 == "Aborted" {
if (++n > 50) next; m = $3; if (length(m) > 300) m = substr(m, 1, 300) "…"; print " - " $2 ": " m }'
fi
if (( saltate > 0 )); then
echo " Saltate, per motivo:"
# Il motivo senza la cornice di MSTest («Il metodo … ha generato un'eccezione. Assert.Inconclusive.»).
printf '%s\n' "$righe" | awk -F'\t' '$1 != "Passed" && $1 != "Failed" && $1 != "Error" && $1 != "Timeout" && $1 != "Aborted" {
m = $3; sub(/^.*Assert\.Inconclusive\. */, "", m); if (m == "") m = "(nessun motivo)"; print m }' \
| sort | uniq -c | sort -rn | awk 'NR <= 30 { sub(/^ */, " "); print }'
fi
done
esito=0
{
echo
echo "Fallite: $fallite_totali · saltate: $saltate_totali (ammesse: $ammesse)."
} >> "$riepilogo"
if (( fallite_totali > 0 )); then
echo "Prove fallite: $fallite_totali (i file .trx sono fra gli artefatti dell'esecuzione)." >&2
esito=1
fi
if (( saltate_totali > ammesse )); then
echo "Prove saltate: $saltate_totali, più delle $ammesse ammesse. Qui ci sono Chromium, Xvfb, ffmpeg, NSIS e Node: una prova che si salta segnala un ambiente rotto, non una prova superata." >&2
esito=1
fi
if [[ -n "${GITHUB_STEP_SUMMARY:-}" ]]; then
cat "$riepilogo" >> "$GITHUB_STEP_SUMMARY" || true
fi
exit "$esito"
+54
View File
@@ -0,0 +1,54 @@
#!/usr/bin/env bash
# Scansione delle vulnerabilità dell'immagine Docker con Trivy, a versione fissa (strumento.sh), sull'archivio prodotto
# dalla costruzione (docker save o buildx --output type=docker): non serve il demone, e si scansiona proprio
# l'immagine provata. Pacchetti di Debian e dipendenze .NET di Febe (i file *.deps.json).
#
# .gitea/scripts/scansione-immagine.sh <immagine.tar> [cartella dei rapporti]
#
# La regola (docs/processo.md, «Rilievi di sicurezza»):
# - CRITICAL con una correzione disponibile: il lavoro fallisce e l'immagine non si pubblica;
# - HIGH, e CRITICAL ancora senza correzione: si riportano nel registro e in trivy.json, senza fermare nulla.
# Le eccezioni stanno solo in .trivyignore, alla radice del repository: un identificativo per riga, con la scadenza
# (exp:AAAA-MM-GG) e, sulla riga sopra, il motivo scritto e chi l'ha deciso.
set -euo pipefail
radice="$(git rev-parse --show-toplevel)"
archivio="${1:?Manca il file .tar da scansionare.}"
rapporti="${2:-$radice/out/sicurezza}"
lavoro="${RUNNER_TEMP:-/tmp}"
strumenti="$lavoro/febe-strumenti"
[[ -s "$archivio" ]] || { echo "Manca l'archivio dell'immagine: $archivio" >&2; exit 2; }
bash "$radice/.gitea/scripts/strumento.sh" trivy "$strumenti"
mkdir -p "$rapporti"
# Niente barre di avanzamento, niente controllo di versioni nuove, niente dati d'uso.
export TRIVY_NO_PROGRESS=true TRIVY_SKIP_VERSION_CHECK=true TRIVY_DISABLE_TELEMETRY=true
export TRIVY_CACHE_DIR="$lavoro/febe-trivy-cache"
comuni=(image --input "$archivio" --scanners vuln --timeout 20m)
if [[ -f "$radice/.trivyignore" ]]; then
comuni+=(--ignorefile "$radice/.trivyignore")
echo "Eccezioni in .trivyignore: $(grep -c -E '^[^#[:space:]]' "$radice/.trivyignore" || true)"
fi
echo "== Vulnerabilità HIGH e CRITICAL (rapporto: non fermano il lavoro)"
"$strumenti/trivy" "${comuni[@]}" --severity HIGH,CRITICAL --format json --output "$rapporti/trivy.json" --exit-code 0
"$strumenti/trivy" convert --format table "$rapporti/trivy.json"
if command -v jq > /dev/null; then
conteggio=$(jq -r '[.Results[]?.Vulnerabilities[]?] as $v
| "HIGH \([$v[] | select(.Severity == "HIGH")] | length) · CRITICAL \([$v[] | select(.Severity == "CRITICAL")] | length), di cui correggibili \([$v[] | select(.Severity == "CRITICAL" and ((.FixedVersion // "") != ""))] | length)"' "$rapporti/trivy.json")
echo "Trovate: $conteggio."
if [[ -n "${GITHUB_STEP_SUMMARY:-}" ]]; then
printf "### Sicurezza dell'immagine (Trivy)\n\n%s.\n" "$conteggio" >> "$GITHUB_STEP_SUMMARY" || true
fi
fi
echo "== CRITICAL con una correzione disponibile (fermano il lavoro)"
if "$strumenti/trivy" "${comuni[@]}" --skip-db-update --skip-java-db-update --severity CRITICAL --ignore-unfixed \
--format table --exit-code 1; then
echo "Nessuna vulnerabilità CRITICAL con una correzione disponibile."
else
echo "Vulnerabilità CRITICAL con una correzione disponibile: l'immagine non passa. Aggiorna il pacchetto o la dipendenza (docs/processo.md, «Rilievi di sicurezza»)." >&2
exit 1
fi
+47
View File
@@ -0,0 +1,47 @@
#!/usr/bin/env bash
# Cerca segreti (gettoni, chiavi, password) con gitleaks, a versione fissa (strumento.sh), in tutta la storia del
# commit verificato: ogni commit da cui discende, non solo l'ultimo. Ogni ramo si controlla al suo push (main a ogni
# unione), così un rilievo su un ramo non blocca gli altri. Un segreto non compare mai per intero: --redact lo
# sostituisce con REDACTED nel registro e nel rapporto, e qui si stampano solo regola, file, riga, commit e impronta.
#
# .gitea/scripts/segreti.sh [cartella del rapporto]
#
# Che cosa fare con un rilievo: docs/processo.md, «Rilievi di sicurezza». In breve: un segreto vero si revoca subito
# (toglierlo dalla storia non basta); un falso allarme già controllato (un dato di prova finto) si mette in
# .gitleaksignore con la sua impronta e, sulla riga sopra, un commento che dice che cos'è e chi l'ha controllato.
set -euo pipefail
radice="$(git rev-parse --show-toplevel)"
rapporti="${1:-$radice/out/sicurezza}"
strumenti="${RUNNER_TEMP:-/tmp}/febe-strumenti"
if [[ "$(git -C "$radice" rev-parse --is-shallow-repository)" == "true" ]]; then
echo "Il clone è parziale: per cercare in tutta la storia serve actions/checkout con fetch-depth: 0." >&2
exit 2
fi
bash "$radice/.gitea/scripts/strumento.sh" gitleaks "$strumenti"
mkdir -p "$rapporti"
rapporto="$rapporti/gitleaks.json"
argomenti=(git "$radice" --log-opts="--full-history HEAD" --redact --no-banner --no-color --exit-code 1 --log-level warn
--report-format json --report-path "$rapporto")
[[ -f "$radice/.gitleaks.toml" ]] && argomenti+=(--config "$radice/.gitleaks.toml")
[[ -f "$radice/.gitleaksignore" ]] && argomenti+=(--gitleaks-ignore-path "$radice/.gitleaksignore")
commit=$(git -C "$radice" rev-list --count HEAD)
stato=0
"$strumenti/gitleaks" "${argomenti[@]}" || stato=$?
if ((stato == 0)); then
echo "Nessun segreto in $commit commit."
exit 0
fi
if [[ -s "$rapporto" ]] && command -v jq > /dev/null; then
quanti=$(jq 'length' "$rapporto")
echo "Possibili segreti: $quanti (in $commit commit). Regola, file:riga, commit, impronta per .gitleaksignore:" >&2
jq -r '.[] | " \(.RuleID) \(.File):\(.StartLine) commit \(.Commit[0:12]) impronta \(.Fingerprint)"' "$rapporto" >&2
else
echo "gitleaks è uscito con $stato: vedi il registro qui sopra e il rapporto $rapporto." >&2
fi
exit "$stato"
+60
View File
@@ -0,0 +1,60 @@
#!/usr/bin/env bash
# Installa uno dei due strumenti esterni della CI, gli unici approvati da Alberto e solo per la CI (20 ottobre 2026):
# gitleaks (segreti nella storia) e Trivy (vulnerabilità dell'immagine). Versione fissa, archivio scaricato dalla
# release del progetto e installato solo se la sua impronta SHA-256 coincide con quella scritta qui. Le impronte sono
# quelle dei file *_checksums.txt delle release, ricontrollate il 20 ottobre 2026 sull'archivio scaricato e
# sull'impronta che GitHub mostra per l'allegato.
#
# .gitea/scripts/strumento.sh gitleaks|trivy <cartella>
#
# Per aggiornare uno strumento si cambiano versione e impronta insieme, in un commit solo, con una riga in
# docs/decisioni.md. Mai «latest», mai le azioni di terzi (trivy-action fu compromessa a marzo 2026, CVE-2026-33634),
# mai uno script di installazione scaricato al volo.
set -euo pipefail
nome="${1:?Indica lo strumento: gitleaks o trivy.}"
cartella="${2:?Indica la cartella in cui installarlo.}"
case "$nome" in
gitleaks)
versione="8.30.1"
archivio="gitleaks_${versione}_linux_x64.tar.gz"
indirizzo="https://github.com/gitleaks/gitleaks/releases/download/v${versione}/${archivio}"
sha256="551f6fc83ea457d62a0d98237cbad105af8d557003051f41f3e7ca7b3f2470eb"
;;
trivy)
versione="0.75.0"
archivio="trivy_${versione}_Linux-64bit.tar.gz"
indirizzo="https://github.com/aquasecurity/trivy/releases/download/v${versione}/${archivio}"
sha256="c6e65abddb348e25f10549df887045629cf28cc72453cd1c63acb717316b3f3f"
;;
*)
echo "Strumento sconosciuto: «$nome» (gitleaks o trivy)." >&2
exit 2
;;
esac
piattaforma="$(uname -s)-$(uname -m)"
if [[ "$piattaforma" != "Linux-x86_64" ]]; then
echo "Gli archivi fissati qui sono per Linux x86_64, non per $piattaforma." >&2
exit 2
fi
if [[ -x "$cartella/$nome" ]] && [[ -f "$cartella/$nome.sha256" ]] && [[ "$(cat "$cartella/$nome.sha256")" == "$sha256" ]]; then
echo "== $nome $versione già installato in $cartella"
exit 0
fi
temporanea="$(mktemp -d)"
trap 'rm -rf "$temporanea"' EXIT
echo "== $nome $versione"
curl -fsSL --retry 3 --retry-delay 5 --max-time 600 -o "$temporanea/$archivio" "$indirizzo"
if ! echo "$sha256 $temporanea/$archivio" | sha256sum -c --quiet -; then
echo "L'impronta SHA-256 di $archivio non è quella attesa: $nome non si installa." >&2
exit 1
fi
mkdir -p "$cartella"
tar -xzf "$temporanea/$archivio" -C "$cartella" "$nome"
chmod 0755 "$cartella/$nome"
echo "$sha256" > "$cartella/$nome.sha256"
"$cartella/$nome" --version | head -n 1 || true
+37
View File
@@ -0,0 +1,37 @@
# Pulizia settimanale (il lunedì alle 4:17, ora del server di Gitea) e a mano (Actions ▸ pulizia ▸ Esegui) del demone
# Docker del runner.
# Ogni esecuzione di verifica e di rilascio toglie già ciò che crea; qui si toglie ciò che resta di esecuzioni
# interrotte (annullate o scadute) e ciò che invecchia. Il demone è lo stesso di Encelado, Mimante e degli altri
# progetti di Alberto, e ci può girare un Febe vero: si toccano solo i contenitori di prova fermi (etichetta
# febe.ci.prova e nome febe-prova-<esecuzione>, mai le etichette febe.ci.* che un Febe vero eredita dall'immagine), i
# nomi locali febe-ci:<esecuzione>, i builder febe-ci-<esecuzione> e le immagini senza nome più vecchie di 72 ore. Mai
# le immagini degli altri progetti, mai la cache di costruzione del demone, mai i volumi con un nome. Un contenitore di
# prova ancora acceso si segnala e il lavoro diventa rosso. Dettagli in .gitea/scripts/pulizia-docker.sh e in
# docs/processo.md, «Pulizia».
name: pulizia
on:
schedule:
- cron: "17 4 * * 1"
workflow_dispatch:
permissions:
contents: read
concurrency:
group: pulizia
cancel-in-progress: false
defaults:
run:
shell: bash
jobs:
docker:
runs-on: ubuntu-latest
timeout-minutes: 20
steps:
- uses: actions/checkout@v4
- name: Resti della CI di Febe e immagini senza nome
run: bash .gitea/scripts/pulizia-docker.sh settimanale
+55 -18
View File
@@ -3,9 +3,11 @@
# e tutte le prove passano. Senza prove verdi non si costruisce né si rilascia nulla;
# 2. windows: Febe.exe in un file solo, il programma di installazione NSIS e lo zip portabile (installer/costruisci.sh,
# gira su Linux);
# 3. immagine: l'immagine Docker (le prove girano anche dentro la build), pubblicata sul registro dei container di
# Gitea come <registro>/<proprietario>/febe:X.Y.Z e :latest (solo per le versioni senza trattino). Il lavoro dice
# se l'ha pubblicata;
# 3. immagine: dopo l'installatore, l'immagine Docker (le prove girano anche dentro la build), provata senza rete e
# scansionata con Trivy come nella verifica (una CRITICAL con correzione ferma tutto), poi pubblicata sul registro
# dei container di Gitea come <registro>/<proprietario>/febe:X.Y.Z e :latest (solo per le versioni senza
# trattino). Il lavoro dice se l'ha pubblicata, e alla fine toglie sempre immagini, contenitori, cache e builder
# dell'esecuzione;
# 4. release: solo dopo le prove, l'installatore e l'immagine. Crea la release (o la completa, se esiste già) con
# installatore, zip portabile, modello Unraid e l'archivio per Docker Compose (compose.yml con il profilo seccomp
# accanto); le note dicono dove sta l'immagine, o che non è stata pubblicata.
@@ -29,6 +31,7 @@ on:
jobs:
prove:
runs-on: ubuntu-latest
timeout-minutes: 60
steps:
- uses: actions/checkout@v4
@@ -60,6 +63,7 @@ jobs:
windows:
runs-on: ubuntu-latest
needs: prove
timeout-minutes: 30
steps:
- uses: actions/checkout@v4
@@ -89,7 +93,14 @@ jobs:
immagine:
runs-on: ubuntu-latest
needs: prove
# Dopo l'installatore: :X.Y.Z e :latest escono solo se anche la release potrà uscire.
needs: [prove, windows]
timeout-minutes: 60
env:
FLUSSO: rilascio
ESECUZIONE: ${{ gitea.run_id }}
BUILDER: febe-ci-${{ gitea.run_id }}
PROVA: febe-ci:${{ gitea.run_id }}
outputs:
immagine: ${{ steps.nome.outputs.immagine }}
pubblicata: ${{ steps.pubblicazione.outputs.pubblicata }}
@@ -97,6 +108,12 @@ jobs:
steps:
- uses: actions/checkout@v4
# Ciò che un'esecuzione interrotta non ha potuto togliere, e un tentativo precedente di questa stessa esecuzione.
- name: Resti di esecuzioni interrotte
run: |
bash .gitea/scripts/pulizia-docker.sh residui 90
bash .gitea/scripts/pulizia-docker.sh esecuzione "$ESECUZIONE"
- name: Versione, registro e nome dell'immagine
id: nome
run: |
@@ -105,6 +122,9 @@ jobs:
[ -n "$REGISTRY" ] || REGISTRY=$(echo "${{ gitea.server_url }}" | sed -E 's#^https?://##; s#/.*$##')
OWNER=$(echo "${{ gitea.repository_owner }}" | tr '[:upper:]' '[:lower:]')
echo "VERSION=$V" >> "$GITHUB_ENV"
echo "VERSIONE=$V" >> "$GITHUB_ENV"
echo "GIT_COMMIT=${GITHUB_SHA::12}" >> "$GITHUB_ENV"
echo "ARCHIVIO=${RUNNER_TEMP:-/tmp}/febe-$ESECUZIONE.tar" >> "$GITHUB_ENV"
echo "REGISTRY=$REGISTRY" >> "$GITHUB_ENV"
echo "IMAGE=$REGISTRY/$OWNER/febe" >> "$GITHUB_ENV"
echo "registro=$REGISTRY" >> "$GITHUB_OUTPUT"
@@ -113,19 +133,32 @@ jobs:
# Un builder buildx proprio, che sa che il registro di casa risponde in HTTP.
- uses: docker/setup-buildx-action@v3
with:
name: febe-ci-${{ gitea.run_id }}
driver: docker-container
buildkitd-config-inline: |
[registry."${{ steps.nome.outputs.registro }}"]
http = true
insecure = true
# Gli stessi argomenti ed etichette della pubblicazione (costruisci-immagine.sh): quella esce dalla cache di questa.
- name: Costruzione dell'immagine (le prove girano dentro la build)
run: |
docker buildx build -f docker/Dockerfile \
--build-arg VERSION="$VERSION" \
--build-arg GIT_COMMIT="${GITHUB_SHA::12}" \
-t "$IMAGE:$VERSION" --load .
docker run --rm --entrypoint /usr/bin/chromium "$IMAGE:$VERSION" --version
bash .gitea/scripts/costruisci-immagine.sh archivio "$ARCHIVIO" "$PROVA"
docker load -i "$ARCHIVIO"
- name: Prova del contenitore, senza rete
run: bash .gitea/scripts/prova-immagine.sh "$PROVA" "$ESECUZIONE"
- name: Vulnerabilità dell'immagine (Trivy)
run: bash .gitea/scripts/scansione-immagine.sh "$ARCHIVIO" out/sicurezza
- name: Rapporto di Trivy
if: ${{ !cancelled() }}
uses: actions/upload-artifact@v3
with:
name: sicurezza-immagine
path: out/sicurezza/trivy.json
if-no-files-found: ignore
- name: Segreto per il registro
id: segreto
@@ -156,16 +189,13 @@ jobs:
AUTH=$(printf '%s:%s' "$UTENTE" "$TOKEN" | base64 -w0)
jq --arg r "$REGISTRY" --arg a "$AUTH" '.auths[$r].auth = $a' "$CONFIG/config.json" > "$CONFIG/config.json.nuovo"
mv "$CONFIG/config.json.nuovo" "$CONFIG/config.json"
TAGS="-t $IMAGE:$VERSION"
NOMI="$IMAGE:$VERSION"
case "$VERSION" in
*-*) echo "Versione di anteprima: :latest non si sposta." ;;
*) TAGS="$TAGS -t $IMAGE:latest" ;;
*) NOMI="$NOMI $IMAGE:latest" ;;
esac
# La stessa costruzione di prima (dalla cache del builder), questa volta spinta sul registro.
docker buildx build -f docker/Dockerfile \
--build-arg VERSION="$VERSION" \
--build-arg GIT_COMMIT="${GITHUB_SHA::12}" \
$TAGS --push .
# La stessa costruzione di prima (dalla cache del builder), questa volta spinta sul registro da buildx.
bash .gitea/scripts/costruisci-immagine.sh pubblica $NOMI
echo "pubblicata=si" >> "$GITHUB_OUTPUT"
- name: Credenziali tolte
@@ -176,12 +206,19 @@ jobs:
jq --arg r "$REGISTRY" 'if .auths then .auths |= del(.[$r]) else . end' "$CONFIG" > "$CONFIG.nuovo" && mv "$CONFIG.nuovo" "$CONFIG"
fi
- name: Pulizia (sempre)
if: always()
run: |
if [ -n "${ARCHIVIO:-}" ]; then rm -f "$ARCHIVIO"; fi
bash .gitea/scripts/pulizia-docker.sh esecuzione "$ESECUZIONE"
release:
runs-on: ubuntu-latest
# Le prove sono verdi, l'installatore c'è e l'immagine si è costruita: pubblicata, o non pubblicata per la sola
# mancanza del segreto (il lavoro «immagine» lo dice e le note lo riportano). Se la costruzione o la spinta sul
# registro falliscono, non esce nessuna release.
# mancanza del segreto (il lavoro «immagine» lo dice e le note lo riportano). Se la costruzione, la prova del
# contenitore, la scansione o la spinta sul registro falliscono, non esce nessuna release.
needs: [prove, windows, immagine]
timeout-minutes: 15
steps:
- uses: actions/checkout@v4
+282 -28
View File
@@ -1,18 +1,154 @@
# Verifica a ogni push e a ogni pull request: compilazione con gli avvisi come errori
# (compreso Febe.Desktop, che si compila anche da Linux) e tutte le prove.
# Le prove che richiedono Chromium e Xvfb si saltano da sole se il runner non li ha.
# Verifica: a ogni push su qualunque ramo (i tag li prende rilascio.yml) e a mano (Actions ▸ verifica ▸ Esegui).
# I suoi quattro lavori sono i controlli richiesti per unire in main (docs/processo.md):
# controlli sintassi degli script, flussi senza tabulazioni, segni di conflitto, versione, progetti della
# soluzione, JSON; segreti in tutta la storia con gitleaks (versione e impronta fissate);
# prove compilazione di tutta la soluzione con gli avvisi come errori e tutte le prove di tests/Febe.Tests
# (mai «dotnet test» sulla soluzione intera: tests/Febe.Tests.Windows gira solo su Windows) con
# Chromium, Xvfb, ffmpeg, NSIS e Node veri in un contenitore Debian 13: nessuna prova deve saltarsi.
# Il mondo sintetico del sito di prova ha il seme 13 e, per la categoria SitoDiProva, anche il seme di
# questa esecuzione, scritto nel registro per rifare un errore;
# installatore Febe-Setup-<versione>-ci.<numero>.exe e lo zip portabile, artefatti per 14 giorni;
# immagine dopo l'installatore: l'immagine Docker costruita con buildx, provata senza rete (parte, salute,
# Chromium, it_IT) e scansionata con Trivy (si ferma per una CRITICAL con correzione); solo dopo un push
# su main la pubblica come :main e :sha-<7 caratteri> (:latest resta al rilascio). Alla fine, sempre,
# toglie immagini, contenitori, cache e builder di questa esecuzione.
#
# Runner: act_runner con l'etichetta ubuntu-latest.
# Niente «pull_request»: in Gitea una richiesta di unione mostra lo stato del suo ultimo commit, che il push del ramo
# ha già verificato; pull_request rifarebbe tutto sullo stesso commit (refs/pull/N/head) sull'unico runner.
# Runner: act_runner con l'etichetta ubuntu-latest, un lavoro alla volta. I lavori parlano con il demone Docker del
# server, lo stesso di Encelado, Mimante e degli altri progetti: niente montaggi della cartella del lavoro in altri
# contenitori (sul server i percorsi sono diversi); le immagini passano come archivi e contesti di costruzione.
# Che cosa di Gitea 28 si usa e perché: docs/decisioni.md (20 ottobre 2026) e docs/processo.md.
name: verifica
on:
push:
branches: [main, febe-v1]
pull_request:
branches: ["**"]
workflow_dispatch:
inputs:
seme:
description: "Seme del mondo sintetico per la seconda passata delle prove (vuoto: 1000 più il numero dell'esecuzione)"
required: false
default: ""
permissions:
contents: read
# Su un ramo conta l'ultimo push: l'esecuzione precedente si annulla. Su main ogni commit ha il suo gruppo, così ogni
# unione arriva fino in fondo e pubblica la sua :sha-. L'evento fa parte del gruppo: un'esecuzione a mano non annulla
# mai quella di un push, che è l'unica a scrivere gli stati del commit richiesti per unire (un lavoro annullato lascia
# lo stato «failure», e workflow_dispatch non ne scrive).
concurrency:
group: verifica-${{ gitea.event_name }}-${{ gitea.ref }}${{ gitea.ref == 'refs/heads/main' && format('-{0}', gitea.sha) || '' }}
cancel-in-progress: ${{ gitea.ref != 'refs/heads/main' }}
defaults:
run:
shell: bash
env:
DOTNET_NOLOGO: "1"
DOTNET_CLI_TELEMETRY_OPTOUT: "1"
DOTNET_SKIP_FIRST_TIME_EXPERIENCE: "1"
jobs:
prove:
controlli:
runs-on: ubuntu-latest
timeout-minutes: 10
steps:
# Tutta la storia: gitleaks legge ogni commit da cui discende quello verificato.
- uses: actions/checkout@v4
with:
fetch-depth: 0
- name: Script, flussi, conflitti, versione, soluzione e JSON
run: bash .gitea/scripts/controlli.sh
- name: Segreti in tutta la storia (gitleaks)
run: bash .gitea/scripts/segreti.sh out/sicurezza
- name: Rapporto di gitleaks (segreti oscurati)
if: failure()
uses: actions/upload-artifact@v3
with:
name: rapporto-gitleaks
path: out/sicurezza/gitleaks.json
retention-days: 14
if-no-files-found: ignore
prove:
needs: controlli
runs-on: ubuntu-latest
timeout-minutes: 60
# Debian 13 con Node 24: Chromium vero della distribuzione, come nell'immagine di Febe (su Ubuntu è uno snap), e
# Node per le azioni e per la prova della pagina di accesso.
# Memoria condivisa più ampia dei 64 MB predefiniti: le prove dell'interfaccia usano un Chromium senza finestra.
container:
image: node:24-trixie
options: --shm-size=1g
env:
FEBE_CHROMIUM: /usr/bin/chromium
SEME_RICHIESTO: ${{ gitea.event.inputs.seme }}
NUMERO: ${{ gitea.run_number }}
steps:
- uses: actions/checkout@v4
# Prima di tutto, così un seme chiesto a mano e sbagliato ferma subito il lavoro.
- name: Semi del mondo sintetico
id: semi
run: |
seme="${SEME_RICHIESTO:-}"
[ -n "$seme" ] || seme=$((1000 + ${NUMERO:-0}))
if ! [[ "$seme" =~ ^-?[0-9]{1,9}$ ]]; then
echo "Seme non valido: «$seme» (serve un intero di al massimo nove cifre)." >&2
exit 1
fi
echo "seme=$seme" >> "$GITHUB_OUTPUT"
echo "Mondo sintetico: seme 13 per tutte le prove, seme $seme per la seconda passata (categoria SitoDiProva)."
echo "Per rifarla: FEBE_SEME_PROVA=$seme dotnet test tests/Febe.Tests --filter \"TestCategory=SitoDiProva\""
- name: Chromium, Xvfb, ffmpeg, NSIS e lingua italiana
run: bash .gitea/scripts/ambiente-prove.sh
- uses: actions/setup-dotnet@v4
with:
dotnet-version: "10.0.x"
- name: Compilazione di tutta la soluzione (avvisi = errori)
run: dotnet build Febe.slnx -c Release -nologo -warnaserror
- name: Prove, seme 13
run: >-
dotnet test tests/Febe.Tests -c Release --no-build --nologo
--logger "trx;LogFileName=prove-seme-13.trx" --results-directory out/prove
- name: Prove del sito di prova, seme dell'esecuzione
if: ${{ !cancelled() && steps.semi.outputs.seme != '' }}
env:
FEBE_SEME_PROVA: ${{ steps.semi.outputs.seme }}
run: >-
dotnet test tests/Febe.Tests -c Release --no-build --nologo --filter "TestCategory=SitoDiProva"
--logger "trx;LogFileName=prove-seme-$FEBE_SEME_PROVA.trx" --results-directory out/prove
- name: Riepilogo delle prove
if: ${{ !cancelled() }}
run: bash .gitea/scripts/riepilogo-prove.sh out/prove 0
- name: Risultati delle prove
if: ${{ !cancelled() }}
uses: actions/upload-artifact@v3
with:
name: risultati-prove
path: out/prove/*.trx
retention-days: 14
if-no-files-found: warn
installatore:
needs: prove
runs-on: ubuntu-latest
timeout-minutes: 30
env:
NUMERO: ${{ gitea.run_number }}
steps:
- uses: actions/checkout@v4
@@ -20,37 +156,155 @@ jobs:
with:
dotnet-version: "10.0.x"
- name: Compilazione (avvisi = errori)
run: dotnet build Febe.slnx -c Release -nologo -warnaserror
- name: NSIS e zip
run: |
SUDO=""; [ "$(id -u)" = 0 ] || SUDO=sudo
$SUDO apt-get update -qq
$SUDO apt-get install -y -qq nsis zip > /dev/null
- name: Prove
run: >-
dotnet test tests/Febe.Tests -c Release --no-build --nologo
--logger "trx;LogFileName=prove.trx" --results-directory out/prove
- name: Febe.exe, programma di installazione e zip portabile (versione di prova)
run: |
V=$(sed -n 's:.*<Version>\(.*\)</Version>.*:\1:p' Directory.Build.props | head -n 1)
echo "Versione di questa esecuzione: $V-ci.$NUMERO"
bash installer/costruisci.sh "$V-ci.$NUMERO"
- name: Risultati
if: always()
- name: Artefatti per Windows
uses: actions/upload-artifact@v3
with:
name: risultati-prove
path: out/prove/*.trx
if-no-files-found: ignore
name: windows
path: |
out/Febe-Setup-*.exe
out/Febe-*-portabile.zip
retention-days: 14
if-no-files-found: error
# Dopo l'installatore, non solo dopo le prove: :main e :sha- escono solo da un commit con tutta la verifica verde.
# Sull'unico runner i lavori vanno comunque uno alla volta, quindi la durata non cambia.
immagine:
needs: [prove, installatore]
runs-on: ubuntu-latest
needs: prove
timeout-minutes: 60
env:
FLUSSO: verifica
ESECUZIONE: ${{ gitea.run_id }}
NUMERO: ${{ gitea.run_number }}
BUILDER: febe-ci-${{ gitea.run_id }}
PROVA: febe-ci:${{ gitea.run_id }}
steps:
- uses: actions/checkout@v4
- name: Costruzione dell'immagine Docker (senza pubblicarla; le prove girano anche dentro la build)
# Ciò che un'esecuzione interrotta (annullata, scaduta) non ha potuto togliere, e un tentativo precedente di
# questa stessa esecuzione.
- name: Resti di esecuzioni interrotte
run: |
docker version
docker build -f docker/Dockerfile \
--build-arg VERSION=ci \
--build-arg GIT_COMMIT="${GITHUB_SHA::12}" \
-t febe:ci .
bash .gitea/scripts/pulizia-docker.sh residui 90
bash .gitea/scripts/pulizia-docker.sh esecuzione "$ESECUZIONE"
- name: L'immagine parte e mostra la pagina di errore senza password
# Registro: la variabile REGISTRY delle Actions, se c'è, altrimenti l'host dell'indirizzo del server (ROOT_URL).
- name: Versione, registro e nomi
id: nome
env:
REGISTRO_SCELTO: ${{ vars.REGISTRY }}
SERVER: ${{ gitea.server_url }}
PROPRIETARIO: ${{ gitea.repository_owner }}
run: |
docker run --rm --entrypoint /usr/bin/chromium febe:ci --version
docker run --rm --entrypoint sh febe:ci -c 'locale -a | grep -i it_IT && ls /etc/chromium/policies/managed/'
V=$(sed -n 's:.*<Version>\(.*\)</Version>.*:\1:p' Directory.Build.props | head -n 1)
REGISTRY="$REGISTRO_SCELTO"
[ -n "$REGISTRY" ] || REGISTRY=$(echo "$SERVER" | sed -E 's#^https?://##; s#/.*$##')
OWNER=$(echo "$PROPRIETARIO" | tr '[:upper:]' '[:lower:]')
{
echo "VERSIONE=$V-ci.$NUMERO"
echo "GIT_COMMIT=${GITHUB_SHA::12}"
echo "REGISTRY=$REGISTRY"
echo "IMAGE=$REGISTRY/$OWNER/febe"
echo "ARCHIVIO=${RUNNER_TEMP:-/tmp}/febe-$ESECUZIONE.tar"
} >> "$GITHUB_ENV"
echo "registro=$REGISTRY" >> "$GITHUB_OUTPUT"
echo "Immagine $V-ci.$NUMERO del commit ${GITHUB_SHA::12}, provata come $PROVA; registro $REGISTRY/$OWNER/febe"
# Un builder buildx di questa esecuzione (con la sua cache), che sa che il registro di casa risponde in HTTP.
- name: Builder buildx dell'esecuzione
uses: docker/setup-buildx-action@v3
with:
name: febe-ci-${{ gitea.run_id }}
driver: docker-container
buildkitd-config-inline: |
[registry."${{ steps.nome.outputs.registro }}"]
http = true
insecure = true
- name: Costruzione dell'immagine (dentro girano compilazione e prove)
run: |
bash .gitea/scripts/costruisci-immagine.sh archivio "$ARCHIVIO" "$PROVA"
docker load -i "$ARCHIVIO"
- name: Prova del contenitore, senza rete
run: bash .gitea/scripts/prova-immagine.sh "$PROVA" "$ESECUZIONE"
- name: Vulnerabilità dell'immagine (Trivy)
run: bash .gitea/scripts/scansione-immagine.sh "$ARCHIVIO" out/sicurezza
- name: Rapporto di Trivy
if: ${{ !cancelled() }}
uses: actions/upload-artifact@v3
with:
name: sicurezza-immagine
path: out/sicurezza/trivy.json
retention-days: 14
if-no-files-found: ignore
- name: Pubblicare?
id: segreto
env:
TOKEN: ${{ secrets.REGISTRY_TOKEN }}
EVENTO: ${{ gitea.event_name }}
RIFERIMENTO: ${{ gitea.ref }}
run: |
if [ "$EVENTO" != push ] || [ "$RIFERIMENTO" != refs/heads/main ]; then
echo "Si pubblica solo dopo un push su main: qui l'immagine è costruita, provata e scansionata."
echo "presente=no" >> "$GITHUB_OUTPUT"
elif [ -z "$TOKEN" ]; then
echo "::warning::Manca il segreto REGISTRY_TOKEN: l'immagine di main è costruita, provata e scansionata ma non pubblicata. Aggiungilo (token con package: read and write) e rilancia la verifica di questo commit."
echo "presente=no" >> "$GITHUB_OUTPUT"
else
echo "presente=si" >> "$GITHUB_OUTPUT"
fi
- name: Pubblicazione come :main e :sha-<commit>
if: steps.segreto.outputs.presente == 'si'
env:
TOKEN: ${{ secrets.REGISTRY_TOKEN }}
UTENTE: ${{ gitea.actor }}
run: |
# Le credenziali vanno nella configurazione del client: buildx le passa al builder, il demone non c'entra (e
# proverebbe HTTPS). Non si stampano mai.
CONFIG="${DOCKER_CONFIG:-$HOME/.docker}"
mkdir -p "$CONFIG"
[ -s "$CONFIG/config.json" ] || echo '{}' > "$CONFIG/config.json"
AUTH=$(printf '%s:%s' "$UTENTE" "$TOKEN" | base64 -w0)
jq --arg r "$REGISTRY" --arg a "$AUTH" '.auths[$r].auth = $a' "$CONFIG/config.json" > "$CONFIG/config.json.nuovo"
mv "$CONFIG/config.json.nuovo" "$CONFIG/config.json"
NOMI=("$IMAGE:sha-${GITHUB_SHA::7}")
# :main solo se main è ancora a questo commit: un'esecuzione arrivata in ritardo non lo riporta indietro.
# Il passo gira con «bash -e -o pipefail»: senza «|| CIMA=""» un errore di ls-remote chiuderebbe il passo
# prima dell'avviso, e non uscirebbe nemmeno la :sha-.
CIMA=$(git ls-remote origin refs/heads/main 2> /dev/null | cut -f1) || CIMA=""
if [ "$CIMA" = "$GITHUB_SHA" ]; then
NOMI+=("$IMAGE:main")
elif [ -z "$CIMA" ]; then
echo "::warning::Non riesco a leggere la cima di main: si pubblica solo :sha-${GITHUB_SHA::7} e :main resta dov'è."
else
echo "main è già andato avanti (${CIMA::7}): si pubblica solo :sha-${GITHUB_SHA::7}."
fi
bash .gitea/scripts/costruisci-immagine.sh pubblica "${NOMI[@]}"
- name: Pulizia (sempre)
if: always()
run: |
CONFIG="${DOCKER_CONFIG:-$HOME/.docker}/config.json"
if [ -s "$CONFIG" ] && [ -n "${REGISTRY:-}" ]; then
jq --arg r "$REGISTRY" 'if .auths then .auths |= del(.[$r]) else . end' "$CONFIG" > "$CONFIG.nuovo" \
&& mv "$CONFIG.nuovo" "$CONFIG" || echo "::warning::Non riesco a togliere le credenziali da $CONFIG."
fi
if [ -n "${ARCHIVIO:-}" ]; then rm -f "$ARCHIVIO"; fi
bash .gitea/scripts/pulizia-docker.sh esecuzione "$ESECUZIONE"
+6 -1
View File
@@ -38,6 +38,11 @@ Conserva: tappa in corso, file modificati, controlli ancora da eseguire, domande
## Repository e rilascio
- Repository: Gitea di casa, https://gitea.encke-hake.ts.net/Alby96/Febe (ramo main). Non è GitHub: niente strumenti GitHub.
- CI in `.gitea/workflows/`: `verifica.yml` a ogni push e pull request, `rilascio.yml` a ogni tag `vX.Y.Z` (immagine Docker sul registro di Gitea, installatore Windows e release).
- Processo (rami `<tipo>/<argomento>`, commit piccoli, una richiesta di unione per ramo, verifica verde per unire in main, commit di unione, rilasci, correzioni urgenti): docs/processo.md.
- CI in `.gitea/workflows/`, script comuni in `.gitea/scripts/`:
- `verifica.yml` a ogni push su qualunque ramo (non sui tag) e a mano, niente pull_request: controlli e gitleaks; compilazione di tutta la soluzione e tutte le prove di `tests/Febe.Tests` con Chromium, Xvfb, ffmpeg e NSIS veri in Debian, nessuna saltata, anche con il seme dell'esecuzione (`FEBE_SEME_PROVA`); installatore e zip `-ci.<numero>`; immagine provata senza rete e scansionata con Trivy. Dopo un push su main pubblica `:main` e `:sha-<commit>` (con il segreto `REGISTRY_TOKEN`; senza, un avviso).
- `rilascio.yml` a ogni tag `vX.Y.Z`: immagine `:X.Y.Z` (e `:latest`) sul registro di Gitea, installatore Windows e release.
- `pulizia.yml` ogni lunedì: solo i resti della CI di Febe sul demone Docker condiviso.
- Le prove nella CI passano solo da `tests/Febe.Tests`, mai `dotnet test` sulla soluzione intera.
- La versione sta solo in `Directory.Build.props` (`<Version>`); il tag deve coincidere.
- Guida per l'uso: wiki del repository (sorgenti in `docs/guida/`).
+20 -13
View File
@@ -7,7 +7,10 @@
# -t 192.168.30.23:3000/alby96/febe:0.1.0 .
#
# Stadi:
# build restore e compilazione di tutta la soluzione con gli avvisi come errori;
# progetti solo i file che il restore legge (soluzione, props, progetti), trovati da soli: un progetto nuovo in
# Febe.slnx non chiede di cambiare questo file;
# build restore (in cache finché quei file non cambiano) e compilazione di tutta la soluzione con gli avvisi come
# errori;
# test tutte le prove: un'immagine con prove rosse non esiste. Qui non ci sono Chromium né Xvfb, quindi le prove
# con il browser vero risultano «inconcludenti» (saltate) e girano solo dove ci sono (CI, sviluppo);
# publish Febe.Server autosufficiente per linux-x64: nell'immagine non serve il runtime .NET;
@@ -18,24 +21,25 @@
ARG DOTNET_VERSION=10.0
# ─────────────────────────────────────────────────────────────── progetti
# I file che il restore legge, ciascuno nella sua cartella. Questo stadio rigira a ogni modifica, ma il suo risultato
# cambia solo con loro: la copia nello stadio build, e quindi il restore, restano in cache (BuildKit confronta il
# contenuto). Un progetto aggiunto a Febe.slnx (per esempio tests/Febe.Tests.Windows) arriva qui senza toccare il file.
FROM mcr.microsoft.com/dotnet/sdk:${DOTNET_VERSION} AS progetti
WORKDIR /src
COPY . .
RUN mkdir -p /progetti \
&& find . -type f \( -name '*.slnx' -o -name '*.csproj' -o -name 'Directory.*.props' -o -name 'Directory.*.targets' \
-o -iname 'nuget.config' -o -name 'global.json' \) -exec cp --parents '{}' /progetti/ ';' \
&& test -f /progetti/Febe.slnx
# ─────────────────────────────────────────────────────────────── build
FROM mcr.microsoft.com/dotnet/sdk:${DOTNET_VERSION} AS build
WORKDIR /src
ENV DOTNET_NOLOGO=1 DOTNET_CLI_TELEMETRY_OPTOUT=1
# Prima i file di progetto: il restore resta in cache finché non cambiano.
COPY Directory.Build.props Directory.Packages.props Febe.slnx ./
COPY src/Febe.Core/Febe.Core.csproj src/Febe.Core/
COPY src/Febe.Data/Febe.Data.csproj src/Febe.Data/
COPY src/Febe.Browser/Febe.Browser.csproj src/Febe.Browser/
COPY src/Febe.Web/Febe.Web.csproj src/Febe.Web/
COPY src/Febe.App/Febe.App.csproj src/Febe.App/
COPY src/Febe.Server/Febe.Server.csproj src/Febe.Server/
COPY src/Febe.Desktop.Core/Febe.Desktop.Core.csproj src/Febe.Desktop.Core/
COPY src/Febe.Desktop/Febe.Desktop.csproj src/Febe.Desktop/
COPY tests/Febe.Tests/Febe.Tests.csproj tests/Febe.Tests/
COPY tools/Febe.Sonda/Febe.Sonda.csproj tools/Febe.Sonda/
COPY tools/Febe.SitoDiProva/Febe.SitoDiProva.csproj tools/Febe.SitoDiProva/
COPY --from=progetti /progetti/ ./
RUN dotnet restore Febe.slnx \
&& dotnet restore src/Febe.Server/Febe.Server.csproj -r linux-x64
@@ -73,8 +77,11 @@ LABEL org.opencontainers.image.title="Febe" \
# Chromium della distribuzione con le sue lingue, il display virtuale, ffmpeg (miniature dei video importati), ICU e
# le librerie del runtime .NET autosufficiente, caratteri di sistema con le emoji, certificati, fusi orari, la lingua
# italiana generata, tini come processo 1 (raccoglie i processi di Chromium), setpriv (util-linux) per PUID/PGID.
# Prima gli aggiornamenti di sicurezza della distribuzione già pubblicati, anche quelli arrivati dopo l'immagine di
# base: la scansione della CI non deve trovare correzioni disponibili e non applicate.
ENV DEBIAN_FRONTEND=noninteractive
RUN apt-get update \
&& apt-get upgrade -y --no-install-recommends \
&& apt-get install -y --no-install-recommends \
chromium chromium-l10n \
xvfb \
+18
View File
@@ -226,3 +226,21 @@ Ogni scelta tecnica presa strada facendo, con data e motivo (specifica §15).
| 2026-10-13 | Prove dell'interfaccia in un Chromium senza finestra guidato col protocollo DevTools diretto (`UiBrowser`, solo 127.0.0.1), inconcludenti senza Chromium | Come `tools/schermate`; il client CDP di Febe accetta solo letture |
| 2026-10-14 | Revisione avversaria di tutto il codice (7 aree, ogni rilievo verificato da un secondo revisore indipendente): 54 rilievi confermati e corretti con prove di regressione, 2 smentiti, 3 incerti corretti dove il rimedio era sicuro | §14, regola 14: resoconti onesti |
| 2026-10-14 | Restano noti e accettati: «Tieni il più grande» scrive con il proprio SafeFileWriter e non passa dal lucchetto per account di `LibraryIngest` (un'importazione e uno scaricamento con gli stessi byte nello stesso istante potrebbero entrare entrambi); le prove d'interfaccia con browser vero aspettano fino a 30 s | Finestra rarissima, nessuna perdita di dati: al più un doppione esatto da togliere a mano |
| 2026-10-20 | Il seme del mondo sintetico del sito di prova si sceglie con la variabile `FEBE_SEME_PROVA` (13 se manca), letta da `SyntheticSite` (`tests/Febe.Tests/Support`), l'unico modo in cui le prove avviano il sito; le classi che lo avviano stanno nella categoria `SitoDiProva`, e una prova controlla che nessuna lo avvii per altre vie o resti fuori dalla categoria. `SyntheticSiteSeedTests` controlla senza browser, per 300 semi, la forma del mondo su cui contano le prove d'insieme e i lettori sulle pagine servite | La CI rifà quelle prove con un seme diverso a ogni esecuzione, scritto nel registro, senza raddoppiare la durata di tutta la suite; senza la variabile non cambia nulla; un errore si rifà con lo stesso seme |
| 2026-10-20 | Dockerfile: i file che il restore legge (soluzione, `Directory.*.props`, progetti) si trovano da soli in uno stadio `progetti` invece che da un elenco scritto a mano; lo stadio finale applica gli aggiornamenti della distribuzione (`apt-get upgrade`) prima di installare i pacchetti | Un progetto nuovo in `Febe.slnx` (come `tests/Febe.Tests.Windows`) non rompe più la costruzione dell'immagine e il restore resta in cache (BuildKit confronta il contenuto copiato); la scansione Trivy della CI non deve trovare correzioni di Debian già pubblicate ma non applicate perché l'immagine di base è più vecchia |
| 2026-10-20 | Codice comune della CI in script di `.gitea/scripts/` (lanciati con `bash`), non in azioni composite locali | Uno script si prova con `bash -n` nel lavoro «controlli» e si lancia anche a mano; le azioni composite di act hanno comportamenti propri (ambiente, `if`, passi finali) che qui non si possono provare prima della prima esecuzione vera |
| 2026-10-20 | Strumenti esterni della CI: solo gitleaks 8.30.1 e Trivy 0.75.0 (approvati da Alberto il 20 ottobre, solo nella CI), scaricati dalle release come binari e installati solo se l'impronta SHA-256 scritta in `strumento.sh` coincide (verificata sull'archivio, sul file `*_checksums.txt` e sull'impronta mostrata da GitHub); nessuna azione di terzi per eseguirli | `trivy-action` e `setup-trivy` furono compromesse a marzo 2026 (CVE-2026-33634, Trivy 0.69.4–0.69.6): un'etichetta si sposta, un'impronta no. Trivy 0.75.0 e non 0.76.0: almeno due settimane di vita prima di entrare nella CI |
| 2026-10-20 | gitleaks su tutta la storia del commit verificato (`fetch-depth: 0`, ogni commit da cui discende; ogni ramo si controlla al suo push, così il rilievo di un ramo non blocca gli altri) con `--redact`; nessun `.gitleaks.toml` né elenco di eccezioni per ora: un'approssimazione locale delle 221 regole predefinite (le espressioni regolari pubblicate, applicate da uno script nostro: gitleaks non gira fuori dalla CI) non ha trovato rilievi veri, e i gettoni finti delle prove non hanno la forma completa che le regole cercano | Un falso allarme futuro si toglie con la sua impronta in `.gitleaksignore` e un commento accanto, mai disattivando una regola; un segreto vero si revoca prima di tutto (`docs/processo.md`) |
| 2026-10-20 | Trivy sull'archivio dell'immagine provata (non dal demone): una vulnerabilità CRITICAL con correzione disponibile ferma il lavoro, le HIGH (e le CRITICAL senza correzione) si riportano nel registro e in `trivy.json` (artefatto di 14 giorni); eccezioni solo in `.trivyignore`, con motivo scritto e scadenza `exp:` | La regola chiesta da Alberto; scansionare l'archivio vuol dire scansionare proprio l'immagine provata, senza dipendere dal socket del demone |
| 2026-10-20 | La prova del contenitore (`prova-immagine.sh`) gira sempre con `--network none`: Chromium, criteri, lingua, poi l'avvio come da guida (profilo seccomp, password casuale passata solo nell'ambiente del client) fino a «healthy», `febe --controllo-salute` e l'arresto entro 30 secondi | Regola 1: un'immagine appena costruita non deve poter raggiungere Instagram nemmeno per sbaglio; il controllo di salute passa dalla rete interna del contenitore |
| 2026-10-20 | Le etichette `febe.ci.workflow`, `febe.ci.run`, `febe.ci.ref`, `febe.ci.commit` dell'immagine dicono solo da dove viene; `pulizia-docker.sh` sceglie che cosa togliere da segni che nessuna immagine porta: contenitori di prova con l'etichetta `febe.ci.prova=<esecuzione>` (messa solo da `docker run --label` in `prova-immagine.sh`) e il nome esatto `febe-prova-<esecuzione>`; immagini solo per il nome locale `febe-ci:<esecuzione>`, mai per identificativo né con `-f`; builder per nome esatto e immagine `moby/buildkit`. Alla fine di ogni lavoro tutto ciò dell'esecuzione; all'inizio del lavoro successivo e ogni settimana i resti più vecchi di 90 minuti, ma dei contenitori di prova solo quelli fermi (uno acceso si segnala); più le immagini senza nome oltre 72 ore. Mai `system prune`, `builder prune`, `volume prune`. `PipelineTests` fa girare la pulizia contro un client Docker finto con un Febe vero acceso e uno fermo | Docker copia le etichette dell'immagine in ogni contenitore: un Febe vero avviato da `:main`, `:X.Y.Z` o `:latest` sullo stesso demone porta `febe.ci.run`, e un rilascio rilanciato ha lo stesso numero di esecuzione dell'immagine pubblicata (rilievo bloccante della revisione). Il demone è lo stesso di Encelado, Mimante e degli altri progetti; un lavoro dura al massimo 60 minuti, quindi un resto di 90 minuti è orfano; i builder sono sempre accesi e la loro cache se ne va solo con il contenitore |
| 2026-10-20 | `verifica` a ogni push su qualunque ramo (`branches: ["**"]`, quindi mai sui tag) e a mano (`workflow_dispatch`, con un seme facoltativo); niente `pull_request` | In Gitea i controlli di una richiesta di unione sono gli stati del suo ultimo commit, che il push del ramo ha già verificato; `pull_request` girerebbe sullo stesso commit (`refs/pull/N/head`, non un'unione di prova) e sull'unico runner raddoppierebbe tutto. Niente richieste da fork: un solo autore, rami nello stesso repository |
| 2026-10-20 | Concorrenza di `verifica`: il gruppo comprende l'evento e il ramo; su un ramo l'esecuzione nuova annulla quella in corso dello stesso evento; su main ogni commit ha il suo gruppo e nessuna si annulla; `:main` si sposta solo se main è ancora a quel commit, e se la cima di main non si legge si pubblica solo `:sha-` con un avviso | Il runner fa un lavoro alla volta; ogni unione in main deve arrivare a pubblicare la sua `:sha-`, e un'esecuzione in ritardo non deve riportare indietro `:main`. Con l'evento nel gruppo un'esecuzione a mano non annulla quella del push: in Gitea un lavoro annullato lascia lo stato «failure» e `workflow_dispatch` non scrive stati, quindi la richiesta di unione resterebbe bloccata. Gitea 28 valuta le espressioni di `concurrency.group` e `cancel-in-progress` (`services/actions/concurrency.go`) |
| 2026-10-20 | Lavoro «prove» nel contenitore `node:24-trixie` (Debian 13 con Node 24), con Chromium, Xvfb, ffmpeg, NSIS e la lingua italiana installati a ogni esecuzione; il riepilogo non ammette prove saltate; seconda passata della categoria `SitoDiProva` con il seme 1000 + numero dell'esecuzione, o quello chiesto a mano | Su Ubuntu Chromium è uno snap; le azioni JavaScript girano dentro il contenitore del lavoro e vogliono Node; un'immagine di CI costruita da noi non può fare da contenitore del lavoro, perché act_runner la scaricherebbe da un registro e quello di casa è in HTTP; nella CI una prova saltata vuol dire un ambiente rotto, non una prova superata |
| 2026-10-20 | Installatore di ogni esecuzione con versione `<Version>-ci.<numero>` e immagine con etichetta `org.opencontainers.image.version` uguale; dopo ogni unione in main l'immagine va sul registro come `:main` e `:sha-<7 caratteri>`, mai `:latest`, che resta del rilascio | Decisione di Alberto del 20 ottobre; la versione di prova non si confonde con una versione rilasciata e `installer/costruisci.sh` la accetta già |
| 2026-10-20 | Artefatti con `actions/upload-artifact@v3` e `retention-days: 14` (risultati delle prove, installatore e zip, rapporti di sicurezza) | La v4 rifiuta di girare dove il server non è github.com (prende Gitea per GHES) e la sua copia per Gitea sarebbe un'azione nuova, non approvata; il backend v3 di Gitea 28 rispetta `retentionDays` (`routers/api/actions/artifacts.go`) |
| 2026-10-20 | `permissions: contents: read` in `verifica` e `pulizia`; i riepiloghi delle prove e di Trivy vanno nel registro e anche in `GITHUB_STEP_SUMMARY` | Gitea 28 applica `permissions` al gettone del lavoro (docs.gitea.com, «Actions job token permissions»), che così non può scrivere nel repository; i riepiloghi dei lavori esistono da Gitea 1.27 ma compaiono solo se il runner li carica, quindi il registro resta la fonte |
| 2026-10-20 | Ciò che la CI usa di Gitea 28 e di act_runner: `concurrency` con espressioni, `timeout-minutes` dei lavori (lo applica il runner), `workflow_dispatch` con `inputs`, `schedule`, `defaults.run.shell`, `container` del lavoro, contesti `gitea.*`, `vars` e `secrets`; gli stati dei commit si chiamano «verifica / <lavoro> (push)» (`modules/actions/workflows.go`) e solo push, pull_request e release ne creano | Controllato sul codice di Gitea `release/v28` e su docs.gitea.com il 20 ottobre 2026; ciò che solo la prima esecuzione vera può provare è in `docs/processo.md` |
| 2026-10-20 | Processo in `docs/processo.md`: rami `<tipo>/<argomento>` da `main`, commit piccoli in italiano, una richiesta di unione per ramo con il modello di `.gitea/` (comprese le 14 regole di §2), unione con commit di unione e ramo cancellato; `main` protetto con i quattro lavori di `verifica` come controlli richiesti e «blocca se indietro»; tag `v*` protetti; Alberto proprietario di tutto (`CODEOWNERS`) | Decisione di Alberto del 20 ottobre (processo da grande azienda); con il ramo aggiornato il commit di unione ha lo stesso contenuto del commit verificato, quindi in `main` entra solo codice provato. Le approvazioni richieste dipendono da chi apre le richieste (Gitea non conta quella dell'autore): domanda aperta per Alberto |
| 2026-10-20 | Nella verifica il lavoro «immagine» viene dopo «prove» e «installatore» (`needs: [prove, installatore]`) | `:main` e `:sha-` devono uscire solo da un commit con tutta la verifica verde, come dice `docs/docker.md`; sull'unico runner i lavori vanno comunque uno alla volta, quindi la durata non cambia. Su un ramo, se l'installatore fallisce l'immagine si salta: la richiesta di unione è già bloccata dall'installatore |
| 2026-10-20 | Anche nel rilascio il lavoro «immagine» viene dopo «prove» e «windows» (`needs: [prove, windows]`) | Come nella verifica: `:X.Y.Z` e `:latest` si pubblicano solo se anche la release potrà uscire; prima, con l'installatore rosso, l'immagine usciva senza release |
+21
View File
@@ -20,6 +20,27 @@ display virtuale (Xvfb) e la libreria su disco. Si usa dal browser di casa; il b
- L'immagine si costruisce solo con le prove verdi: la compilazione e tutte le prove girano dentro la costruzione
(quelle con il browser vero lì si saltano da sole, perché nello stadio di compilazione non ci sono Chromium e Xvfb;
girano nella CI e in sviluppo).
- I pacchetti di Debian sono aggiornati al momento della costruzione (anche le correzioni uscite dopo l'immagine di
base). Prima di ogni pubblicazione la CI fa partire il contenitore senza rete fino al controllo di salute e lo
scansiona con Trivy: una vulnerabilità CRITICAL con correzione disponibile ferma la pubblicazione
(`docs/processo.md`, «Rilievi di sicurezza»).
## Etichette dell'immagine
Sul registro di Gitea, `192.168.30.23:3000/alby96/febe`:
| Etichetta | Che cos'è | Quando cambia |
|---|---|---|
| `:latest` | l'ultima versione rilasciata senza trattino: quella del modello di Unraid e di `compose.yml` | a ogni rilascio stabile |
| `:X.Y.Z` | una versione rilasciata (anche `X.Y.Z-rc.N` per un'anteprima) | mai: serve per tornare a una versione precisa |
| `:main` | l'ultimo commit di `main` che ha passato la verifica | a ogni unione in `main`: per provare, non per l'archivio vero |
| `:sha-<7 caratteri>` | un commit di `main` preciso | mai |
Ogni immagine costruita dalla CI dice da dove viene, nelle etichette Docker `febe.ci.workflow`, `febe.ci.run`,
`febe.ci.ref` e `febe.ci.commit` e in `org.opencontainers.image.version` e `.revision`:
`docker inspect --format '{{json .Config.Labels}}' <immagine>`. Docker copia queste etichette anche nel contenitore di
Febe: la pulizia della CI non le usa per scegliere che cosa togliere, quindi un Febe sullo stesso Docker del runner
della CI non viene mai toccato.
## Volumi
+20 -5
View File
@@ -129,12 +129,27 @@ da sole). Vedi [Installazione con Docker e Unraid](Installazione-Docker-e-Unraid
## CI e rilascio
Il repository è sul Gitea di casa (<https://gitea.encke-hake.ts.net/Alby96/Febe>); la CI usa Gitea Actions in
`.gitea/workflows/`:
`.gitea/workflows/`, con il codice comune in `.gitea/scripts/`. Il processo completo (nomi dei rami, commit,
richieste di unione, protezione di `main`, rilievi di sicurezza, rilasci, correzioni urgenti) è in `docs/processo.md`.
- `verifica.yml`, a ogni push e pull request: compilazione con gli avvisi come errori, tutte le prove, costruzione
dell'immagine Docker (senza pubblicarla) e due controlli sull'immagine (Chromium presente, lingua italiana generata);
- `rilascio.yml`, a ogni tag `vX.Y.Z`: immagine Docker sul registro di Gitea, installatore Windows e release. Al 13
ottobre 2026 è in preparazione: se il file non c'è ancora in `.gitea/workflows/`, il rilascio non è automatico.
- `verifica.yml`, a ogni push su qualunque ramo e a mano (non sui tag, non sulle richieste di unione, che mostrano lo
stato del loro ultimo commit). Quattro lavori, che sono i controlli richiesti per unire in `main`:
- `controlli`: sintassi degli script, file di testo, versione, progetti della soluzione, JSON, e nessun segreto in
tutta la storia (gitleaks);
- `prove`: compilazione di tutta la soluzione con gli avvisi come errori e tutte le prove di `tests/Febe.Tests` in
un contenitore Debian con Chromium, Xvfb, ffmpeg, NSIS e Node veri: nessuna prova si salta;
- `installatore`: `Febe-Setup-<versione>-ci.<numero>.exe` e lo zip portabile, fra gli artefatti per 14 giorni;
- `immagine`, dopo l'installatore: l'immagine Docker, provata senza rete (parte, diventa «healthy», si ferma) e
scansionata con Trivy; dopo un push su `main` va sul registro come `:main` e `:sha-<commit>`. Alla fine si toglie
tutto ciò che l'esecuzione ha creato sul demone Docker, che è condiviso con gli altri progetti;
- `rilascio.yml`, a ogni tag `vX.Y.Z`: prove, installatore e zip, immagine provata e scansionata, pubblicata come
`:X.Y.Z` e `:latest` (solo per le versioni senza trattino), poi la release;
- `pulizia.yml`, ogni lunedì e a mano: i resti delle esecuzioni interrotte e le immagini senza nome vecchie.
Nella CI le prove del sito di prova (categoria `SitoDiProva`) girano due volte: con il seme 13 e con un seme diverso
a ogni esecuzione, scritto nel registro del lavoro. Per rifare un errore con quel seme:
`FEBE_SEME_PROVA=<seme> dotnet test tests/Febe.Tests --filter "TestCategory=SitoDiProva"`. I controlli veloci della
CI si lanciano anche a mano: `bash .gitea/scripts/controlli.sh`.
La versione sta solo in `Directory.Build.props` (`<Version>`); il tag deve coincidere.
+214
View File
@@ -0,0 +1,214 @@
# Processo: dal ramo al rilascio
Come una modifica arriva in `main` e da lì a una versione, con le stesse garanzie di un'azienda che non accetta codice
non verificato. Vale per Alberto e per chiunque lavori al repository, persone o agenti. Repository: il Gitea di casa,
<https://gitea.encke-hake.ts.net/Alby96/Febe> (non GitHub: niente strumenti di GitHub). Il motivo di ogni scelta è in
`docs/decisioni.md`, alle righe del 20 ottobre 2026.
## In breve
1. Un ramo per filone di lavoro, nato da `main`.
2. Commit piccoli e separati, ciascuno con un messaggio che dice che cosa cambia e perché.
3. A ogni push la verifica parte da sola: controlli, prove, installatore, immagine.
4. Una richiesta di unione per ramo, con il modello compilato, e una revisione.
5. Si unisce in `main` solo con la verifica verde sull'ultimo commit (protezione di `main`), con un commit di unione;
il ramo si cancella.
6. Dopo l'unione la verifica gira su `main` e pubblica l'immagine `:main` e `:sha-<commit>`.
7. Un rilascio è un tag `vX.Y.Z` su `main`.
## Rami
- Nome: `<tipo>/<argomento>`, in minuscolo, parole separate da trattini, in italiano. Tipi:
| Tipo | Per |
|---|---|
| `funzione/` | una funzione nuova (`funzione/esporta-csv`) |
| `correzione/` | un difetto (`correzione/webview2-avvio`) |
| `urgente/` | una correzione da rilasciare subito (vedi «Correzioni urgenti») |
| `ci/` | flussi, script e immagini della CI (`ci/pipeline-aziendale`) |
| `strumenti/` | strumenti di sviluppo (`strumenti/vscode`) |
| `documenti/` | solo documenti e guida |
| `rilascio/` | la preparazione di una versione (`rilascio/0.2.0`) |
- Si parte da `main` aggiornato e si resta brevi: giorni, non settimane. Se `main` va avanti, il ramo si aggiorna
(pulsante «Aggiorna il ramo» della richiesta di unione, o `git merge origin/main`) prima di unire.
- Su `main` non si fa push diretto: ci si arriva solo da una richiesta di unione.
## Commit
- Piccoli e logici: ogni commit compila e passa le prove da solo (così `git bisect` funziona).
- Messaggio in italiano: la prima riga (al massimo 72 caratteri) dice che cosa cambia; il corpo, dopo una riga vuota,
dice perché. Non un elenco di file.
- I commit scritti con un agente finiscono con una riga vuota e `Co-Authored-By: …` dell'agente.
- Mai nel repository: risultati di compilazione (`bin/`, `obj/`, `out/`), segreti, campioni grezzi della sonda, dati
di Alberto.
## Richieste di unione
- Una per ramo, con il modello (`.gitea/pull_request_template.md`): sintesi, perché, che cosa cambia, come è stato
provato (comandi e risultati, e che cosa non è stato provato), rischi e ritorno indietro, le quattordici regole di
§2 della specifica. Le righe per `CHANGELOG.md` e `docs/stato.md` stanno nella richiesta: le aggiunge chi integra.
- Revisione: Alberto è il proprietario di tutto (`.gitea/CODEOWNERS`). Le osservazioni si risolvono con commit nuovi
sullo stesso ramo, non riscrivendo quelli già rivisti.
- Stile di unione: **commit di unione** («Crea un commit di unione»), con il titolo della richiesta; poi il ramo si
cancella («Elimina il ramo dopo l'unione», da tenere attivo nelle impostazioni del repository).
- Tornare indietro: `git revert -m 1 <commit di unione>` in una nuova richiesta di unione.
## Controlli richiesti e protezione di main
I controlli richiesti sono i quattro lavori della verifica, come Gitea li riporta sul commit:
`verifica / controlli (push)`, `verifica / prove (push)`, `verifica / installatore (push)`,
`verifica / immagine (push)`. Una richiesta di unione mostra lo stato del suo ultimo commit, che il push del ramo ha
già verificato: per questo la verifica non gira anche su `pull_request`.
Regola di protezione di `main` (Impostazioni ▸ Rami ▸ Aggiungi regola; la imposta chi integra, una volta che i
quattro controlli sono comparsi almeno una volta):
| Impostazione | Valore |
|---|---|
| Schema del ramo | `main` |
| Push | disattivato: solo da richiesta di unione |
| Push forzato | disattivato |
| Controllo di stato | attivo, con gli schemi `verifica / controlli (push)`, `verifica / prove (push)`, `verifica / installatore (push)`, `verifica / immagine (push)` |
| Blocca l'unione se la richiesta è indietro rispetto al ramo di base | attivo: con il ramo aggiornato il commit di unione ha lo stesso contenuto del commit verificato |
| Approvazioni richieste | 1 se le richieste le apre un account diverso da quello di Alberto; 0 se le apre lui (Gitea non conta l'approvazione dell'autore) |
| Annulla le approvazioni superate da nuovi commit | attivo |
| Blocca l'unione con revisioni che chiedono modifiche | attivo |
| Anche gli amministratori seguono la regola | attivo |
E nei tag protetti (Impostazioni ▸ Tag): `v*` creabili solo da Alberto.
## La CI
Gitea Actions su un solo act_runner (etichetta `ubuntu-latest`, un lavoro alla volta). I lavori parlano con il demone
Docker del server, lo stesso che costruisce Encelado, Mimante e gli altri progetti di Alberto. I flussi stanno in
`.gitea/workflows/`, il codice comune in `.gitea/scripts/` (si lancia anche a mano).
| Lavoro | Quando | Che cosa garantisce |
|---|---|---|
| `controlli` | ogni push | sintassi di tutti gli script di shell (`bash -n`, `sh -n`) e righe Unix; flussi senza tabulazioni; nessun segno di conflitto; versione in `Directory.Build.props` valida; ogni progetto di `Febe.slnx` esiste; ogni JSON si legge; nessun segreto in tutta la storia (gitleaks 8.30.1, `--redact`) |
| `prove` | dopo `controlli` | in un contenitore Debian 13 (`node:24-trixie`) con Chromium della distribuzione, Xvfb, ffmpeg, NSIS, Node e la lingua italiana: tutta la soluzione compila con gli avvisi come errori e **tutte** le prove di `tests/Febe.Tests` passano senza saltarsi; quelle della categoria `SitoDiProva` passano anche con il seme dell'esecuzione. Risultati `.trx` fra gli artefatti (14 giorni) |
| `installatore` | dopo `prove` | `Febe.exe` in un file solo, `Febe-Setup-<versione>-ci.<numero>.exe` e lo zip portabile si costruiscono, ciascuno sotto i 100 MB; artefatti per 14 giorni |
| `immagine` | dopo `installatore` (così `:main` e `:sha-` escono solo da un commit con tutta la verifica verde) | l'immagine si costruisce con buildx (dentro girano compilazione e prove), il contenitore parte **senza rete** come dice la guida e diventa «healthy», Chromium e la lingua italiana ci sono, si ferma entro 30 secondi; Trivy 0.75.0 non trova vulnerabilità CRITICAL con correzione disponibile. Solo dopo un push su `main`: pubblicazione `:main` e `:sha-<commit>` |
La verifica gira a ogni push su qualunque ramo e a mano (Actions ▸ verifica ▸ Esegui, con un seme facoltativo). Su un
ramo un push nuovo annulla l'esecuzione in corso; su `main` ogni unione arriva fino in fondo. Un'esecuzione a mano non
annulla mai quella di un push (l'evento fa parte del gruppo di concorrenza): solo il push scrive gli stati del commit
che servono per unire, e un lavoro annullato lascerebbe lo stato «failure».
Altri flussi: `rilascio.yml` a ogni tag (vedi «Rilasci») e `pulizia.yml` ogni lunedì (vedi «Pulizia»).
### Il mondo sintetico e il suo seme
Le prove non contattano mai Instagram: usano il sito di prova (`tools/Febe.SitoDiProva`), con dati sintetici generati
da un seme. Nella CI le prove girano con il seme 13 e quelle della categoria `SitoDiProva` di nuovo con il seme
`1000 + numero dell'esecuzione`, scritto nel registro del passo «Semi del mondo sintetico». Per rifare un errore, in
locale o dalla CI a mano con quel seme:
```sh
FEBE_SEME_PROVA=<seme> dotnet test tests/Febe.Tests --filter "TestCategory=SitoDiProva"
```
### Segreti e variabili
- `REGISTRY_TOKEN` (segreto del repository): token di Alberto con «package: read and write». Senza, `verifica` e
`rilascio` costruiscono, provano e scansionano l'immagine ma non la pubblicano, con un avviso, e restano verdi.
- `REGISTRY` (variabile, facoltativa): il registro come lo raggiunge il runner (`192.168.30.23:3000`); se manca si usa
l'host dell'indirizzo del server Gitea.
- Le credenziali vanno nella configurazione del client Docker del lavoro, mai nel demone, e si tolgono alla fine.
Nessun flusso stampa segreti; `PipelineTests` lo controlla a ogni esecuzione.
- I segreti sono leggibili da qualunque flusso di questo repository, su qualunque ramo: chi può fare push può leggerli.
Per questo il permesso di scrittura sul repository resta ad Alberto e agli account di cui si fida.
## Registro dei container: le etichette
Sul registro di Gitea, `192.168.30.23:3000/alby96/febe`:
| Etichetta | Chi la crea | Quando cambia | Per che cosa |
|---|---|---|---|
| `:latest` | `rilascio`, solo versioni senza trattino | a ogni rilascio stabile | Unraid e Docker Compose |
| `:X.Y.Z` | `rilascio` (anche `X.Y.Z-rc.1` per un'anteprima) | mai | una versione precisa, per tornare indietro |
| `:main` | `verifica`, dopo ogni unione in `main` | a ogni unione (mai all'indietro) | provare `main` su un server di prova; non per l'archivio vero |
| `:sha-<7 caratteri>` | `verifica`, dopo ogni unione in `main` | mai | un commit preciso di `main` |
Ogni immagine della CI porta le etichette Docker `febe.ci.workflow`, `febe.ci.run`, `febe.ci.ref` e `febe.ci.commit`,
oltre a quelle OCI del Dockerfile: da un'immagine si risale all'esecuzione e al commit. Docker le copia in ogni
contenitore creato dall'immagine, anche in un Febe vero: per questo la pulizia non le usa mai per scegliere che cosa
togliere (vedi «Pulizia»). Le `:sha-` si accumulano: una
regola di pulizia dei pacchetti (Impostazioni ▸ Pacchetti ▸ Regole di pulizia) può tenere sempre `latest`, `main` e
le versioni e togliere le `sha-.*` più vecchie di 30 giorni.
## Pulizia
Il demone Docker è condiviso con gli altri progetti, e ci può girare anche un Febe vero, avviato da un'immagine che la
CI ha pubblicato e che quindi porta le sue etichette `febe.ci.*`. La CI di Febe toglie solo ciò che può provare suo
(`.gitea/scripts/pulizia-docker.sh`):
- contenitori di prova: l'etichetta `febe.ci.prova=<esecuzione>`, che mette solo `prova-immagine.sh` con
`docker run --label` e che nessuna immagine porta (lo controlla `PipelineTests`), e insieme il nome esatto
`febe-prova-<esecuzione>`;
- immagini provate: il nome locale `febe-ci:<esecuzione>`, tolto per nome, mai per identificativo e mai con `-f`. Se la
stessa immagine ha anche un nome del registro, quello resta; se un contenitore la usa, resta tutto;
- builder buildx: il contenitore `buildx_buildkit_febe-ci-<esecuzione>0` con l'immagine `moby/buildkit` e il suo volume
`…_state`;
- più le immagini senza nome più vecchie di 72 ore che nessun contenitore usa.
`PipelineTests` fa girare la pulizia contro un demone finto (`tests/Febe.Tests/Packaging/fake-docker.sh`) con un Febe
vero acceso e uno fermo che portano le etichette delle loro immagini: non li deve toccare.
| Quando | Che cosa si toglie |
|---|---|
| alla fine di ogni lavoro «immagine», sempre | il contenitore di prova con i suoi volumi anonimi, l'immagine provata, il builder buildx dell'esecuzione con la sua cache, l'archivio dell'immagine, le credenziali del registro |
| all'inizio di ogni lavoro «immagine» | i resti di esecuzioni interrotte più vecchi di 90 minuti (un lavoro dura al massimo 60 minuti): contenitori di prova **fermi**, immagini `febe-ci:`, builder; e ciò che ha lasciato un tentativo precedente della stessa esecuzione |
| ogni lunedì e a mano (`pulizia.yml`) | gli stessi resti, l'immagine `febe:ci` del vecchio flusso se nessuno la usa, le immagini senza nome più vecchie di 72 ore |
| mai | immagini, contenitori e volumi degli altri progetti; un contenitore Febe che non sia di prova, anche se porta le etichette `febe.ci.*`; un contenitore di prova ancora acceso di un'altra esecuzione (si segnala con un avviso e il comando per toglierlo: il flusso settimanale diventa rosso); la cache di costruzione del demone; i volumi con un nome; le immagini col nome del registro |
## Rilievi di sicurezza
- **gitleaks** (lavoro `controlli`). Un segreto vero si **revoca subito** (gettone di Telegram da BotFather, token di
Gitea dalle impostazioni dell'utente) e se ne crea uno nuovo: toglierlo dalla storia non basta, perché qualcuno può
averlo già. Solo dopo, se serve, si riscrive la storia, d'accordo con Alberto. Un falso allarme (un dato di prova
finto, già controllato) si toglie aggiungendo la sua impronta («Fingerprint», nel registro del lavoro o nel
rapporto `rapporto-gitleaks`) a `.gitleaksignore`, con un commento sulla riga sopra: che cos'è, chi l'ha
controllato, quando. Mai disattivare una regola.
- **Trivy** (lavoro `immagine`, anche nel rilascio). Una vulnerabilità CRITICAL con correzione disponibile ferma il
lavoro e l'immagine non si pubblica. Che cosa fare: per un pacchetto di Debian di solito basta rilanciare (il
Dockerfile applica gli aggiornamenti della distribuzione); per una dipendenza .NET si aggiorna la sua versione in
`Directory.Packages.props` (una dipendenza nuova va chiesta ad Alberto); per il runtime .NET si ricostruisce con
l'SDK aggiornato. Le HIGH, e le CRITICAL ancora senza correzione, non fermano nulla ma si guardano nel rapporto
`sicurezza-immagine` (`trivy.json`) e, se riguardano ciò che Febe usa, diventano una segnalazione. Un'eccezione si
scrive solo in `.trivyignore`, alla radice: l'identificativo con una scadenza (`CVE-AAAA-NNNN exp:AAAA-MM-GG`, al
massimo 90 giorni) e, sulla riga sopra, il motivo e chi l'ha deciso.
- Strumenti: gitleaks e Trivy sono gli unici strumenti esterni della CI, approvati da Alberto, e girano solo nella
CI. Si aggiornano cambiando versione e impronta SHA-256 in `.gitea/scripts/strumento.sh`, in una richiesta di
unione con una riga in `docs/decisioni.md`, preferendo versioni uscite da almeno due settimane.
## Rilasci
1. In un ramo `rilascio/X.Y.Z`: `<Version>` in `Directory.Build.props`, la sezione `## X.Y.Z` di `CHANGELOG.md` (è il
testo delle note della release), `docs/stato.md`. Richiesta di unione, verifica verde, unione.
2. Sul commit di unione in `main`: `git tag -a vX.Y.Z -m "Febe X.Y.Z"` e `git push origin vX.Y.Z`.
3. `rilascio.yml` controlla che il tag coincida con `<Version>`, rifà le prove, costruisce installatore e zip,
costruisce, prova e scansiona l'immagine, la pubblica come `:X.Y.Z` (e `:latest` se la versione non ha trattini) e
crea la release con installatore, zip, modello di Unraid e archivio per Compose.
4. Un'anteprima è `vX.Y.Z-rc.N`: stessa strada, `:latest` non si sposta e la release è segnata come anteprima (come
ogni versione `0.x`).
5. Se manca `REGISTRY_TOKEN` la release esce senza immagine e lo dice; aggiunto il segreto, si rilancia il flusso del
tag e le note si correggono.
## Correzioni urgenti
- Se `main` contiene solo ciò che si vuole rilasciare: ramo `urgente/<argomento>` da `main`, richiesta di unione con la
verifica verde come sempre (nessuna scorciatoia), poi un rilascio di correzione (`X.Y.Z+1`) come sopra.
- Se `main` contiene già lavoro da non rilasciare: ramo `rilascio/X.Y` dal tag della versione in uso, la correzione con
`git cherry-pick` (o scritta lì), `<Version>` a `X.Y.Z+1`, tag `vX.Y.Z+1` su quel ramo (il rilascio parte da
qualunque tag); poi la stessa correzione entra in `main` con la sua richiesta di unione.
## Che cosa solo la prima esecuzione vera può provare
Qui non ci sono runner né demone Docker: i flussi sono stati controllati come testo (struttura, espressioni, `bash -n`
di ogni blocco `run`), gli script con un client Docker finto. Restano da vedere alla prima esecuzione: il contenitore
`node:24-trixie` con le azioni dentro; le prove con il browser nel contenitore (nessuna saltata); `upload-artifact@v3`
con `retention-days`; la concorrenza; il builder buildx con il nome dell'esecuzione; la prova del contenitore senza
rete fino a «healthy»; il download e la scansione di Trivy (e se trova CRITICAL da correggere); gitleaks sulla storia;
la pubblicazione su `main` con il segreto; la pulizia settimanale sul demone vero.
@@ -4,7 +4,6 @@ using Febe.Browser.Cdp;
using Febe.Browser.Gestures;
using Febe.Core.Abstractions;
using Febe.Core.Collection;
using Febe.SitoDiProva;
using Febe.Sonda;
using Febe.Tests.Collection.Support;
using Febe.Tests.Support;
@@ -16,6 +15,7 @@ namespace Febe.Tests.Collection;
/// the probe only listens. Then the whole M0 path: raw samples, cleaning, verification.
/// </summary>
[TestClass]
[TestCategory(SyntheticSite.Category)]
[DoNotParallelize]
public sealed class ProbeIntegrationTests
{
@@ -53,7 +53,7 @@ public sealed class ProbeIntegrationTests
Assert.Inconclusive(s_unavailable);
}
await using var site = await TestSite.StartAsync();
await using var site = await SyntheticSite.StartAsync();
using var temp = new TempFolder("sonda");
var raw = temp.Combine("grezzi");
var hosts = new HostClassifier([site.SiteHost], [site.CdnHost]);
@@ -5,6 +5,7 @@ using Febe.Core.Engine;
using Febe.Core.Storage;
using Febe.SitoDiProva;
using Febe.Tests.Collection.Support;
using Febe.Tests.Support;
namespace Febe.Tests.Collection;
@@ -13,6 +14,7 @@ namespace Febe.Tests.Collection;
/// Instagram. Time is compressed (a 2.2 s wait lasts about 0.2 s); the browser is shared and the tests run one at a time.
/// </summary>
[TestClass]
[TestCategory(SyntheticSite.Category)]
[DoNotParallelize]
public sealed class RecipeIntegrationTests
{
@@ -7,6 +7,7 @@ using Febe.Core.Library;
using Febe.Core.Storage;
using Febe.SitoDiProva;
using Febe.Tests.Collection.Support;
using Febe.Tests.Support;
namespace Febe.Tests.Collection;
@@ -14,6 +15,7 @@ namespace Febe.Tests.Collection;
/// Stop signals (spec §7.6) and the download queue (spec §6.5) against the local test site with a real Chromium.
/// </summary>
[TestClass]
[TestCategory(SyntheticSite.Category)]
[DoNotParallelize]
public sealed class StopAndDownloadIntegrationTests
{
@@ -129,7 +129,7 @@ internal sealed class CollectionHarness : IAsyncDisposable
public static async Task<CollectionHarness> CreateAsync(SharedChromium chromium, RecipeOptions? options = null, double factor = 10)
{
var site = await TestSite.StartAsync(new TestSiteOptions());
var site = await SyntheticSite.StartAsync();
var temp = new TempFolder("raccolta");
var library = await TestLibrary.CreateAsync(temp);
var clock = new CompressedClock(factor, TestZones.Rome);
@@ -0,0 +1,262 @@
using System.Globalization;
using System.Text.RegularExpressions;
using Febe.Core.Collection.Readers;
using Febe.Core.Domain;
using Febe.SitoDiProva;
using Febe.Tests.Desktop.Support;
using Febe.Tests.Support;
namespace Febe.Tests.Collection;
/// <summary>
/// The synthetic world of the test site and its seed (<see cref="SyntheticSite"/>), without a browser, so they run
/// everywhere: what the integration tests take for granted holds for every seed, and the readers of
/// <c>lettori.prova.json</c> read what the site serves with the seed of this run, page after page. Never Instagram:
/// the site is on 127.0.0.1.
/// </summary>
[TestClass]
[TestCategory(SyntheticSite.Category)]
public sealed partial class SyntheticSiteSeedTests
{
private static readonly ShapeReader Reader = new(ReaderVocabulary.LoadTestSite());
private static readonly string[] StoryBarOrder = ["marta.prova", "nadia.prova", "luca.prova", "giulia.prova"];
public TestContext TestContext { get; set; } = null!;
[TestMethod]
public void TheSeedComesFromTheVariableAndIsThirteenWithoutIt()
{
Assert.AreEqual(13, SyntheticSite.ParseSeed(null));
Assert.AreEqual(13, SyntheticSite.ParseSeed(" "));
Assert.AreEqual(4242, SyntheticSite.ParseSeed("4242"));
Assert.AreEqual(-7, SyntheticSite.ParseSeed(" -7 "));
Assert.ThrowsExactly<InvalidOperationException>(() => SyntheticSite.ParseSeed("tredici"));
Assert.ThrowsExactly<InvalidOperationException>(() => SyntheticSite.ParseSeed("99999999999"));
}
[TestMethod]
public void EveryTestThatStartsTheSiteTakesTheSeedOfTheRunAndIsInItsCategory()
{
var tests = Repository.PathOf("tests", "Febe.Tests");
var direct = new List<string>();
var outside = new List<string>();
foreach (var file in Directory.EnumerateFiles(tests, "*.cs", SearchOption.AllDirectories))
{
var name = Path.GetRelativePath(tests, file).Replace('\\', '/');
if (name.StartsWith("bin/", StringComparison.Ordinal) || name.StartsWith("obj/", StringComparison.Ordinal))
{
continue;
}
var text = File.ReadAllText(file);
if (name != "Support/SyntheticSite.cs" && DirectStart().IsMatch(text))
{
direct.Add(name);
}
if (SiteStart().IsMatch(text) && text.Contains("[TestClass]", StringComparison.Ordinal)
&& !text.Contains("[TestCategory(SyntheticSite.Category)]", StringComparison.Ordinal))
{
outside.Add(name);
}
}
Assert.IsEmpty(direct, "The site starts through SyntheticSite.StartAsync, which reads FEBE_SEME_PROVA: " + string.Join(", ", direct));
Assert.IsEmpty(outside, "The CI runs these tests again with the seed of the run only through their category: " + string.Join(", ", outside));
}
[TestMethod]
public void EverySeedGivesTheWorldTheIntegrationTestsRelyOn()
{
var now = new DateTimeOffset(2026, 10, 20, 9, 30, 0, TimeSpan.Zero);
int[] extremes = [SyntheticSite.Seed, int.MinValue, -1, 0, int.MaxValue];
foreach (var seed in extremes.Concat(Enumerable.Range(1, 300)).Distinct())
{
var world = World.Generate(seed, now);
var context = "seme " + seed.ToString(CultureInfo.InvariantCulture);
Assert.AreEqual(seed, world.Seed, context);
Assert.AreEqual("alberto.prova", world.Viewer.Username, context);
Assert.HasCount(31, world.Accounts, context);
Assert.HasCount(28, world.Following, context);
var counts = new Dictionary<string, int>
{
["alberto.prova"] = 4,
["marta.prova"] = 18,
["luca.prova"] = 40,
["giulia.prova"] = 6,
["nadia.prova"] = 3,
["paolo.prova"] = 8,
["riservato.prova"] = 5,
};
foreach (var (username, count) in counts)
{
Assert.HasCount(count, world.FindByUsername(username)!.Posts, $"{context}: {username}");
}
foreach (var account in world.Accounts)
{
if (account.Username.StartsWith("amico", StringComparison.Ordinal))
{
Assert.IsTrue(account.Posts.Count is 1 or 2, $"{context}: {account.Username}");
}
// Newest first, strictly: «known content at the top» and the cursors rely on it.
for (var i = 1; i < account.Posts.Count; i++)
{
Assert.IsTrue(account.Posts[i - 1].PublishedAt > account.Posts[i].PublishedAt, $"{context}: {account.Username} #{i}");
}
}
var posts = world.Accounts.SelectMany(a => a.Posts).ToList();
Assert.HasCount(posts.Count, posts.Select(p => p.Code).Distinct(StringComparer.Ordinal), $"{context}: codes are unique");
Assert.HasCount(posts.Count, posts.Select(p => p.Id).Distinct(StringComparer.Ordinal), $"{context}: identifiers are unique");
Assert.IsTrue(posts.All(p => p.Code.Length == 7 && p.PublishedAt <= now), context);
var feed = world.Feed();
for (var i = 1; i < feed.Count; i++)
{
Assert.IsTrue(feed[i - 1].PublishedAt >= feed[i].PublishedAt, $"{context}: feed #{i}");
}
CollectionAssert.AreEqual(StoryBarOrder, world.StoryBar(now).Select(a => a.Username).ToArray(), context);
var marta = world.FindByUsername("marta.prova")!;
var active = marta.Stories.Where(s => s.ExpiresAt > now).ToList();
Assert.HasCount(4, active, context);
Assert.AreEqual(1, active.Count(s => s.File.IsVideo), context);
Assert.HasCount(3, world.FindByUsername("nadia.prova")!.Stories.Where(s => s.ExpiresAt > now), context);
Assert.HasCount(2, world.FindByUsername("luca.prova")!.Stories.Where(s => s.ExpiresAt > now), context);
Assert.HasCount(5, world.FindByUsername("giulia.prova")!.Stories.Where(s => s.ExpiresAt > now), context);
var grid = world.Grid(marta, ProfileTab.Posts);
Assert.IsTrue(grid.Take(2).All(p => p.Pinned) && grid.Count(p => p.Pinned) == 2, $"{context}: two pinned posts on top");
Assert.IsTrue(grid.Take(DataApi.GridPageSize).Any(p => p.Files.Count == 3), $"{context}: a series on the first page");
Assert.HasCount(3, world.Grid(marta, ProfileTab.Tagged), context);
CollectionAssert.AreEqual(new[] { "Estate", "Viaggi" }, marta.Highlights.Select(h => h.Title).ToArray(), context);
Assert.IsTrue(marta.Highlights[0].Items.Any(i => i.Id == marta.Stories[1].Id), $"{context}: a story also in «Estate» (H9)");
}
}
[TestMethod]
[Timeout(30_000, CooperativeCancellation = true)]
public async Task TheLoginAddressOfTheTestSiteIsAWelcomePageThatOpensTheSession()
{
// Febe opens /benvenuto as the «pagina di accesso» of the test site (LoginUrl of DesktopOptions and ServerOptions).
await using var site = await SyntheticSite.StartAsync();
using var client = new HttpClient(new SocketsHttpHandler { UseProxy = false, UseCookies = false });
using var response = await client.GetAsync(new Uri(site.Url("/benvenuto")), TestContext.CancellationToken);
Assert.AreEqual(System.Net.HttpStatusCode.OK, response.StatusCode);
var html = await response.Content.ReadAsStringAsync(TestContext.CancellationToken);
StringAssert.Contains(html, "Ho finito");
Assert.DoesNotContain("<form", html, "No login form: the test site never asks for a password.");
Assert.IsTrue(
response.Headers.TryGetValues("Set-Cookie", out var cookies) && cookies.Any(c => c.StartsWith(TestSite.SessionCookie + "=", StringComparison.Ordinal)),
"The visit opens the session of the site.");
}
[TestMethod]
[Timeout(60_000, CooperativeCancellation = true)]
public async Task TheReadersReadWhatTheSiteServesWithTheSeedOfThisRun()
{
await using var site = await SyntheticSite.StartAsync();
TestContext.WriteLine($"Seme del mondo sintetico: {site.World.Seed.ToString(CultureInfo.InvariantCulture)}");
Assert.AreEqual(SyntheticSite.Seed, site.World.Seed);
string[] feed, firstFeedPageSeries, martaFirstPage, lucaGrid, martaStories, following;
string seriesCode, sharedStory, summerId;
lock (site.World.Gate)
{
var world = site.World;
var marta = world.FindByUsername("marta.prova")!;
feed = [.. world.Feed().Select(p => p.Id)];
firstFeedPageSeries = [.. world.Feed().Take(DataApi.FeedPageSize).Where(p => p.Files.Count > 1).Select(p => p.Id)];
martaFirstPage = [.. world.Grid(marta, ProfileTab.Posts).Take(DataApi.GridPageSize).Select(p => p.Id)];
seriesCode = world.Grid(marta, ProfileTab.Posts).First(p => p.Files.Count == 3).Code;
lucaGrid = [.. world.Grid(world.FindByUsername("luca.prova")!, ProfileTab.Posts).Select(p => p.Id)];
martaStories = [.. marta.Stories.Select(s => s.Id)];
sharedStory = marta.Stories[1].Id;
summerId = marta.Highlights[0].Id;
following = [.. world.Following.Select(a => a.Username)];
}
// The home: the connected account, the stories bar, then the whole feed page by page, as the recipe scrolls it.
var home = await ReadAsync(site, "/dati/inizio");
Assert.AreEqual(ReadShape.Recognized, home.Shape);
Assert.AreEqual("alberto.prova", home.Viewer?.Username);
CollectionAssert.AreEqual(StoryBarOrder, home.Profiles.Where(p => p.LatestStoryAt is not null).Select(p => p.Username).ToArray());
CollectionAssert.AreEqual(firstFeedPageSeries, home.Contents.Where(c => !c.IsComplete).Select(c => c.Id).ToArray(), "A series arrives incomplete in the feed.");
Assert.IsTrue(home.Contents.Where(c => !c.IsComplete).All(c => c.Files.Count == 1));
CollectionAssert.AreEqual(feed, await AllPagesAsync(site, home, "/dati/inizio/altri?dopo="));
// Marta's grid: two pinned posts on top, her highlights, her post count.
var profile = await ReadAsync(site, "/dati/profilo/marta.prova?scheda=post");
CollectionAssert.AreEqual(martaFirstPage, profile.Contents.Select(c => c.Id).ToArray());
Assert.IsTrue(profile.Contents.Take(2).All(c => c.Pinned) && profile.Contents.Count(c => c.Pinned) == 2);
CollectionAssert.AreEqual(new[] { "Estate", "Viaggi" }, profile.Highlights.Select(h => h.Title).ToArray());
Assert.AreEqual(18, profile.Profiles.Single(p => p.PostCount is not null).PostCount);
// Luca's history, page after page (the backfill): every post once, in order.
var luca = await ReadAsync(site, "/dati/profilo/luca.prova?scheda=post");
CollectionAssert.AreEqual(lucaGrid, await AllPagesAsync(site, luca, "/dati/profilo/luca.prova/altri?scheda=post&dopo="));
// A series on its own page: complete, in order, a video in the middle.
var series = (await ReadAsync(site, "/dati/post/" + seriesCode)).Contents.Single();
Assert.AreEqual(seriesCode, series.Code);
Assert.IsTrue(series.IsComplete);
CollectionAssert.AreEqual(new[] { MediaKind.Photo, MediaKind.Video, MediaKind.Photo }, series.Files.Select(f => f.Kind).ToArray());
// Stories and a highlight that shares one of them (H9).
var stories = await ReadAsync(site, "/dati/storie/marta.prova");
CollectionAssert.AreEqual(martaStories, stories.Contents.Select(c => c.Id).ToArray());
Assert.AreEqual(1, stories.Contents.Count(c => c.Files[0].Kind == MediaKind.Video));
var summer = (await ReadAsync(site, "/dati/evidenza/" + summerId)).Highlights.Single();
Assert.HasCount(3, summer.Items);
Assert.IsTrue(summer.Items.Any(i => i.Id == sharedStory));
// The following list, page after page, and a private profile Alberto does not follow.
var first = await ReadAsync(site, "/dati/seguiti");
var names = first.Profiles.Select(p => p.Username).ToList();
var page = first.Page;
while (page?.HasMore == true)
{
var next = await ReadAsync(site, "/dati/seguiti?dopo=" + Uri.EscapeDataString(page.Cursor!));
names.AddRange(next.Profiles.Select(p => p.Username));
page = next.Page;
}
CollectionAssert.AreEqual(following, names);
var hidden = await ReadAsync(site, "/dati/profilo/riservato.prova?scheda=post");
Assert.AreEqual(true, hidden.Profiles.Single().IsPrivate);
Assert.AreEqual(false, hidden.Profiles.Single().IsFollowed);
Assert.IsEmpty(hidden.Contents);
}
private async Task<ReadResult> ReadAsync(TestSite site, string pathAndQuery)
{
var result = Reader.Read(await site.GetDataAsync(pathAndQuery, TestContext.CancellationToken));
Assert.AreEqual(ReadShape.Recognized, result.Shape, pathAndQuery);
return result;
}
/// <summary>The identifiers of a first page and of every page after it, following the cursors.</summary>
private async Task<string[]> AllPagesAsync(TestSite site, ReadResult first, string nextPath)
{
var ids = first.Contents.Select(c => c.Id).ToList();
var page = first.Page;
while (page?.HasMore == true)
{
var next = await ReadAsync(site, nextPath + Uri.EscapeDataString(page.Cursor!));
ids.AddRange(next.Contents.Select(c => c.Id));
page = next.Page;
}
return [.. ids];
}
[GeneratedRegex(@"\bTestSite\.StartAsync\(")]
private static partial Regex DirectStart();
[GeneratedRegex(@"\b(?:SyntheticSite\.StartAsync|CollectionHarness\.CreateAsync|ServerTestBed\.StartAsync)\(")]
private static partial Regex SiteStart();
}
+18 -5
View File
@@ -128,8 +128,9 @@ public sealed partial class PackagingTests
StringAssert.Contains(prove, "dotnet build Febe.slnx -c Release -nologo -warnaserror");
StringAssert.Contains(prove, "dotnet test tests/Febe.Tests -c Release --no-build");
StringAssert.Contains(Job(workflow, "windows"), "needs: prove");
// The image waits for the installer too: :X.Y.Z and :latest are published only when the release can follow.
var image = Job(workflow, "immagine");
StringAssert.Contains(image, "needs: prove");
StringAssert.Contains(image, "needs: [prove, windows]");
// pkg-3: the release needs the tests, the installer and the image job, which says whether it published.
var release = Job(workflow, "release");
@@ -145,13 +146,25 @@ public sealed partial class PackagingTests
StringAssert.Contains(secret, "presente=no");
StringAssert.Contains(Step(image, "Pubblicazione sul registro di Gitea"), "if: steps.segreto.outputs.presente == 'si'");
// The registry at home answers in HTTP: buildx with its own builder, told so, and no «docker login».
// The registry at home answers in HTTP: buildx with its own builder, told so, and no «docker login». The push is
// the same build as the tested one (.gitea/scripts/costruisci-immagine.sh, shared with the verification).
StringAssert.Contains(image, "uses: docker/setup-buildx-action@v3");
StringAssert.Contains(image, "http = true");
StringAssert.Contains(image, "insecure = true");
StringAssert.Contains(image, "--push");
Assert.DoesNotContain("docker login", image);
Assert.DoesNotContain("docker push", image);
StringAssert.Contains(Step(image, "Pubblicazione sul registro di Gitea"), "bash .gitea/scripts/costruisci-immagine.sh pubblica");
var build = File.ReadAllText(Repository.PathOf(".gitea", "scripts", "costruisci-immagine.sh"));
StringAssert.Contains(build, "docker buildx build \"${comuni[@]}\" \"${etichette[@]}\" --push .");
foreach (var text in new[] { image, build })
{
Assert.DoesNotContain("docker login", text);
Assert.DoesNotContain("docker push", text);
}
// Before publishing, the image is started without a network and scanned (Trivy); at the end everything of the
// run goes away, whatever happened.
StringAssert.Contains(image, "bash .gitea/scripts/prova-immagine.sh");
StringAssert.Contains(image, "bash .gitea/scripts/scansione-immagine.sh");
StringAssert.Contains(Step(image, "Pulizia (sempre)"), "if: always()");
// pkg-4: compose.yml goes out with chromium/seccomp.json next to it, never alone.
StringAssert.Contains(release, "cp docker/compose.yml \"$COMPOSE/compose.yml\"");
+487
View File
@@ -0,0 +1,487 @@
using System.Diagnostics;
using System.Text.RegularExpressions;
using Febe.Tests.Desktop.Support;
using Febe.Tests.Support;
namespace Febe.Tests.Packaging;
/// <summary>
/// The CI of the repository (.gitea/workflows/verifica.yml, pulizia.yml and the scripts of .gitea/scripts), read as
/// text: the rules that must survive later edits. Every push of every branch is verified and nothing else triggers
/// it twice; the tests run only through tests/Febe.Tests, with the browser, and again with the seed of the run; the
/// image is published only from main and never as :latest; credentials are never printed; the external tools are
/// pinned and checked; the cleanup touches only what the CI of Febe made, never a real Febe on the same daemon; the
/// tried container never has a network.
/// </summary>
[TestClass]
public sealed partial class PipelineTests
{
private static readonly string[] Jobs = ["controlli", "prove", "installatore", "immagine"];
public TestContext TestContext { get; set; } = null!;
[TestMethod]
public void EveryPushOfEveryBranchIsVerifiedOnceAndTagsAreLeftToTheRelease()
{
var workflow = Workflow("verifica.yml");
StringAssert.Contains(workflow, "on:\n push:\n branches: [\"**\"]\n workflow_dispatch:");
var code = Code(workflow);
Assert.DoesNotContain("pull_request", code, "a PR shows the status of its head commit, already verified by the push");
Assert.DoesNotContain("tags:", code, "tags belong to rilascio.yml");
StringAssert.Contains(code, "cancel-in-progress: ${{ gitea.ref != 'refs/heads/main' }}", "every merge into main runs to the end");
// A run started by hand never cancels the run of a push: only that one writes the statuses a merge needs.
StringAssert.Contains(code, "group: verifica-${{ gitea.event_name }}-${{ gitea.ref }}");
}
[TestMethod]
public void TheJobsFollowOneAnotherAndEachHasATimeout()
{
var workflow = Workflow("verifica.yml");
foreach (var job in Jobs)
{
StringAssert.Contains(Job(workflow, job), "timeout-minutes:", job);
}
StringAssert.Contains(Job(workflow, "prove"), "needs: controlli");
StringAssert.Contains(Job(workflow, "installatore"), "needs: prove");
StringAssert.Contains(Job(workflow, "immagine"), "needs: [prove, installatore]", ":main comes only from a commit whose whole verification is green");
foreach (var other in new[] { "rilascio.yml", "pulizia.yml" })
{
var text = Workflow(other);
foreach (Match job in JobHeader().Matches(text))
{
StringAssert.Contains(Job(text, job.Groups["name"].Value), "timeout-minutes:", $"{other}: {job.Groups["name"].Value}");
}
}
}
[TestMethod]
public void TheWholeSolutionIsBuiltAndTheTestsRunOnlyThroughTheTestProjectWithTheBrowser()
{
var prove = Job(Workflow("verifica.yml"), "prove");
StringAssert.Contains(prove, "container:\n image: node:24-trixie", "Debian: Chromium is a real package there, a snap on Ubuntu");
StringAssert.Contains(prove, "bash .gitea/scripts/ambiente-prove.sh");
StringAssert.Contains(prove, "dotnet build Febe.slnx -c Release -nologo -warnaserror");
StringAssert.Contains(prove, "bash .gitea/scripts/riepilogo-prove.sh out/prove 0", "no test may skip itself in the CI");
// The second pass: the tests of the synthetic world again, with the seed of the run in the variable the helper reads.
StringAssert.Contains(prove, $"{SyntheticSite.Variable}: ${{{{ steps.semi.outputs.seme }}}}");
StringAssert.Contains(prove, $"--filter \"TestCategory={SyntheticSite.Category}\"");
var environment = Script("ambiente-prove.sh");
foreach (var package in new[] { "chromium", "xvfb", "ffmpeg", "nsis", "locales" })
{
StringAssert.Contains(environment, package);
}
// tests/Febe.Tests.Windows runs only on Windows: never «dotnet test» on the solution or without a project.
foreach (var name in new[] { "verifica.yml", "rilascio.yml" })
{
foreach (Match test in DotnetTest().Matches(Code(Workflow(name))))
{
Assert.AreEqual("tests/Febe.Tests", test.Groups["target"].Value, $"{name}: {test.Value}");
}
}
}
[TestMethod]
public void TheImageIsPublishedOnlyAfterAPushToMainAsMainAndShaNeverAsLatest()
{
var image = Job(Workflow("verifica.yml"), "immagine");
var decision = Step(image, "Pubblicare?");
StringAssert.Contains(decision, "[ \"$EVENTO\" != push ] || [ \"$RIFERIMENTO\" != refs/heads/main ]");
StringAssert.Contains(decision, "::warning::Manca il segreto REGISTRY_TOKEN");
Assert.DoesNotContain("exit 1", decision, "without the secret the job stays green");
var publish = Step(image, "Pubblicazione come :main e :sha-<commit>");
StringAssert.Contains(publish, "if: steps.segreto.outputs.presente == 'si'");
StringAssert.Contains(publish, "\"$IMAGE:sha-${GITHUB_SHA::7}\"");
StringAssert.Contains(publish, "\"$IMAGE:main\"");
StringAssert.Contains(publish, "bash .gitea/scripts/costruisci-immagine.sh pubblica");
StringAssert.Contains(publish, "| cut -f1) || CIMA=\"\"", "under bash -e an unreadable main must reach the warning and still publish :sha-");
Assert.DoesNotContain(":latest", Code(Workflow("verifica.yml")), ":latest belongs to the release");
// Built with buildx, tried without a network and scanned before anything is published; always cleaned up.
StringAssert.Contains(image, "uses: docker/setup-buildx-action@v3");
StringAssert.Contains(image, "http = true");
StringAssert.Contains(image, "insecure = true");
var decide = image.IndexOf("- name: Pubblicare?", StringComparison.Ordinal);
foreach (var gate in new[] { "bash .gitea/scripts/costruisci-immagine.sh archivio", "bash .gitea/scripts/prova-immagine.sh", "bash .gitea/scripts/scansione-immagine.sh" })
{
var at = image.IndexOf(gate, StringComparison.Ordinal);
Assert.IsTrue(at >= 0 && at < decide, $"«{gate}» comes before the publication");
}
var cleanup = Step(image, "Pulizia (sempre)");
StringAssert.Contains(cleanup, "if: always()");
StringAssert.Contains(cleanup, "bash .gitea/scripts/pulizia-docker.sh esecuzione \"$ESECUZIONE\"");
StringAssert.Contains(cleanup, ".auths |= del(.[$r])", "the credentials leave the client configuration");
}
[TestMethod]
public void SecretsAreNeverPrintedNorTheDaemonUsedForTheRegistry()
{
foreach (var (name, text) in AllCiFiles())
{
var code = Code(text);
Assert.DoesNotContain("docker login", code, name);
Assert.DoesNotContain("docker push", code, name);
Assert.IsFalse(Trace().IsMatch(code), $"{name}: no shell tracing (it would print secrets)");
// A secret goes into echo or printf only to be piped or redirected, never to the log.
foreach (var line in code.Split('\n').Where(l => Printing().IsMatch(l)))
{
var secret = SecretReference().Match(line);
if (secret.Success)
{
var after = line[secret.Index..];
Assert.IsTrue(after.Contains('|', StringComparison.Ordinal) || after.Contains('>', StringComparison.Ordinal), $"{name}: «{line.Trim()}» would print a secret");
}
}
}
}
[TestMethod]
public void TheExternalToolsArePinnedAndCheckedAndNoThirdPartyActionRunsThem()
{
var tool = Script("strumento.sh");
StringAssert.Contains(tool, "versione=\"8.30.1\"");
StringAssert.Contains(tool, "versione=\"0.75.0\"");
Assert.HasCount(2, Sha256().Matches(tool), "one SHA-256 per tool");
StringAssert.Contains(tool, "sha256sum -c");
Assert.DoesNotContain("latest", Code(tool));
foreach (var (name, text) in AllCiFiles())
{
Assert.DoesNotContain("trivy-action", Code(text), name);
Assert.DoesNotContain("gitleaks-action", Code(text), name);
}
var secrets = Script("segreti.sh");
StringAssert.Contains(secrets, "--redact");
StringAssert.Contains(Job(Workflow("verifica.yml"), "controlli"), "fetch-depth: 0");
var scan = Script("scansione-immagine.sh");
StringAssert.Contains(scan, "--severity CRITICAL --ignore-unfixed");
StringAssert.Contains(scan, "--exit-code 1");
}
[TestMethod]
public void TheCleanupTouchesOnlyWhatTheCiOfFebeMade()
{
var cleanup = Code(Script("pulizia-docker.sh"));
foreach (var forbidden in new[] { "system prune", "builder prune", "volume prune", "container prune", "image prune -a", "prune --all", "image prune -f -a" })
{
Assert.DoesNotContain(forbidden, cleanup, "the daemon is shared with Alberto's other projects");
}
Assert.HasCount(1, ImagePrune().Matches(cleanup), "only dangling images, older than three days");
StringAssert.Contains(cleanup, "docker image prune -f --filter \"until=72h\"");
StringAssert.Contains(cleanup, "^buildx_buildkit_(febe-ci-[0-9]+)0$");
// The febe.ci.* labels of the image are in every container made from a published image, a real Febe too: they
// never choose what goes. Containers are chosen by febe.ci.prova (and their exact name), the builders by name,
// and an image only by its local name febe-ci:<run>, never by id and never forced.
Assert.IsFalse(ProvenanceLabelFilter().IsMatch(cleanup), "the cleanup filters on febe.ci.prova only");
foreach (var line in cleanup.Split('\n').Where(l => l.Contains("docker ps", StringComparison.Ordinal)))
{
Assert.IsTrue(
line.Contains("--filter \"label=febe.ci.prova", StringComparison.Ordinal) || line.Contains("--filter \"name=buildx_buildkit_febe-ci-\"", StringComparison.Ordinal) || line.Contains("--filter \"ancestor=", StringComparison.Ordinal),
$"«{line.Trim()}» lists containers without the mark of the tried container");
}
StringAssert.Contains(cleanup, "\"febe-prova-$valore\"", "the name must match the mark");
StringAssert.Contains(cleanup, "contenitori_di_prova \"\" exited created dead", "the sweeps take only stopped tried containers");
Assert.IsFalse(ForcedImageRemoval().IsMatch(cleanup), "an image is never removed by force");
StringAssert.Contains(cleanup, "[[ \"$riferimento\" =~ ^febe-ci:[0-9]+$ ]]");
var weekly = Workflow("pulizia.yml");
StringAssert.Contains(weekly, "schedule:");
StringAssert.Contains(weekly, "workflow_dispatch:");
StringAssert.Contains(weekly, "bash .gitea/scripts/pulizia-docker.sh settimanale");
}
[TestMethod]
public void TheTriedContainerNeverHasANetworkAndAlwaysCarriesTheMarkNoImageHas()
{
var smoke = Code(Script("prova-immagine.sh"));
var runs = DockerRun().Matches(smoke);
Assert.IsGreaterThanOrEqualTo(4, runs.Count);
foreach (Match run in runs)
{
StringAssert.Contains(run.Value, "--network none", "rule 1: the image under test cannot reach any site");
StringAssert.Contains(run.Value, "\"${etichette[@]}\"", "every tried container carries the mark the cleanup looks for");
}
StringAssert.Contains(smoke, "etichette=(--label \"febe.ci.prova=$esecuzione\")");
StringAssert.Contains(smoke, "nome=\"febe-prova-$esecuzione\"");
// Docker copies the labels of an image into every container made from it: the mark must never be in an image.
Assert.DoesNotContain("febe.ci.prova", Code(Script("costruisci-immagine.sh")));
Assert.DoesNotContain("febe.ci.prova", Code(Read(Repository.PathOf("docker", "Dockerfile"))));
}
[TestMethod]
[Timeout(180_000, CooperativeCancellation = true)]
public async Task OnADaemonSharedWithARealFebeTheCleanupTakesOnlyWhatTheCiMade()
{
var script = CiPath("scripts", "pulizia-docker.sh");
var bash = BashForScripts();
if (bash is null)
{
Assert.Inconclusive("Manca bash (su Windows serve Git Bash): la prova della pulizia su un demone finto si salta.");
}
Assert.IsTrue(File.Exists(script));
// At the start or the end of a run (a release run again keeps its id, so the published image has the same
// febe.ci.run as the run): only the tried container, the local name and the builder of that run.
var run = await RunCleanupAsync(bash, FakeDaemon.Full, "esecuzione", "777");
Assert.AreEqual(0, run.Code, run.Report);
Assert.DoesNotContain("::warning::", run.Output, run.Report);
CollectionAssert.AreEquivalent(FakeDaemon.ContainersOf(FakeDaemon.Full).Except(["c-prova-777", "b-777"]).ToList(), run.Containers, run.Report);
CollectionAssert.AreEquivalent(FakeDaemon.ImagesWithout777(), run.Images, run.Report);
CollectionAssert.AreEquivalent(FakeDaemon.Volumes.Except(["buildx_buildkit_febe-ci-7770_state"]).ToList(), run.Volumes, run.Report);
// Leftovers of interrupted runs: stopped tried containers, febe-ci images and builders older than 90 minutes.
var leftovers = await RunCleanupAsync(bash, FakeDaemon.Full, "residui", "90");
Assert.AreEqual(0, leftovers.Code, leftovers.Report);
CollectionAssert.AreEquivalent(FakeDaemon.ContainersOf(FakeDaemon.Full).Except(["c-prova-555", "b-vecchio"]).ToList(), leftovers.Containers, leftovers.Report);
CollectionAssert.AreEquivalent(FakeDaemon.ImagesWithout777("img-ci555"), leftovers.Images, leftovers.Report);
CollectionAssert.AreEquivalent(FakeDaemon.Volumes.Except(["buildx_buildkit_febe-ci-4560_state"]).ToList(), leftovers.Volumes, leftovers.Report);
StringAssert.Contains(leftovers.Output, "::warning::Il contenitore di prova febe-prova-556 è acceso", "a running tried container is reported, not removed");
StringAssert.Contains(leftovers.Output, "::warning::Il contenitore buildx_buildkit_febe-ci-4570 non è un builder buildx", leftovers.Report);
// Every week, on a daemon without anything odd: the same, the old febe:ci and the dangling images older than
// 72 hours that no container uses. Green.
var weekly = await RunCleanupAsync(bash, FakeDaemon.Clean, "settimanale");
Assert.AreEqual(0, weekly.Code, weekly.Report);
CollectionAssert.AreEquivalent(FakeDaemon.ContainersOf(FakeDaemon.Clean).Except(["c-prova-555", "b-vecchio"]).ToList(), weekly.Containers, weekly.Report);
CollectionAssert.AreEquivalent(FakeDaemon.ImagesWithout777("img-ci555", "img-ci556", "img-legacy", "img-penzolante-vecchia"), weekly.Images, weekly.Report);
// With something left for a person to look at, the weekly cleanup goes red.
var noticed = await RunCleanupAsync(bash, FakeDaemon.Full, "settimanale");
Assert.AreEqual(1, noticed.Code, noticed.Report);
CollectionAssert.Contains(noticed.Containers, "c-prova-556");
CollectionAssert.Contains(noticed.Containers, "c-febe-vero");
}
/// <summary>
/// The daemon the cleanup runs against in <see cref="OnADaemonSharedWithARealFebeTheCleanupTakesOnlyWhatTheCiMade"/>
/// (format in fake-docker.sh). A real Febe started from :latest and one from :main carry the febe.ci.* labels of
/// their images, as Docker gives them; the image of the release also has the local name of run 777.
/// </summary>
private static class FakeDaemon
{
public static readonly string[] Full =
[
"c-febe-vero|febe|running|43200|192.168.30.23:3000/alby96/febe:latest|img-rilascio|febe.ci.workflow=rilascio,febe.ci.run=777,febe.ci.ref=v0.1.0",
"c-febe-fermo|febe-main|exited|43200|192.168.30.23:3000/alby96/febe:main|img-main|febe.ci.workflow=verifica,febe.ci.run=888",
"c-febe-antico|febe-antico|exited|20000|img-penzolante-in-uso|img-penzolante-in-uso|febe.ci.run=111",
"c-prova-777|febe-prova-777|running|5|febe-ci:777|img-rilascio|febe.ci.workflow=rilascio,febe.ci.run=777,febe.ci.prova=777",
"c-prova-555|febe-prova-555|exited|300|febe-ci:555|img-ci555|febe.ci.run=555,febe.ci.prova=555",
"c-prova-556|febe-prova-556|running|300|febe-ci:556|img-ci556|febe.ci.run=556,febe.ci.prova=556",
"c-prova-557|febe-prova-557|exited|10|febe-ci:557|img-ci557|febe.ci.run=557,febe.ci.prova=557",
"c-nome-strano|febe-prova-558-bis|exited|300|encelado:latest|img-encelado|febe.ci.prova=558",
"c-segno-diverso|febe-prova-559|exited|300|encelado:latest|img-encelado|febe.ci.prova=560",
"c-senza-segno|febe-prova-561|exited|300|encelado:latest|img-encelado|",
"c-encelado|encelado|exited|5000|encelado:latest|img-encelado|",
"b-vecchio|buildx_buildkit_febe-ci-4560|running|300|moby/buildkit:buildx-stable-1|img-buildkit|",
"b-finto|buildx_buildkit_febe-ci-4570|running|300|encelado:latest|img-encelado|",
"b-giovane|buildx_buildkit_febe-ci-7890|running|10|moby/buildkit:buildx-stable-1|img-buildkit|",
"b-altro|altro_buildx_buildkit_febe-ci-10|running|300|moby/buildkit:buildx-stable-1|img-buildkit|",
"b-777|buildx_buildkit_febe-ci-7770|running|20|moby/buildkit:buildx-stable-1|img-buildkit|",
];
/// <summary>The same daemon without the running tried container and the builder that is not one.</summary>
public static readonly string[] Clean = [.. Full.Where(c => !c.StartsWith("c-prova-556|", StringComparison.Ordinal) && !c.StartsWith("b-finto|", StringComparison.Ordinal))];
public static readonly string[] Images =
[
"img-rilascio|192.168.30.23:3000/alby96/febe:latest,192.168.30.23:3000/alby96/febe:0.1.0,febe-ci:777|43200|febe.ci.run=777",
"img-main|192.168.30.23:3000/alby96/febe:main|43200|febe.ci.run=888",
"img-ci555|febe-ci:555|300|febe.ci.run=555",
"img-ci556|febe-ci:556|300|febe.ci.run=556",
"img-ci557|febe-ci:557|10|febe.ci.run=557",
"img-penzolante-febe||300|febe.ci.run=999",
"img-penzolante-vecchia||6000|",
"img-penzolante-in-uso||20000|febe.ci.run=111",
"img-encelado|encelado:latest|5000|",
"img-buildkit|moby/buildkit:buildx-stable-1|50000|",
"img-legacy|febe:ci|6000|",
];
public static readonly string[] Volumes =
[
"buildx_buildkit_febe-ci-4560_state",
"buildx_buildkit_febe-ci-4570_state",
"buildx_buildkit_febe-ci-7890_state",
"buildx_buildkit_febe-ci-7770_state",
"encelado-dati",
];
public static List<string> ContainersOf(string[] world) => [.. world.Select(c => c[..c.IndexOf('|', StringComparison.Ordinal)])];
/// <summary>
/// «id|names» of each image once febe-ci:777 is gone (the image of the release keeps its registry names), without
/// the images given.
/// </summary>
public static List<string> ImagesWithout777(params string[] gone) =>
[
.. Images
.Select(i => string.Join('|', i.Split('|')[..2]).Replace(",febe-ci:777", string.Empty, StringComparison.Ordinal))
.Where(i => !gone.Contains(i[..i.IndexOf('|', StringComparison.Ordinal)])),
];
}
private sealed record CleanupRun(int Code, string Output, string Errors, List<string> Containers, List<string> Images, List<string> Volumes)
{
public string Report => $"codice {Code}\n{Output}\n{Errors}";
}
/// <summary>
/// pulizia-docker.sh against the fake daemon. DOCKER_HOST points nowhere: even if a real docker client came first on
/// the PATH it could not reach a daemon, and the test fails because the fake recorded no call.
/// </summary>
private async Task<CleanupRun> RunCleanupAsync(string bash, string[] containers, params string[] arguments)
{
using var world = new TempFolder("febe-pulizia");
var bin = world.Combine("bin");
Directory.CreateDirectory(bin);
var docker = Path.Combine(bin, "docker");
File.Copy(Repository.PathOf("tests", "Febe.Tests", "Packaging", "fake-docker.sh"), docker);
if (!OperatingSystem.IsWindows())
{
File.SetUnixFileMode(docker, UnixFileMode.UserRead | UnixFileMode.UserWrite | UnixFileMode.UserExecute);
}
await WriteLinesAsync(world.Combine("containers"), containers);
await WriteLinesAsync(world.Combine("images"), FakeDaemon.Images);
await WriteLinesAsync(world.Combine("volumes"), FakeDaemon.Volumes);
var start = new ProcessStartInfo(bash)
{
WorkingDirectory = Repository.Root()!,
RedirectStandardOutput = true,
RedirectStandardError = true,
StandardOutputEncoding = System.Text.Encoding.UTF8,
StandardErrorEncoding = System.Text.Encoding.UTF8,
};
start.ArgumentList.Add(".gitea/scripts/pulizia-docker.sh");
foreach (var argument in arguments)
{
start.ArgumentList.Add(argument);
}
start.Environment["PATH"] = bin + Path.PathSeparator + Environment.GetEnvironmentVariable("PATH");
start.Environment["FAKE_DOCKER_WORLD"] = world.Path.Replace('\\', '/');
start.Environment["DOCKER_HOST"] = OperatingSystem.IsWindows() ? "npipe:////./pipe/febe-nessun-demone" : "unix:///nonexistent/febe-nessun-demone.sock";
start.Environment.Remove("DOCKER_CONTEXT");
using var process = Process.Start(start)!;
var output = process.StandardOutput.ReadToEndAsync(TestContext.CancellationToken);
var errors = process.StandardError.ReadToEndAsync(TestContext.CancellationToken);
await process.WaitForExitAsync(TestContext.CancellationToken);
var result = new CleanupRun(
process.ExitCode,
(await output).Replace("\r\n", "\n", StringComparison.Ordinal),
await errors,
FakeDaemon.ContainersOf([.. await ReadLinesAsync(world.Combine("containers"))]),
[.. (await ReadLinesAsync(world.Combine("images"))).Select(i => string.Join('|', i.Split('|')[..2]))],
await ReadLinesAsync(world.Combine("volumes")));
var calls = world.Combine("calls");
Assert.IsTrue(File.Exists(calls) && (await File.ReadAllTextAsync(calls, TestContext.CancellationToken)).Contains("docker ps", StringComparison.Ordinal), $"the fake docker client was not the one called\n{result.Report}");
Assert.DoesNotContain("unexpected call", result.Errors, result.Report);
return result;
}
private async Task WriteLinesAsync(string path, IEnumerable<string> lines) =>
await File.WriteAllTextAsync(path, string.Concat(lines.Select(line => line + "\n")), TestContext.CancellationToken);
private async Task<List<string>> ReadLinesAsync(string path) =>
[.. (await File.ReadAllTextAsync(path, TestContext.CancellationToken)).Split('\n', StringSplitOptions.RemoveEmptyEntries)];
/// <summary>bash for the scripts of the CI: the system one on Linux, Git Bash on Windows (not the one of WSL).</summary>
private static string? BashForScripts()
{
if (OperatingSystem.IsWindows())
{
var git = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles), "Git", "bin", "bash.exe");
return File.Exists(git) ? git : null;
}
return new[] { "/bin/bash", "/usr/bin/bash" }.FirstOrDefault(File.Exists);
}
/// <summary>The workflows and the scripts of the CI, by name.</summary>
private static List<(string Name, string Text)> AllCiFiles() =>
[.. Directory.EnumerateFiles(CiPath("workflows")).Concat(Directory.EnumerateFiles(CiPath("scripts")))
.Select(file => (Path.GetFileName(file), Read(file)))];
private static string Workflow(string name) => Read(CiPath("workflows", name));
private static string Script(string name) => Read(CiPath("scripts", name));
private static string Read(string path) => File.ReadAllText(path).Replace("\r\n", "\n", StringComparison.Ordinal);
/// <summary>A path under .gitea; inconclusive in the build of the image, whose context leaves .gitea out.</summary>
private static string CiPath(params string[] parts)
{
var path = Repository.PathOf([".gitea", .. parts]);
var root = Repository.Root()!;
if (!File.Exists(path) && !Directory.Exists(path) && !Directory.Exists(Path.Combine(root, ".git")) && !File.Exists(Path.Combine(root, ".git")))
{
Assert.Inconclusive("Questa copia del repository non ha .gitea/ (costruzione dell'immagine Docker).");
}
return path;
}
/// <summary>The text without comment lines (YAML and shell): what runs, not what the comments say.</summary>
private static string Code(string text) =>
string.Join('\n', text.Replace("\r\n", "\n", StringComparison.Ordinal).Split('\n').Where(line => !line.TrimStart().StartsWith('#')));
/// <summary>The block of a job: from « name:» to the next job.</summary>
private static string Job(string workflow, string name)
{
var match = Regex.Match(workflow, $@"^ {Regex.Escape(name)}:\n(?<body>(?:(?: .*|\s*)\n)*)", RegexOptions.Multiline);
Assert.IsTrue(match.Success, $"manca il lavoro {name}");
return match.Groups["body"].Value;
}
/// <summary>The block of a step, from its «- name:» to the next step.</summary>
private static string Step(string job, string name)
{
var start = job.IndexOf("- name: " + name, StringComparison.Ordinal);
Assert.IsGreaterThanOrEqualTo(0, start, $"manca il passo «{name}»");
var next = job.IndexOf("\n - ", start + 1, StringComparison.Ordinal);
return next < 0 ? job[start..] : job[start..next];
}
[GeneratedRegex(@"(?<=^jobs:\n(?:.*\n)*?)^ (?<name>[a-z][\w-]*):$", RegexOptions.Multiline)]
private static partial Regex JobHeader();
[GeneratedRegex(@"dotnet test(?:\s+(?<target>[^\s-][^\s]*))?")]
private static partial Regex DotnetTest();
[GeneratedRegex(@"(?m)^\s*set\s+-[a-wyz]*x|\bbash\s+-x\b")]
private static partial Regex Trace();
[GeneratedRegex(@"\b(?:echo|printf)\b")]
private static partial Regex Printing();
[GeneratedRegex(@"\$\{?(?:TOKEN|FEBE_PASSWORD|AUTH|REGISTRY_TOKEN|PASSWORD)\b")]
private static partial Regex SecretReference();
[GeneratedRegex(@"\b[0-9a-f]{64}\b")]
private static partial Regex Sha256();
[GeneratedRegex(@"docker (?:image|container|volume|builder|system) prune")]
private static partial Regex ImagePrune();
[GeneratedRegex(@"docker run\b(?:[^\n]*\\\n)*[^\n]*")]
private static partial Regex DockerRun();
[GeneratedRegex(@"label=febe\.ci\.(?!prova\b)")]
private static partial Regex ProvenanceLabelFilter();
[GeneratedRegex(@"docker (?:image rm|rmi)\s+(?:-\w+\s+)*-\w*f")]
private static partial Regex ForcedImageRemoval();
}
+302
View File
@@ -0,0 +1,302 @@
#!/usr/bin/env bash
# A fake docker client for PipelineTests: .gitea/scripts/pulizia-docker.sh runs against a small daemon written in text
# files, and the test reads what is left. No daemon, no network. It models only what the cleanup relies on, the way
# Docker does it:
# - filters of «ps»: label filters must all match, the values of any other key are alternatives (status, name as a
# regular expression, ancestor by name or id);
# - «rm» refuses a running container without -f;
# - «image rm <name>» only untags when the image has other names, and refuses an image a container uses (always if the
# container runs, without -f if it is stopped);
# - «image prune --filter until=72h» takes only images without a name, older than 72 hours, used by no container.
# Any other call is an error (exit 3), so the test sees every command the cleanup starts to use.
#
# $FAKE_DOCKER_WORLD/containers id|name|state|minutes ago|image as given to «docker run»|image id|labels
# (labels as Docker gives them to the container: those of the image plus those of «run»)
# $FAKE_DOCKER_WORLD/images id|names (comma separated; empty: dangling)|minutes ago|labels
# $FAKE_DOCKER_WORLD/volumes one name per line
# $FAKE_DOCKER_WORLD/calls every call, one per line (written here)
set -uo pipefail
world="${FAKE_DOCKER_WORLD:?}"
printf 'docker %s\n' "$*" >> "$world/calls"
now=$(date -u +%s)
touch "$world/containers" "$world/images" "$world/volumes"
unexpected() {
echo "fake docker: unexpected call: $*" >&2
exit 3
}
created() { date -u -d "@$((now - $1 * 60))" +%Y-%m-%dT%H:%M:%S.123456789Z; }
# The value of a label, or $3 when it is missing («docker ps» prints nothing, «inspect» prints <no value>).
label_value() {
local labels=",$1," key="$2" rest
[[ "$labels" == *",$key="* ]] || { echo "${3:-}"; return; }
rest="${labels#*,"$key"=}"
echo "${rest%%,*}"
}
has_label() {
local labels=",$1," want="$2"
if [[ "$want" == *=* ]]; then
[[ "$labels" == *",$want,"* ]]
else
[[ "$labels" == *",$want="* ]]
fi
}
# Image id for a name or an id; empty when there is none.
resolve_image() {
local ref="$1" id names age labels
while IFS='|' read -r id names age labels; do
[[ -n "$id" ]] || continue
if [[ "$id" == "$ref" || ",$names," == *",$ref,"* ]]; then
echo "$id"
return
fi
done < "$world/images"
}
# The image line for an id; empty when there is none.
image_line() {
local line
while IFS= read -r line; do
[[ -n "$line" && "${line%%|*}" == "$1" ]] && { echo "$line"; return; }
done < "$world/images"
}
# The container line for an id or a name; empty when there is none.
find_container() {
local ref="$1" line id name rest
while IFS= read -r line; do
IFS='|' read -r id name rest <<< "$line"
if [[ -n "$id" && ("$id" == "$ref" || "$name" == "$ref") ]]; then
echo "$line"
return
fi
done < "$world/containers"
}
# Rewrites a world file without the lines whose first field is $2.
drop() {
local file="$1" id="$2" line
: > "$file.new"
while IFS= read -r line; do
[[ "${line%%|*}" == "$id" ]] || printf '%s\n' "$line" >> "$file.new"
done < "$file"
mv "$file.new" "$file"
}
used_by() {
local image="$1" want="$2" id name state age config image_id labels
while IFS='|' read -r id name state age config image_id labels; do
[[ -n "$id" && "$image_id" == "$image" ]] || continue
[[ "$want" == any || "$state" == running ]] && return 0
done < "$world/containers"
return 1
}
matches() {
local name="$1" state="$2" image_id="$3" labels="$4"
shift 4
local -A seen=() ok=()
local filter key value
for filter in "$@"; do
key="${filter%%=*}"
value="${filter#*=}"
case "$key" in
label) has_label "$labels" "$value" || return 1 ;;
status) seen[$key]=1; [[ "$state" == "$value" ]] && ok[$key]=1 ;;
name) seen[$key]=1; [[ "$name" =~ $value ]] && ok[$key]=1 ;;
ancestor) seen[$key]=1; [[ -n "$image_id" && "$(resolve_image "$value")" == "$image_id" ]] && ok[$key]=1 ;;
*) unexpected "filter $filter" ;;
esac
done
for key in "${!seen[@]}"; do
[[ -n "${ok[$key]:-}" ]] || return 1
done
return 0
}
ps_command() {
local quiet=0 format='{{.ID}} {{.Names}}' filters=()
while (($#)); do
case "$1" in
-a | --no-trunc) ;;
-q) quiet=1 ;;
--filter) filters+=("$2"); shift ;;
--format) format="$2"; shift ;;
*) unexpected "ps $1" ;;
esac
shift
done
local id name state age config image_id labels out key
while IFS='|' read -r id name state age config image_id labels; do
[[ -n "$id" ]] || continue
matches "$name" "$state" "$image_id" "$labels" "${filters[@]}" || continue
if ((quiet)); then
echo "$id"
continue
fi
out="${format//"{{.ID}}"/$id}"
out="${out//"{{.Names}}"/$name}"
while [[ "$out" =~ \{\{\.Label\ \"([^\"]+)\"\}\} ]]; do
key="${BASH_REMATCH[1]}"
out="${out/"${BASH_REMATCH[0]}"/$(label_value "$labels" "$key" "")}"
done
printf '%s\n' "$out"
done < "$world/containers"
return 0
}
container_inspect() {
local format=""
[[ "${1:-}" == -f ]] && { format="$2"; shift 2; }
local line id name state age config image_id labels
line=$(find_container "${1:?}")
[[ -n "$line" ]] || { echo "Error: No such container: $1" >&2; exit 1; }
IFS='|' read -r id name state age config image_id labels <<< "$line"
case "$format" in
"") echo "[{\"Id\": \"$id\"}]" ;;
"{{.Created}}") created "$age" ;;
"{{.Config.Image}}") echo "$config" ;;
"{{.Name}}") echo "/$name" ;;
'{{index .Config.Labels "febe.ci.prova"}}') label_value "$labels" febe.ci.prova "<no value>" ;;
*) unexpected "container inspect -f $format" ;;
esac
}
rm_command() {
local force=0
while [[ "${1:-}" == -* ]]; do
case "$1" in
-f) force=1 ;;
-v) ;;
*) unexpected "rm $1" ;;
esac
shift
done
local line id name state rest
line=$(find_container "${1:?}")
[[ -n "$line" ]] || { echo "Error: No such container: $1" >&2; exit 1; }
IFS='|' read -r id name state rest <<< "$line"
if [[ "$state" == running && "$force" == 0 ]]; then
echo "Error: cannot remove container \"/$name\": container is running: stop the container before removing or force remove" >&2
exit 1
fi
drop "$world/containers" "$id"
}
image_ls() {
local format="" reference=""
while (($#)); do
case "$1" in
--filter) [[ "$2" == reference=* ]] || unexpected "image ls --filter $2"; reference="${2#reference=}"; shift ;;
--format) format="$2"; shift ;;
*) unexpected "image ls $1" ;;
esac
shift
done
[[ "$format" == "{{.Repository}}:{{.Tag}}" ]] || unexpected "image ls --format $format"
local id names age labels tag
while IFS='|' read -r id names age labels; do
[[ -n "$id" ]] || continue
IFS=',' read -r -a tags <<< "$names"
for tag in "${tags[@]}"; do
[[ -z "$reference" || "${tag%:*}" == "$reference" || "$tag" == "$reference" ]] && echo "$tag"
done
done < "$world/images"
return 0
}
image_inspect() {
local format=""
[[ "${1:-}" == -f ]] && { format="$2"; shift 2; }
local wanted id names age labels
wanted=$(resolve_image "${1:?}")
[[ -n "$wanted" ]] || { echo "Error: No such image: $1" >&2; exit 1; }
while IFS='|' read -r id names age labels; do
[[ "$id" == "$wanted" ]] || continue
case "$format" in
"") echo "[{\"Id\": \"$id\"}]" ;;
"{{.Created}}") created "$age" ;;
"{{len .RepoTags}}") if [[ -z "$names" ]]; then echo 0; else IFS=',' read -r -a tags <<< "$names"; echo "${#tags[@]}"; fi ;;
*) unexpected "image inspect -f $format" ;;
esac
done < "$world/images"
}
image_rm() {
local force=0
[[ "${1:-}" == -f ]] && { force=1; shift; }
local ref="${1:?}" wanted id names age labels left="" tag
wanted=$(resolve_image "$ref")
[[ -n "$wanted" ]] || { echo "Error: No such image: $ref" >&2; exit 1; }
IFS='|' read -r id names age labels <<< "$(image_line "$wanted")"
tags=()
[[ -z "$names" ]] || IFS=',' read -r -a tags <<< "$names"
if [[ "$ref" != "$id" && ${#tags[@]} -gt 1 ]]; then
for tag in "${tags[@]}"; do [[ "$tag" == "$ref" ]] || left="${left:+$left,}$tag"; done
drop "$world/images" "$id"
printf '%s|%s|%s|%s
' "$id" "$left" "$age" "$labels" >> "$world/images"
echo "Untagged: $ref"
return 0
fi
if [[ "$ref" == "$id" && ${#tags[@]} -gt 1 && "$force" == 0 ]]; then
echo "Error: conflict: unable to delete $id (must be forced) - image is referenced in multiple repositories" >&2
exit 1
fi
if used_by "$id" running || { [[ "$force" == 0 ]] && used_by "$id" any; }; then
echo "Error: conflict: unable to remove repository reference \"$ref\" - container is using its referenced image" >&2
exit 1
fi
drop "$world/images" "$id"
echo "Deleted: $id"
}
image_prune() {
[[ "$*" == "-f --filter until=72h" ]] || unexpected "image prune $*"
local id names age labels gone=()
while IFS='|' read -r id names age labels; do
[[ -n "$id" && -z "$names" && "$age" -ge $((72 * 60)) ]] || continue
used_by "$id" any || gone+=("$id")
done < "$world/images"
for id in "${gone[@]}"; do
drop "$world/images" "$id"
echo "deleted: $id"
done
echo "Total reclaimed space: 0B"
}
case "${1:-}" in
ps) shift; ps_command "$@" ;;
container) [[ "${2:-}" == inspect ]] || unexpected "$*"; shift 2; container_inspect "$@" ;;
rm) shift; rm_command "$@" ;;
image)
sub="${2:-}"
shift 2
case "$sub" in
ls) image_ls "$@" ;;
inspect) image_inspect "$@" ;;
rm) image_rm "$@" ;;
prune) image_prune "$@" ;;
*) unexpected "image $sub" ;;
esac
;;
buildx) [[ "${2:-}" == rm ]] || unexpected "$*"; echo "ERROR: no builder \"${4:-}\" found" >&2; exit 1 ;;
volume)
case "${2:-}" in
inspect) grep -qxF -- "${3:?}" "$world/volumes" || { echo "Error: no such volume: $3" >&2; exit 1; } ;;
rm)
[[ "${3:-}" == -f ]] || unexpected "$*"
grep -vxF -- "${4:?}" "$world/volumes" > "$world/volumes.new"
mv "$world/volumes.new" "$world/volumes"
;;
*) unexpected "$*" ;;
esac
;;
system) [[ "${2:-}" == df ]] || unexpected "$*"; echo "TYPE TOTAL ACTIVE SIZE RECLAIMABLE" ;;
*) unexpected "$*" ;;
esac
@@ -9,6 +9,7 @@ using Febe.Core.Storage;
using Febe.SitoDiProva;
using Febe.Tests.Alerts.Support;
using Febe.Tests.Server.Support;
using Febe.Tests.Support;
using Febe.Web.Connection;
namespace Febe.Tests.Server;
@@ -20,6 +21,7 @@ namespace Febe.Tests.Server;
/// the remote view. Never Instagram: the browser only sees 127.0.0.1.
/// </summary>
[TestClass]
[TestCategory(SyntheticSite.Category)]
[DoNotParallelize]
public sealed partial class ServerEndToEndTests
{
@@ -60,7 +60,7 @@ internal sealed class ServerTestBed : IAsyncDisposable
public static async Task<ServerTestBed> StartAsync(bool autoLogin = false, double factor = 10, HttpMessageHandler? telegram = null, IFreeSpaceProbe? freeSpace = null)
{
var temp = new TempFolder("server");
var site = await TestSite.StartAsync(new TestSiteOptions());
var site = await SyntheticSite.StartAsync();
var zone = NoonZone();
var clock = new CompressedClock(factor, zone);
var options = new ServerOptions
+46
View File
@@ -0,0 +1,46 @@
using System.Globalization;
using Febe.SitoDiProva;
namespace Febe.Tests.Support;
/// <summary>
/// The one way the tests start the local test site (spec §14.2), so that a run can choose the seed of its synthetic
/// world: <see cref="Variable"/> when it is set, <see cref="DefaultSeed"/> otherwise (nothing changes when it is unset).
/// The CI runs the whole suite with the default seed, then the tests of <see cref="Category"/> again with a seed of
/// its own that it prints in the log: a failure is reproduced by setting the same variable.
/// </summary>
internal static class SyntheticSite
{
/// <summary>Environment variable with the seed of the synthetic world.</summary>
public const string Variable = "FEBE_SEME_PROVA";
/// <summary>The seed when the variable is not set: the one of the command-line site and of the cleaned samples.</summary>
public const int DefaultSeed = 13;
/// <summary>Test category of the tests whose world comes from the seed (the CI runs them with a second seed).</summary>
public const string Category = "SitoDiProva";
/// <summary>The seed of this run.</summary>
public static int Seed => ParseSeed(Environment.GetEnvironmentVariable(Variable));
/// <summary>Starts the test site with the seed of this run, and says which one in the output of the test.</summary>
public static Task<TestSite> StartAsync()
{
var seed = Seed;
Console.WriteLine($"Sito di prova con il seme {seed.ToString(CultureInfo.InvariantCulture)} (si cambia con {Variable}).");
return TestSite.StartAsync(new TestSiteOptions { Seed = seed });
}
/// <summary>The seed written in <paramref name="value"/>: the default when it is empty, an error when it is not a number.</summary>
public static int ParseSeed(string? value)
{
if (string.IsNullOrWhiteSpace(value))
{
return DefaultSeed;
}
return int.TryParse(value.Trim(), NumberStyles.AllowLeadingSign, CultureInfo.InvariantCulture, out var seed)
? seed
: throw new InvalidOperationException($"{Variable} deve essere un numero intero (fra -2147483648 e 2147483647), non «{value}».");
}
}
+6 -1
View File
@@ -15,7 +15,11 @@ dotnet run --project tools/Febe.SitoDiProva -- [--porta 8481] [--porta-cdn 8482]
del sito non gli arrivano.
- I dati sono **sintetici** e si generano da un seme: stesso seme, stessi account, post, codici e didascalie. Le date
sono relative al momento dell'avvio (le storie sono attive per 24 ore da lì).
- Le prove automatiche lo avviano dentro il processo con `TestSite.StartAsync(...)` (porte libere scelte da sole).
- Le prove automatiche lo avviano dentro il processo con `SyntheticSite.StartAsync()` (`tests/Febe.Tests/Support`), che
chiama `TestSite.StartAsync(...)` con porte libere scelte da sole e il seme della variabile `FEBE_SEME_PROVA` (13 se
manca). La CI fa girare tutte le prove con il seme 13 e quelle della categoria `SitoDiProva` anche con un seme
diverso a ogni esecuzione, scritto nel registro; per rifare una prova fallita con quel seme:
`FEBE_SEME_PROVA=<seme> dotnet test tests/Febe.Tests --filter "TestCategory=SitoDiProva"`.
- Campioni grezzi per le prove dei lettori: `dotnet run --project tools/Febe.SitoDiProva -- campioni --cartella <fuori dal repository>`
(poi `febe-sonda ripulisci`, vedi `tests/Febe.Tests/campioni/prova/LEGGIMI.md`).
@@ -49,6 +53,7 @@ storie attive di Marta è anche nella raccolta «Estate», con lo **stesso ident
| `/post/{codice}/` | pagina di un post, con tutti i file |
| `/verifica` | pagina di verifica, semplice testo |
| `/sessione-scaduta` | pagina di sessione terminata, semplice testo (non è un modulo di accesso) |
| `/benvenuto` | quella che Febe apre come «pagina di accesso» del sito di prova (Collegamento): semplice testo, nessun modulo; la visita apre la sessione, come ogni pagina |
La mappa dei bersagli di queste pagine è `src/Febe.Core/Config/bersagli.prova.json` (copiata accanto al programma
in `config/`), i segnali di arresto sono in `segnali.prova.json`.
+7
View File
@@ -76,6 +76,13 @@ internal static class Pages
public static string NotFound() => Layout("Pagina non trovata", "nessuna", string.Empty, "<h1>Pagina non trovata</h1>");
/// <summary>What Febe opens as the login page of the test site: there is nothing to type, the visit opens the session.</summary>
public static string Welcome() => Layout("Benvenuto", "nessuna", string.Empty, """
<h1>Benvenuto nel sito di prova</h1>
<p>Qui non c'è nessuna password: il sito di prova ti considera entrato appena apri una sua pagina. Torna a Febe e
premi «Ho finito».</p>
""");
private static string Layout(string title, string page, string attributes, string main) => $"""
<!doctype html>
<html lang="it">
+4
View File
@@ -215,6 +215,10 @@ public sealed class TestSite : IAsyncDisposable
case []:
html = Pages.Home();
break;
case ["benvenuto"]:
// The «pagina di accesso» Febe opens on the test site (LoginUrl): the cookie above already opened the session.
html = Pages.Welcome();
break;
case ["profilo", var user, ..] when World.FindByUsername(user) is null:
html = Pages.ProfileNotFound(user);
status = 404;