diff --git a/.gitea/scripts/pulizia-docker.sh b/.gitea/scripts/pulizia-docker.sh index 77305ee..8f20e85 100755 --- a/.gitea/scripts/pulizia-docker.sh +++ b/.gitea/scripts/pulizia-docker.sh @@ -47,8 +47,9 @@ # # Mai docker system prune, container prune, volume prune o network prune; mai image prune -a o builder prune -a senza # il filtro delle 24 ore; mai un contenitore, un volume o una rete che non sia della CI. Le immagini le toglie Docker -# stesso (image prune), che non tocca mai un'immagine usata da un contenitore, nemmeno fermo. Sul registro mai main, -# latest o una versione X.Y.Z: solo le etichette sha- della verifica. +# stesso (image prune), che non toglie mai un'immagine usata da un contenitore, nemmeno fermo; con -a, però, le toglie i +# nomi in più, e lo script li scrive (nella prova li stima, secondo lo store). Sul registro mai main, latest o una +# versione X.Y.Z: solo le etichette sha- della verifica. # # Nei modi «residui», «settimanale» e «completa» 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 @@ -431,8 +432,9 @@ resti_di_act_runner() { fi } -# Le immagini (identificativo) dei contenitori, accesi o fermi, tranne quelli che la pulizia toglierebbe. Solo -# lettura: serve all'elenco della prova. +# Le immagini dei contenitori, accesi o fermi, tranne quelli che la pulizia toglierebbe: «identificativo immagine» una +# per riga, l'immagine come la si è data a docker run (un nome o un identificativo). Solo lettura: serve all'elenco +# della prova. immagini_in_uso() { local elenco id nome elenco=$(docker ps -a --no-trunc --format '{{.ID}} {{.Names}}') || return 1 @@ -440,17 +442,77 @@ immagini_in_uso() { [[ -n "${id:-}" ]] || continue fra "$id" "${previsti[@]}" && continue fra "${nome#/}" "${previsti[@]}" && continue - docker container inspect -f '{{.Image}}' "$id" 2> /dev/null + docker container inspect -f '{{.Image}} {{.Config.Image}}' "$id" 2> /dev/null done <<< "$elenco" return 0 } +# Il nome completo di un nome d'immagine, come lo ordina Docker: docker.io/library/ o docker.io/ davanti ai nomi di +# Docker Hub scritti senza dominio, :latest se manca l'etichetta. +nome_completo() { + local nome="$1" primo + [[ "${nome##*/}" == *:* ]] || nome="$nome:latest" + if [[ "$nome" != */* ]]; then + echo "docker.io/library/$nome" + return + fi + primo="${nome%%/*}" + if [[ "$primo" == *.* || "$primo" == *:* || "$primo" == localhost ]]; then + echo "$nome" + else + echo "docker.io/$nome" + fi +} + +# In prova: i nomi che «image prune -a» toglierebbe a un'immagine che un contenitore usa (i nomi e le immagini dei +# contenitori, come li scrivono docker image ls e docker container inspect), uno per riga. L'immagine resta, ma i nomi +# in più no (moby). Con lo store classico Docker toglie i nomi in ordine alfabetico del nome completo e si ferma +# all'ultimo, l'unico che rifiuta di togliere perché un contenitore usa l'immagine (daemon/images/image_prune.go e +# image_delete.go, isSingleReference): può andarsene anche il nome da cui il contenitore è stato creato. Con containerd +# restano i nomi da cui i contenitori sono stati creati e, se uno la usa per identificativo e nessun nome resterebbe, +# l'ultimo in ordine alfabetico (daemon/containerd/image_prune.go). +nomi_che_perde() { + local id="$1" nomi="$2" configurazioni="$3" nome completo configurazione resto per_id=0 ordinati quanti + local -A protetti=() + local -a lista=() via=() + ordinati=$(while read -r nome; do + [[ -n "$nome" ]] && printf '%s %s\n' "$(nome_completo "$nome")" "$nome" + done <<< "$nomi" | LC_ALL=C sort) + quanti=$(grep -c . <<< "$ordinati") + ((quanti > 1)) || return 0 + if [[ "$store" != containerd ]]; then + sed '$d' <<< "$ordinati" | cut -d' ' -f2- + return 0 + fi + read -r -a lista <<< "$configurazioni" + for configurazione in "${lista[@]}"; do + if [[ "$id" == "$configurazione"* || "$id" == "sha256:$configurazione"* ]]; then + per_id=1 + elif [[ "$configurazione" == *@* ]]; then + [[ "${configurazione#*@}" == "$id" ]] && per_id=1 + resto="${configurazione%%@*}" + [[ "${resto##*/}" == *:* ]] && protetti[$(nome_completo "$resto")]=1 + else + protetti[$(nome_completo "$configurazione")]=1 + fi + done + while read -r completo nome; do + [[ -n "${protetti[$completo]:-}" ]] || via+=("$nome") + done <<< "$ordinati" + if ((per_id && ${#via[@]} == quanti)); then + unset "via[$((quanti - 1))]" + fi + ((${#via[@]} == 0)) || printf '%s\n' "${via[@]}" + return 0 +} + # In prova: le immagini che la potatura toglierebbe, con dimensione ed età. Nessun contenitore le usa (a parte quelli -# che questa pulizia toglierebbe) e sono state create più di N minuti fa; con «senza-nome» solo quelle senza nome. È -# una stima fatta qui: nella pulizia vera decide Docker (image prune). +# che questa pulizia toglierebbe) e sono state create più di N minuti fa; con «senza-nome» solo quelle senza nome. Con +# «tutte», di un'immagine che un contenitore usa, i nomi in più che Docker le toglierebbe. È una stima fatta qui: nella +# pulizia vera decide Docker (image prune). elenca_immagini() { - local minimo="$1" quali="$2" usate elenco id nome breve dimensione eta quante=0 - local -A nomi=() dimensioni=() aveva_nomi=() + local minimo="$1" quali="$2" usate elenco id nome breve dimensione eta quante=0 configurazione + local -A nomi=() elenco_nomi=() dimensioni=() aveva_nomi=() usata_da=() local ordine=() if ! usate=$(immagini_in_uso) \ || ! elenco=$(docker image ls --no-trunc --format '{{.ID}}|{{.Repository}}:{{.Tag}}|{{.Size}}'); then @@ -460,28 +522,46 @@ elenca_immagini() { if [[ "$store" != classico ]] && ((minimo > 0)); then echo " (l'età qui è quella dell'immagine, dalla costruzione; con lo store di containerd la pulizia vera conta da quando il nome è arrivato sul demone, e un nome riscaricato tiene la data di prima: l'elenco è solo indicativo)" fi + while read -r id configurazione; do + [[ -n "${id:-}" ]] || continue + usata_da[$id]="${usata_da[$id]:+${usata_da[$id]} }$configurazione" + done <<< "$usate" while IFS='|' read -r id nome dimensione; do [[ -n "${id:-}" ]] || continue if [[ -z "${dimensioni[$id]+x}" ]]; then ordine+=("$id") dimensioni[$id]="${dimensione:-?}" nomi[$id]="" + elenco_nomi[$id]="" fi [[ "$nome" == ":" ]] && continue aveva_nomi[$id]=1 fra "$nome" "${nomi_previsti[@]}" && continue nomi[$id]="${nomi[$id]:+${nomi[$id]}, }$nome" + [[ "$nome" == *":" ]] || elenco_nomi[$id]+="$nome"$'\n' done <<< "$elenco" for id in "${ordine[@]}"; do # Un'immagine i cui nomi la pulizia toglie qui sopra se ne va già con l'ultimo. [[ -n "${aveva_nomi[$id]:-}" && -z "${nomi[$id]}" ]] && continue + breve="${id#sha256:}" + if [[ -n "${usata_da[$id]+x}" ]]; then + # Un contenitore la usa: resta. Con -a, però, Docker le toglie i nomi in più. + [[ "$quali" == tutte && -n "${elenco_nomi[$id]}" ]] || continue + eta=$(eta_minuti "$(docker image inspect -f '{{.Created}}' "$id" 2> /dev/null)") + ((eta >= minimo)) || continue + while read -r nome; do + [[ -n "$nome" ]] || continue + echo " toglierei il nome $nome; l'immagine ${breve:0:12} resta, perché la usa un contenitore" + quante=$((quante + 1)) + conta "nomi tolti a immagini che restano" + done < <(nomi_che_perde "$id" "${elenco_nomi[$id]}" "${usata_da[$id]}") + continue + fi [[ "$quali" == senza-nome && -n "${aveva_nomi[$id]:-}" ]] && continue - grep -qxF -- "$id" <<< "$usate" && continue eta=$(eta_minuti "$(docker image inspect -f '{{.Created}}' "$id" 2> /dev/null)") ((eta >= minimo)) || continue nome="${nomi[$id]}" [[ -n "$nome" ]] || nome="un'immagine senza nome" - breve="${id#sha256:}" echo " toglierei $nome (${breve:0:12}) · ${dimensioni[$id]} · creata $(durata "$eta") fa" quante=$((quante + 1)) if [[ "$quali" == senza-nome ]]; then @@ -529,8 +609,9 @@ rileva_store() { esac } -numero_immagini() { - docker image ls --no-trunc --format '{{.ID}}' 2> /dev/null | sort -u | grep -c . +# Ogni immagine con ciascuno dei suoi nomi, «identificativo nome» una per riga (: se non ne ha). +immagini_e_nomi() { + docker image ls --no-trunc --format '{{.ID}} {{.Repository}}:{{.Tag}}' 2> /dev/null } # Lo spazio recuperato secondo Docker: «Total reclaimed space: 1.2GB» (docker) o «Total: 1.2GB» (buildx). @@ -540,17 +621,32 @@ spazio_recuperato() { echo "${riga:-0B}" } -# Una potatura di immagini di Docker: i nomi tolti, quante immagini e quanto spazio. Un errore è un avviso. +# Una potatura di immagini di Docker: i nomi tolti, quante immagini e quanto spazio. Un errore è un avviso. I nomi si +# confrontano prima e dopo: con -a Docker toglie anche i nomi in più di un'immagine che un contenitore usa e che resta, +# e il registro del lavoro lo dice. pota_immagini() { - local cosa="$1" uscita prima dopo recuperato + local cosa="$1" uscita prima dopo recuperato prima_nomi dopo_nomi dopo_id id nome breve shift - prima=$(numero_immagini) + prima_nomi=$(immagini_e_nomi) + prima=$(cut -d' ' -f1 <<< "$prima_nomi" | sort -u | grep -c .) if ! uscita=$("$@" 2>&1); then avviso "Non riesco a togliere le $cosa: $(tail -n 1 <<< "$uscita")" return 0 fi - grep '^untagged: ' <<< "$uscita" | grep -v '@sha256:' | sed 's/^untagged: / tolta /' - dopo=$(numero_immagini) + dopo_nomi=$(immagini_e_nomi) + dopo_id=$(cut -d' ' -f1 <<< "$dopo_nomi" | sort -u) + dopo=$(grep -c . <<< "$dopo_id") + while read -r id nome; do + [[ -n "${nome:-}" && "$nome" != *":" ]] || continue + grep -qxF -- "$id $nome" <<< "$dopo_nomi" && continue + if grep -qxF -- "$id" <<< "$dopo_id"; then + breve="${id#sha256:}" + echo " tolto il nome $nome; l'immagine ${breve:0:12} resta" + conta "nomi tolti a immagini che restano" + else + echo " tolta $nome" + fi + done <<< "$prima_nomi" recuperato=$(spazio_recuperato "$uscita") if [[ "$prima" =~ ^[0-9]+$ && "$dopo" =~ ^[0-9]+$ ]]; then echo " $cosa: $((prima - dopo)) tolte, $recuperato recuperati" diff --git a/.gitea/workflows/pulizia.yml b/.gitea/workflows/pulizia.yml index 467b5bf..47a2ebf 100644 --- a/.gitea/workflows/pulizia.yml +++ b/.gitea/workflows/pulizia.yml @@ -9,9 +9,9 @@ # febe-ci-, l'immagine febe:ci del vecchio flusso; # - i resti di act_runner: contenitori fermi, volumi e reti GITEA-ACTIONS-TASK-… che nessun contenitore usa, più # vecchi di 90 minuti; -# - le immagini che nessun contenitore usa, né acceso né fermo, create più di 24 ore fa, e la cache di costruzione del -# demone non usata da 24 ore. Le immagini di base (node:24-trixie, moby/buildkit, …) si riscaricano alla prima -# esecuzione che le chiede; +# - le immagini che nessun contenitore usa, né acceso né fermo, create più di 24 ore fa (di un'immagine in uso Docker +# toglie i nomi in più), e la cache di costruzione del demone non usata da 24 ore. Le immagini di base +# (node:24-trixie, moby/buildkit, …) si riscaricano alla prima esecuzione che le chiede; # - con il segreto REGISTRY_TOKEN, le etichette sha- del registro oltre le 10 più recenti; mai main, latest o X.Y.Z. # Mai system prune, container prune, volume prune o network prune; mai un contenitore, un volume o una rete che non sia # della CI. Un contenitore di prova ancora acceso si segnala e il lavoro diventa rosso; un rifiuto dell'API del diff --git a/docs/decisioni.md b/docs/decisioni.md index be0e414..8412530 100644 --- a/docs/decisioni.md +++ b/docs/decisioni.md @@ -287,3 +287,4 @@ Ogni scelta tecnica presa strada facendo, con data e motivo (specifica §15). | 2026-10-21 | `pulizia-docker.sh` gira con `BUILDX_BUILDER=default`: la cache che pota è quella del builder del demone | Con il plugin buildx `docker builder` diventa `docker buildx` (`cmd/docker/builder.go` del client Docker), che lavora sul builder corrente: nel lavoro «immagine» è quello dell'esecuzione, che `setup-buildx-action` crea con `--use` (`src/context.ts`) e che il modo «esecuzione» ha già tolto. I comandi buildx che toccano i builder di Febe li indicano per nome | | 2026-10-21 | Il lavoro «controlli» legge anche gli script Node della CI (`node --check .gitea/scripts/*.js`) | Come `bash -n` per gli script di shell: un errore di sintassi in `versioni-registro.js` si vede in pochi secondi, non alla pulizia del lunedì | | 2026-10-21 | Nei modi «settimanale» e «completa» la pulizia legge lo store delle immagini del demone (`docker info --format '{{json .DriverStatus}}'`: con `io.containerd.snapshotter.v1` è quello di containerd, altrimenti il classico) e lo scrive all'inizio; con containerd, o se non lo sa, la prova avverte che le età che elenca sono solo indicative | Da quando contano le 24 ore di `image prune --filter until` dipende dallo store (rilievo della revisione). Con quello classico Docker confronta il `Created` della configurazione, cioè la costruzione (moby, `daemon/images/image_prune.go`: `img.Created.After(until)`); con quello di containerd il `CreatedAt` del record dell'immagine sul demone (`daemon/containerd/image_list.go`: `image.CreatedAt.Before(until)`), che containerd conserva quando lo stesso nome viene riscaricato. Nessun comando mostra quel `CreatedAt` (`docker image ls` dà il `Created` della configurazione anche con containerd), quindi la prova resta sull'età dalla costruzione e lo dice. Lo store di containerd è il predefinito nelle installazioni nuove di Docker Engine dalla 29; su Unraid è più probabile quello classico. `docker info` solo legge | +| 2026-10-21 | Della pulizia del lunedì si dice anche che cosa `image prune -a` toglie alle immagini che un contenitore usa: i nomi in più. La pulizia vera confronta i nomi prima e dopo e scrive, nome per nome, quelli tolti a un'immagine che resta; la prova li stima secondo lo store (classico: tutti tranne l'ultimo in ordine alfabetico del nome completo, `docker.io/library/…` per Docker Hub; containerd: tutti tranne quelli da cui i contenitori sono stati creati, e l'ultimo se un contenitore la usa per identificativo). Il comando resta quello chiesto | Rilievo della revisione: la prova saltava ogni immagine in uso, e i documenti dicevano che un'immagine usata da un contenitore non si tocca. Docker non toglie l'immagine, ma con lo store classico `ImagesPrune` non guarda i contenitori e chiama `ImageDelete` senza forza su ogni riferimento, in ordine alfabetico (`daemon/images/image_prune.go`, uguale in moby v24.0.9, v27.5.1 e master; `reference/store.go`, `lexicalRefs`); `ImageDelete` rifiuta solo l'ultimo riferimento di un'immagine in uso (`image_delete.go`, `isSingleReference`), quindi può sparire proprio il nome da cui il contenitore è stato creato (un'applicazione di Unraid creata da `app:1.2` che si chiama anche `app:latest`). Con containerd `filterImagesUsedByContainers` protegge solo il nome di `Config.Image` e, se il contenitore usa l'immagine per identificativo o digest, l'ultimo nome (`daemon/containerd/image_prune.go`). Il demone finto delle prove fa lo stesso con l'uno e con l'altro store | diff --git a/docs/docker.md b/docs/docker.md index f43fcd0..9fd57cd 100644 --- a/docs/docker.md +++ b/docs/docker.md @@ -43,7 +43,8 @@ Febe: la pulizia della CI non le usa per scegliere che cosa togliere, quindi un della CI non viene mai toccato, né la sua immagine, anche a contenitore fermo. Su quel Docker, però, la pulizia del lunedì toglie le immagini che nessun contenitore usa e che sono state create più di 24 ore fa: un'immagine di Febe tenuta senza contenitore (una versione precedente, per tornare indietro) se ne va, e si riscarica dal registro, dove -`:X.Y.Z` resta (`docs/processo.md`, «Pulizia»). +`:X.Y.Z` resta. E se l'immagine del Febe vero ha più nomi (`:latest` e `:0.1.0`, per esempio), resta, ma con uno solo: +gli altri la pulizia li toglie (`docs/processo.md`, «Pulizia»). ## Volumi diff --git a/docs/processo.md b/docs/processo.md index 0864b08..91266e1 100644 --- a/docs/processo.md +++ b/docs/processo.md @@ -176,15 +176,16 @@ Ciò che resta dei lavori di act_runner si riconosce dal nome che act_runner dà rete `--network`. Se ne vanno i contenitori fermi e i volumi e le reti che nessun contenitore usa, più vecchi di 90 minuti. Il volume `act-toolcache`, la cache degli strumenti condivisa fra i lavori, resta. -Ciò che non serve più a nessuno lo toglie Docker stesso (`docker image prune`, `docker builder prune`), che non tocca -mai un'immagine usata da un contenitore, acceso o fermo: un'applicazione di Unraid ferma tiene la sua immagine. +Ciò che non serve più a nessuno lo toglie Docker stesso (`docker image prune`, `docker builder prune`), che non toglie +mai un'immagine usata da un contenitore, acceso o fermo: un'applicazione di Unraid ferma tiene la sua immagine. Se però +quell'immagine ha più nomi, `image prune -a` le toglie quelli in più (vedi «Che cosa costa»). | Quando | Che cosa si toglie | |---|---| | alla fine di ogni lavoro «immagine» (verifica e rilascio), 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; poi, di tutti i progetti, le immagini senza nome che nessun contenitore usa e la cache di costruzione penzolante del demone, cioè quella che nessuna immagine condivide, non usata da 24 ore (`pulizia-docker.sh penzolanti`). Un errore qui è solo un avviso: il lavoro non diventa rosso | | 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ì alle 4:17 e a mano (`pulizia.yml`, `pulizia-docker.sh completa`) | gli stessi resti e l'immagine `febe:ci` del vecchio flusso; i resti di act_runner; **le immagini che nessun contenitore usa create più di 24 ore fa**, di tutti i progetti, anche col nome del registro; la cache di costruzione del demone non usata da più di 24 ore; con il segreto `REGISTRY_TOKEN`, sul registro le `:sha-` oltre le 10 più recenti. Prima e dopo `docker system df`, alla fine un riepilogo di che cosa è andato via | -| mai | `docker system prune`, `container prune`, `volume prune`, `network prune`; un contenitore, un volume o una rete che non sia della CI: un Febe vero, anche se porta le etichette `febe.ci.*`, le applicazioni di Unraid, i volumi con i dati, `act-toolcache`; un contenitore di prova ancora acceso di un'altra esecuzione (si segnala con un avviso e il comando per toglierlo: il flusso del lunedì diventa rosso); un'immagine usata da un contenitore, anche fermo; `image prune -a` e `builder prune -a` senza il filtro delle 24 ore; sul registro `:main`, `:latest` e le versioni `X.Y.Z` | +| mai | `docker system prune`, `container prune`, `volume prune`, `network prune`; un contenitore, un volume o una rete che non sia della CI: un Febe vero, anche se porta le etichette `febe.ci.*`, le applicazioni di Unraid, i volumi con i dati, `act-toolcache`; un contenitore di prova ancora acceso di un'altra esecuzione (si segnala con un avviso e il comando per toglierlo: il flusso del lunedì diventa rosso); un'immagine usata da un contenitore, anche fermo (i suoi nomi in più sì: vedi sotto); `image prune -a` e `builder prune -a` senza il filtro delle 24 ore; sul registro `:main`, `:latest` e le versioni `X.Y.Z` | Che cosa costa: @@ -202,6 +203,13 @@ Che cosa costa: con containerd lo dice: lì il suo elenco è solo indicativo; - un'immagine costruita a mano e tenuta senza contenitore (per esempio quella di `docker build -t febe .`) se ne va e va ricostruita; una versione di Febe tenuta per tornare indietro si riscarica dal registro, dove `:X.Y.Z` resta; +- un'immagine che un contenitore usa resta, ma se ha più nomi `image prune -a` le toglie quelli in più. Con lo store + classico resta solo l'ultimo in ordine alfabetico del nome completo, anche quando il contenitore è stato creato da un + altro: un'applicazione di Unraid creata da `app:1.2`, se la stessa immagine si chiama anche `app:latest`, continua a + girare, ma in locale `app:1.2` non c'è più, e Unraid la mostra da aggiornare o la riscarica. Con lo store di + containerd restano i nomi da cui i contenitori sono stati creati. Un Febe vero avviato da `:latest`, se la stessa + immagine si chiama anche `:0.1.0`, perde `:0.1.0` e resta `:latest`. La prova elenca questi nomi e la pulizia vera li + scrive uno per uno; - la cache di costruzione del builder del demone, con cui costruiscono gli altri progetti: resta quella usata nelle ultime 24 ore. Dopo ogni esecuzione di Febe se ne va quella che nessuna immagine condivide (strati intermedi, cache montate con `RUN --mount=type=cache`) e che nessuno usa da un giorno; il lunedì anche quella condivisa e quella @@ -209,8 +217,9 @@ Che cosa costa: cache; una più rara la rifà. **Prova senza togliere nulla.** Actions ▸ pulizia ▸ Esegui, con «Solo prova» spuntato: il registro del lavoro elenca -che cosa toglierebbe (le immagini con dimensione ed età, la cache di costruzione, i resti della CI di Febe e di -act_runner, le `:sha-` del registro) e non toglie nulla: solo comandi che leggono, e sul registro solo GET. Si lancia +che cosa toglierebbe (le immagini con dimensione ed età, i nomi in più delle immagini in uso, la cache di costruzione, i +resti della CI di Febe e di act_runner, le `:sha-` del registro) e non toglie nulla: solo comandi che leggono, e sul +registro solo GET. Si lancia prima della prima pulizia vera e dopo ogni cambio dello script. Dal server, nella cartella del repository: `bash .gitea/scripts/pulizia-docker.sh completa --prova` (il registro solo con `REGISTRY_TOKEN`, `GITEA_API` e `PROPRIETARIO` nell'ambiente). Una prova scritta in un altro modo non diventa la pulizia vera: un'opzione diversa da @@ -219,11 +228,12 @@ prima che tocchi Docker, e il flusso accetta per «prova» solo `true` e `false` valore, «True» o «1», si ferma con un errore). Le immagini, nella pulizia vera, le sceglie Docker; nella prova le stima lo script con la stessa regola. -`PipelineTests` fa girare la pulizia contro un demone finto (`tests/Febe.Tests/Packaging/fake-docker.sh`) con un Febe -vero acceso e uno fermo, applicazioni di Unraid accese e ferme, il lavoro della pulizia stessa, resti veri e finti di -act_runner, e contro un'API dei pacchetti finta (`fake-curl.sh`): controlla che cosa resta, che nessun comando vietato -parta, che la prova non tocchi nulla e dica ciò che la pulizia vera poi toglie, e che il token non finisca mai nel -registro del lavoro. +`PipelineTests` fa girare la pulizia contro un demone finto (`tests/Febe.Tests/Packaging/fake-docker.sh`), con lo store +classico e con quello di containerd, con un Febe vero acceso e uno fermo, applicazioni di Unraid accese e ferme (una con +due nomi), il lavoro della pulizia stessa, resti veri e finti di act_runner, e contro un'API dei pacchetti finta +(`fake-curl.sh`): controlla che cosa resta, che nessun comando vietato parta, che la prova non tocchi nulla e dica ciò +che la pulizia vera poi toglie, che una prova scritta male si fermi, e che il token non finisca mai nel registro del +lavoro. ## Rilievi di sicurezza diff --git a/tests/Febe.Tests/Packaging/PipelineTests.Pulizia.cs b/tests/Febe.Tests/Packaging/PipelineTests.Pulizia.cs index 9e581ff..74caeaf 100644 --- a/tests/Febe.Tests/Packaging/PipelineTests.Pulizia.cs +++ b/tests/Febe.Tests/Packaging/PipelineTests.Pulizia.cs @@ -276,6 +276,16 @@ public sealed partial class PipelineTests CollectionAssert.AreEquivalent(SharedDaemon.VolumesLeft, run.Volumes, run.Report); CollectionAssert.AreEquivalent(SharedDaemon.NetworksLeft, run.Networks, run.Report); + // An image a container uses stays, but «image prune -a» takes its extra names: with the classic store all but + // the last in the order of their full names, even the one the container was made from (Jellyfin, from :10.9). + // The log says so, name by name. + StringAssert.Contains(run.Output, "== Store delle immagini del demone: classico", run.Report); + CollectionAssert.Contains(run.Images, "img-rilascio|192.168.30.23:3000/alby96/febe:latest", run.Report); + CollectionAssert.Contains(run.Images, "img-jellyfin|jellyfin/jellyfin:latest", run.Report); + StringAssert.Contains(run.Output, " tolto il nome jellyfin/jellyfin:10.9; l'immagine img-jellyfin resta\n", run.Report); + StringAssert.Contains(run.Output, " tolto il nome 192.168.30.23:3000/alby96/febe:0.1.0; l'immagine img-rilascio resta\n", run.Report); + Assert.AreEqual("2", SummaryCount(run.Output, "nomi tolti a immagini che restano"), run.Report); + // Not even an attempt on what is not the CI's (Docker would refuse some of it: the script must not ask), and // the prunes of everyone only with their filter, once. foreach (var call in run.Calls) @@ -341,6 +351,8 @@ public sealed partial class PipelineTests " toglierei 192.168.30.23:3000/alby96/febe:0.0.9 (img-febe-vec) · 400MB · creata 34 giorni fa\n", " toglierei node:24-trixie (img-node) · 410MB · creata 13 giorni fa\n", " toglierei un'immagine senza nome (img-plex-pre) · 300MB · creata 69 giorni fa\n", + " toglierei il nome 192.168.30.23:3000/alby96/febe:0.1.0; l'immagine img-rilascio resta, perché la usa un contenitore\n", + " toglierei il nome jellyfin/jellyfin:10.9; l'immagine img-jellyfin resta, perché la usa un contenitore\n", "la cache di costruzione del demone occupa 5.3GB", " toglierei sha-4e5f6a7 (pubblicata il 2026-10-05T01:00:00+02:00)\n", $" {UntaggedDigests.Length} versioni senza etichetta (sha256:…", @@ -350,7 +362,7 @@ public sealed partial class PipelineTests StringAssert.Contains(tried.Output, expected, tried.Report); } - foreach (var kept in new[] { "plexinc/pms-docker", "encelado:latest", "mimante:latest", "runner-images", "moby/buildkit", "act-toolcache", "encelado-dati", "febe:latest", "toglierei main", "toglierei latest", "toglierei 0.1.", "GITEA-ACTIONS-TASK-90", "GITEA-ACTIONS-TASK-60", "GITEA-ACTIONS-TASK-88", "GITEA-ACTIONS-TASK-89", "GITEA-ACTIONS-TASK-77" }) + foreach (var kept in new[] { "plexinc/pms-docker", "encelado:latest", "mimante:latest", "runner-images", "moby/buildkit", "act-toolcache", "encelado-dati", "febe:latest", "jellyfin/jellyfin:latest", "toglierei main", "toglierei latest", "toglierei 0.1.", "GITEA-ACTIONS-TASK-90", "GITEA-ACTIONS-TASK-60", "GITEA-ACTIONS-TASK-88", "GITEA-ACTIONS-TASK-89", "GITEA-ACTIONS-TASK-77" }) { Assert.DoesNotContain(kept, tried.Output, tried.Report); } @@ -358,7 +370,7 @@ public sealed partial class PipelineTests // And it counts what the real cleanup then takes. var real = await RunCleanupAsync(bash, world, "completa"); Assert.AreEqual(0, real.Code, real.Report); - foreach (var kind in new[] { "contenitori di prova della CI di Febe", "immagini febe-ci", "builder buildx della CI di Febe", "contenitori fermi di act_runner", "volumi di act_runner", "reti di act_runner", "immagini che nessun contenitore usa", "etichette sha- sul registro" }) + foreach (var kind in new[] { "contenitori di prova della CI di Febe", "immagini febe-ci", "builder buildx della CI di Febe", "contenitori fermi di act_runner", "volumi di act_runner", "reti di act_runner", "immagini che nessun contenitore usa", "nomi tolti a immagini che restano", "etichette sha- sul registro" }) { Assert.AreEqual(SummaryCount(real.Output, kind), SummaryCount(tried.Output, kind), $"{kind}\n{tried.Report}\n{real.Report}"); } @@ -371,11 +383,28 @@ public sealed partial class PipelineTests // With the containerd image store «until» counts from when a name reached the daemon, which no command shows; // the dry run can only give the age of the image and must say so. var bash = RequireBash(); - var tried = await RunCleanupAsync(bash, SharedDaemon.World with { Store = "containerd" }, "completa", "--prova"); + var world = SharedDaemon.World with { Store = "containerd" }; + var tried = await RunCleanupAsync(bash, world, "completa", "--prova"); Assert.AreEqual(0, tried.Code, tried.Report); StringAssert.Contains(tried.Output, "== Store delle immagini del demone: containerd (le 24 ore contano da quando un nome è arrivato sul demone)\n", tried.Report); StringAssert.Contains(tried.Output, "l'elenco è solo indicativo)", tried.Report); CollectionAssert.Contains(tried.Calls, "BUILDX_BUILDER=default docker info --format {{json .DriverStatus}}", "the store is read, never changed"); + + // Of an image a container uses, containerd keeps the names the containers were made from and takes the others: + // Jellyfin keeps :10.9 and loses :latest, the other way round from the classic store. The dry run says so, and + // the real cleanup does it. + StringAssert.Contains(tried.Output, " toglierei il nome jellyfin/jellyfin:latest; l'immagine img-jellyfin resta, perché la usa un contenitore\n", tried.Report); + StringAssert.Contains(tried.Output, " toglierei il nome 192.168.30.23:3000/alby96/febe:0.1.0; l'immagine img-rilascio resta, perché la usa un contenitore\n", tried.Report); + Assert.DoesNotContain("jellyfin/jellyfin:10.9", tried.Output, tried.Report); + var real = await RunCleanupAsync(bash, world, "completa"); + Assert.AreEqual(0, real.Code, real.Report); + CollectionAssert.AreEquivalent(SharedDaemon.ImagesLeft, real.ImageIds, real.Report); + CollectionAssert.Contains(real.Images, "img-jellyfin|jellyfin/jellyfin:10.9", real.Report); + CollectionAssert.Contains(real.Images, "img-rilascio|192.168.30.23:3000/alby96/febe:latest", real.Report); + foreach (var kind in new[] { "immagini che nessun contenitore usa", "nomi tolti a immagini che restano" }) + { + Assert.AreEqual(SummaryCount(real.Output, kind), SummaryCount(tried.Output, kind), $"{kind}\n{tried.Report}\n{real.Report}"); + } } [TestMethod] @@ -552,7 +581,8 @@ public sealed partial class PipelineTests /// A daemon as the runner's is likely to be (format in fake-docker.sh): a real Febe and Unraid apps, running and /// stopped; the job container of the cleanup itself; leftovers of act_runner, with the names of today's act_runner /// («_WORKFLOW-…») and of older ones («-WORKFLOW-…» with a hash), and look-alikes; leftovers of the CI of Febe; - /// images used and unused, named and dangling, old and young; volumes and networks of every kind. + /// images used and unused, named and dangling, old and young; volumes and networks of every kind. The images of the + /// real Febe and of Jellyfin have two names each, and Jellyfin was created from the one that is not the last. /// private static class SharedDaemon { @@ -564,6 +594,7 @@ public sealed partial class PipelineTests [ "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|febe-dati|bridge", "c-plex|plex|exited|90000|plexinc/pms-docker:latest|img-plex||plex-config|br0", + "c-jellyfin|jellyfin|running|90000|jellyfin/jellyfin:10.9|img-jellyfin||", "c-encelado|encelado|exited|5000|encelado:latest|img-encelado|||encelado_default", $"c-lavoro|{Job90}|running|5|docker.gitea.com/runner-images:ubuntu-latest|img-runner||{Job90},{Job90}-env,act-toolcache|{Job90}-docker-network", $"c-act-fermo|{Job53}|exited|3000|node:24-trixie|img-node||{Job53},{Job53}-env,act-toolcache|{Job53}-prove-network", @@ -584,6 +615,7 @@ public sealed partial class PipelineTests "img-febe-vecchia|192.168.30.23:3000/alby96/febe:0.0.9|50000||400MB", "img-plex|plexinc/pms-docker:latest|100000||300MB", "img-plex-precedente||100000||300MB", + "img-jellyfin|jellyfin/jellyfin:10.9,jellyfin/jellyfin:latest|100000||900MB", "img-encelado|encelado:latest|5000||250MB", "img-encelado-dev|encelado:dev|3000||250MB", "img-mimante-nuova|mimante:latest|60||180MB", diff --git a/tests/Febe.Tests/Packaging/fake-docker.sh b/tests/Febe.Tests/Packaging/fake-docker.sh index b3fcfc5..7a7986b 100644 --- a/tests/Febe.Tests/Packaging/fake-docker.sh +++ b/tests/Febe.Tests/Packaging/fake-docker.sh @@ -8,7 +8,8 @@ # - «image rm » 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» takes only images no container uses, running or stopped: without -a only those without a name, with -# -a any; «until» keeps those created in the last 72 or 24 hours; +# -a any; «until» keeps those created in the last 72 or 24 hours. With -a an image a container uses stays but loses +# its extra names, as moby does it with the classic store or, with $FAKE_DOCKER_WORLD/store, with containerd; # - «builder prune» only answers (the cache is not modelled); # - «volume rm» refuses a volume a container mounts, running or stopped, even with -f; # - «network rm» refuses the predefined networks and a network a running container is attached to; @@ -207,6 +208,7 @@ container_inspect() { "{{.Created}}") created "$age" ;; "{{.Config.Image}}") echo "$config" ;; "{{.Image}}") echo "$image_id" ;; + "{{.Image}} {{.Config.Image}}") echo "$image_id $config" ;; "{{.Name}}") echo "/$name" ;; '{{index .Config.Labels "febe.ci.prova"}}') label_value "$labels" febe.ci.prova "" ;; *) unexpected "container inspect -f $format" ;; @@ -313,6 +315,43 @@ image_rm() { echo "Deleted: $id" } +# The full name of an image name, the way Docker sorts references: docker.io/library/ or docker.io/ before the names +# of Docker Hub written without a domain, :latest when the tag is missing. +full_name() { + local name="$1" first + [[ "${name##*/}" == *:* ]] || name="$name:latest" + if [[ "$name" != */* ]]; then + echo "docker.io/library/$name" + return + fi + first="${name%%/*}" + if [[ "$first" == *.* || "$first" == *:* || "$first" == localhost ]]; then echo "$name"; else echo "docker.io/$name"; fi +} + +# The names «image prune -a» leaves to an image a container uses, comma separated, the way moby does it. With the +# classic store it removes the references in lexical order of their full names and only the last one is refused +# (ImageDelete keeps the single reference of an image in use); with containerd it keeps the names the containers were +# created from and, when a container uses the image by id and no name would be left, the last one in lexical order. +names_kept() { + local image="$1" names="$2" sorted name full cid cname state age config image_id rest by_id=0 + local -A from=() + local kept=() + sorted=$(IFS=','; for name in $names; do printf '%s %s\n' "$(full_name "$name")" "$name"; done | LC_ALL=C sort) + if [[ "$(store)" == classic ]]; then + tail -n 1 <<< "$sorted" | cut -d' ' -f2- + return + fi + while IFS='|' read -r cid cname state age config image_id rest; do + [[ -n "$cid" && "$image_id" == "$image" ]] || continue + if [[ "$config" == "$image" ]]; then by_id=1; else from[$(full_name "$config")]=1; fi + done < "$world/containers" + while read -r full name; do + [[ -n "${from[$full]:-}" ]] && kept+=("$name") + done <<< "$sorted" + ((${#kept[@]} > 0 || !by_id)) || kept=("$(tail -n 1 <<< "$sorted" | cut -d' ' -f2-)") + (IFS=','; echo "${kept[*]}") +} + image_prune() { local all=0 hours=0 case "$*" in @@ -322,14 +361,28 @@ image_prune() { *) unexpected "image prune $*" ;; esac broken "image prune" && { echo "Error response from daemon: a prune operation is already running" >&2; exit 1; } - local id names age labels size gone=() tag + local id names age labels size gone=() untag=() tag left while IFS='|' read -r id names age labels size; do [[ -n "$id" ]] || continue ((all)) || [[ -z "$names" ]] || continue ((age >= hours * 60)) || continue - used_by "$id" any || gone+=("$id") + if used_by "$id" any; then + [[ "$names" == *,* ]] && untag+=("$id") + else + gone+=("$id") + fi done < "$world/images" - ((${#gone[@]} == 0)) || echo "Deleted Images:" + ((${#gone[@]} + ${#untag[@]} == 0)) || echo "Deleted Images:" + for id in "${untag[@]}"; do + IFS='|' read -r id names age labels size <<< "$(image_line "$id")" + left=$(names_kept "$id" "$names") + IFS=',' read -r -a tags <<< "$names" + for tag in "${tags[@]}"; do + [[ ",$left," == *",$tag,"* ]] || echo "untagged: $tag" + done + drop "$world/images" "$id" + printf '%s|%s|%s|%s|%s\n' "$id" "$left" "$age" "$labels" "$size" >> "$world/images" + done for id in "${gone[@]}"; do IFS='|' read -r id names age labels size <<< "$(image_line "$id")" tags=()