Files
Febe/.gitea/workflows/verifica.yml
T
Alby96andClaude Opus 5.5 483d57b89a Pulizia: dopo ogni esecuzione la cache se ne va solo se nessuno la usa da 24 ore
Alla fine di ogni lavoro «immagine», cioè a ogni push di ogni ramo,
«docker builder prune -f» senza filtro toglieva dal builder del demone
tutta la cache che nessuna immagine condivide, di qualunque età e di
tutti i progetti: gli strati intermedi e le cache montate che Encelado o
Mimante avevano usato mezz'ora prima. Alla cache di Febe non serviva
(stava nel builder dell'esecuzione, già tolto) e annullava la finestra
di 24 ore della pulizia del lunedì (rilievo della revisione).

Ora anche dopo ogni esecuzione «--filter until=24h», che BuildKit
confronta con l'ultimo uso: una costruzione che si ripete almeno una
volta al giorno ritrova la sua cache. Il compito chiedeva il comando
senza filtro; la scelta resta di Alberto, e per tornarci basta togliere
il filtro. Le immagini senza nome restano senza filtro, come prima.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-21 11:42:28 +02:00

315 lines
14 KiB
YAML

# 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, poi le immagini senza nome e la
# cache di costruzione penzolante non usata da 24 ore di tutti i progetti del demone.
#
# 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: ["**"]
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:
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
- uses: actions/setup-dotnet@v4
with:
dotnet-version: "10.0.x"
- 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: 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: Artefatti per Windows
uses: actions/upload-artifact@v3
with:
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
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
# 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: |
bash .gitea/scripts/pulizia-docker.sh residui 90
bash .gitea/scripts/pulizia-docker.sh esecuzione "$ESECUZIONE"
# 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: |
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"
# Poi, per tutti i progetti del demone, ciò che nessuno usa: immagini senza nome e cache di costruzione
# penzolante non usata da 24 ore. Non fa mai fallire il lavoro.
bash .gitea/scripts/pulizia-docker.sh penzolanti || echo "::warning::La pulizia di ciò che nessuno usa non è riuscita."