Pulizia: dice quali nomi image prune -a toglie alle immagini in uso

Docker non toglie un'immagine che un contenitore usa, ma con -a le toglie
i nomi in più: con lo store classico tutti tranne l'ultimo in ordine
alfabetico, anche quello da cui il contenitore è stato creato
(un'applicazione di Unraid creata da app:1.2 che si chiama anche
app:latest resta senza app:1.2); con containerd tutti tranne quelli dei
contenitori. La prova saltava ogni immagine in uso e i documenti la
davano per intoccata (rilievo della revisione, controllato sul codice di
moby v24, v27 e master).

La pulizia vera confronta i nomi prima e dopo la potatura e scrive, nome
per nome, quelli tolti a un'immagine che resta; la prova li stima secondo
lo store e li conta, e le prove controllano che stima e pulizia vera
coincidano con l'uno e con l'altro store. Il comando resta quello
chiesto, docker image prune -a -f --filter until=24h; docs/processo.md e
docs/docker.md dicono che cosa succede ai nomi.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Alby96andClaude Opus 5.5 committed 2026-10-21 11:56:41 +02:00
1 parent e24ebd24f0
commit 68100b0295
7 files changed
+233 -40

No files matched your search

+114 -18
View File
@@ -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-<esadecimale> 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-<esadecimale> 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" == "<none>:<none>" ]] && continue
aveva_nomi[$id]=1
fra "$nome" "${nomi_previsti[@]}" && continue
nomi[$id]="${nomi[$id]:+${nomi[$id]}, }$nome"
[[ "$nome" == *":<none>" ]] || 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 (<none>:<none> 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" != *":<none>" ]] || 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"
+3 -3
View File
@@ -9,9 +9,9 @@
# febe-ci-<esecuzione>, 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
+1
View File
@@ -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 |
+2 -1
View File
@@ -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
+20 -10
View File
@@ -176,15 +176,16 @@ Ciò che resta dei lavori di act_runner si riconosce dal nome che act_runner dà
rete `<nome>-<lavoro>-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
@@ -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.
/// </summary>
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",
+57 -4
View File
@@ -8,7 +8,8 @@
# - «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» 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 "<no value>" ;;
*) 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=()