CI aziendale: prove con dati sintetici, installatore e immagine a ogni push, scansioni e pulizia #2
No files matched your search
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
```
|
||||
@@ -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
|
||||
|
||||
-
|
||||
@@ -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
|
||||
|
||||
-
|
||||
Executable
+36
@@ -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; }
|
||||
Executable
+89
@@ -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."
|
||||
Executable
+48
@@ -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
|
||||
Executable
+87
@@ -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
|
||||
Executable
+226
@@ -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
|
||||
Executable
+106
@@ -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(/
/, "", s); gsub(/
/, " ", s); gsub(/'/, "\047", s); gsub(/"/, "\"", s)
|
||||
gsub(/</, "<", s); gsub(/>/, ">", s); gsub(/&/, "\\&", 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"
|
||||
Executable
+54
@@ -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
|
||||
Executable
+47
@@ -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"
|
||||
Executable
+60
@@ -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
|
||||
@@ -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
|
||||
@@ -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
@@ -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"
|
||||
@@ -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
@@ -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 \
|
||||
|
||||
@@ -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 |
|
||||
@@ -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
@@ -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.
|
||||
|
||||
|
||||
@@ -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();
|
||||
}
|
||||
@@ -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\"");
|
||||
|
||||
@@ -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();
|
||||
}
|
||||
@@ -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
|
||||
|
||||
@@ -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}».");
|
||||
}
|
||||
}
|
||||
@@ -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`.
|
||||
|
||||
@@ -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">
|
||||
|
||||
@@ -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;
|
||||
|
||||
Reference in new issue
Block a user