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>
315 lines
14 KiB
YAML
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."
|