444 lines
11 KiB
Bash
Executable File
444 lines
11 KiB
Bash
Executable File
#!/usr/bin/env bash
|
|
# arch-maintenance.sh
|
|
# Konservatives Wartungsskript fuer Arch Linux
|
|
# Standard: Dry-Run. Loeschen nur mit --apply.
|
|
# 2026-09-10: Docker-Netze immer erhalten; kein globales system prune.
|
|
|
|
set -uo pipefail
|
|
IFS=$'\n\t'
|
|
|
|
APPLY=0
|
|
YES=0
|
|
|
|
PACMAN_KEEP=3
|
|
PACMAN_KEEP_UNINSTALLED=0
|
|
|
|
JOURNAL_MAX_AGE="14d"
|
|
JOURNAL_MAX_SIZE="500M"
|
|
|
|
DO_DOCKER=1
|
|
DOCKER_UNTIL="168h"
|
|
DOCKER_AGGRESSIVE=0
|
|
DOCKER_VOLUMES=0
|
|
|
|
DO_ORPHANS=1
|
|
DO_AUR_CACHE=1
|
|
AUR_CACHE_DAYS=30
|
|
THUMB_CACHE_DAYS=30
|
|
|
|
LOG_DIR="/var/log/arch-maintenance"
|
|
LOG_FILE=""
|
|
|
|
usage() {
|
|
cat <<'EOF'
|
|
Arch Linux Wartungsskript
|
|
|
|
Usage:
|
|
sudo arch-maintenance.sh [Optionen]
|
|
|
|
Sicherer Standard:
|
|
Ohne --apply wird nur analysiert / simuliert.
|
|
Docker-Netze bleiben auch mit --apply und --docker-aggressive erhalten.
|
|
User-Caches: nur alte yay/paru-Eintraege und Thumbnails, kein globales Leeren.
|
|
|
|
Optionen:
|
|
--apply Wirklich bereinigen
|
|
--yes Keine Rueckfragen stellen
|
|
--no-docker Docker-Bereinigung ueberspringen
|
|
--docker-aggressive Auch ungenutzte Docker-Images entfernen (-a)
|
|
--docker-volumes Ungenutzte Docker-Volumes entfernen; Vorsicht: kann Daten loeschen
|
|
--no-orphans Pacman-Orphans nicht entfernen
|
|
--no-aur-cache yay/paru Build-Caches nicht bereinigen
|
|
--pacman-keep N N alte Versionen installierter Pakete behalten, Default: 3
|
|
--journal-age AGE Journal-Alter, Default: 14d
|
|
--journal-size SIZE Journal-Groesse, Default: 500M
|
|
--docker-until AGE Docker prune Filter, Default: 168h
|
|
--help Hilfe anzeigen
|
|
|
|
Beispiele:
|
|
sudo arch-maintenance.sh
|
|
sudo arch-maintenance.sh --apply
|
|
sudo arch-maintenance.sh --apply --yes
|
|
sudo arch-maintenance.sh --apply --docker-aggressive
|
|
sudo arch-maintenance.sh --apply --docker-volumes
|
|
EOF
|
|
}
|
|
|
|
log() {
|
|
printf '[%s] %s\n' "$(date '+%Y-%m-%d %H:%M:%S')" "$*"
|
|
}
|
|
|
|
warn() {
|
|
log "WARN: $*"
|
|
}
|
|
|
|
die() {
|
|
log "ERROR: $*"
|
|
exit 1
|
|
}
|
|
|
|
cmdline() {
|
|
printf '%q ' "$@"
|
|
}
|
|
|
|
have_cmd() {
|
|
command -v "$1" >/dev/null 2>&1
|
|
}
|
|
|
|
confirm() {
|
|
local prompt="$1"
|
|
|
|
if (( YES )); then
|
|
return 0
|
|
fi
|
|
|
|
if [[ ! -t 0 ]]; then
|
|
warn "Nicht-interaktive Shell ohne --yes: '$prompt' wird uebersprungen."
|
|
return 1
|
|
fi
|
|
|
|
local answer
|
|
read -r -p "$prompt [y/N] " answer
|
|
[[ "$answer" =~ ^([yYjJ]|yes|YES|ja|JA)$ ]]
|
|
}
|
|
|
|
execute() {
|
|
local description="$1"
|
|
shift
|
|
|
|
log "==> $description"
|
|
log "CMD: $(cmdline "$@")"
|
|
|
|
if (( APPLY )); then
|
|
if "$@"; then
|
|
log "OK: $description"
|
|
else
|
|
warn "Fehlgeschlagen, fahre fort: $description"
|
|
fi
|
|
else
|
|
log "DRY-RUN: nicht ausgefuehrt"
|
|
fi
|
|
}
|
|
|
|
run_and_log() {
|
|
local description="$1"
|
|
shift
|
|
|
|
log "==> $description"
|
|
log "CMD: $(cmdline "$@")"
|
|
|
|
if "$@"; then
|
|
log "OK: $description"
|
|
else
|
|
warn "Fehlgeschlagen, fahre fort: $description"
|
|
fi
|
|
}
|
|
|
|
init_logging() {
|
|
mkdir -p "$LOG_DIR" || die "Kann Log-Verzeichnis nicht erstellen: $LOG_DIR"
|
|
chmod 0755 "$LOG_DIR" || true
|
|
|
|
LOG_FILE="$LOG_DIR/maintenance-$(date '+%Y%m%d-%H%M%S').log"
|
|
touch "$LOG_FILE" || die "Kann Log-Datei nicht erstellen: $LOG_FILE"
|
|
chmod 0644 "$LOG_FILE" || true
|
|
|
|
exec > >(tee -a "$LOG_FILE") 2>&1
|
|
|
|
log "Log-Datei: $LOG_FILE"
|
|
if (( APPLY )); then
|
|
log "Modus: APPLY"
|
|
else
|
|
log "Modus: DRY-RUN"
|
|
fi
|
|
}
|
|
|
|
require_root() {
|
|
[[ "${EUID:-$(id -u)}" -eq 0 ]] || die "Bitte mit sudo/root ausfuehren."
|
|
}
|
|
|
|
parse_args() {
|
|
while (($#)); do
|
|
case "$1" in
|
|
--apply)
|
|
APPLY=1
|
|
;;
|
|
--yes)
|
|
YES=1
|
|
;;
|
|
--no-docker)
|
|
DO_DOCKER=0
|
|
;;
|
|
--docker-aggressive)
|
|
DOCKER_AGGRESSIVE=1
|
|
;;
|
|
--docker-volumes)
|
|
DOCKER_VOLUMES=1
|
|
;;
|
|
--no-orphans)
|
|
DO_ORPHANS=0
|
|
;;
|
|
--no-aur-cache)
|
|
DO_AUR_CACHE=0
|
|
;;
|
|
--pacman-keep)
|
|
shift
|
|
[[ "${1:-}" =~ ^[0-9]+$ ]] || die "--pacman-keep erwartet eine Zahl"
|
|
PACMAN_KEEP="$1"
|
|
;;
|
|
--journal-age)
|
|
shift
|
|
JOURNAL_MAX_AGE="${1:-}"
|
|
[[ -n "$JOURNAL_MAX_AGE" ]] || die "--journal-age erwartet einen Wert"
|
|
;;
|
|
--journal-size)
|
|
shift
|
|
JOURNAL_MAX_SIZE="${1:-}"
|
|
[[ -n "$JOURNAL_MAX_SIZE" ]] || die "--journal-size erwartet einen Wert"
|
|
;;
|
|
--docker-until)
|
|
shift
|
|
DOCKER_UNTIL="${1:-}"
|
|
[[ -n "$DOCKER_UNTIL" ]] || die "--docker-until erwartet einen Wert"
|
|
;;
|
|
--help|-h)
|
|
usage
|
|
exit 0
|
|
;;
|
|
*)
|
|
die "Unbekannte Option: $1"
|
|
;;
|
|
esac
|
|
shift
|
|
done
|
|
}
|
|
|
|
real_user() {
|
|
if [[ -n "${SUDO_USER:-}" && "${SUDO_USER:-}" != "root" ]]; then
|
|
printf '%s\n' "$SUDO_USER"
|
|
else
|
|
logname 2>/dev/null || printf 'root\n'
|
|
fi
|
|
}
|
|
|
|
home_of_user() {
|
|
local user="$1"
|
|
getent passwd "$user" | cut -d: -f6
|
|
}
|
|
|
|
show_disk_usage() {
|
|
log "==> Speicherbelegung"
|
|
df -hT / /home /var 2>/dev/null || df -hT
|
|
}
|
|
|
|
cleanup_pacman_cache() {
|
|
log "==> Pacman Cache"
|
|
|
|
if ! have_cmd paccache; then
|
|
warn "paccache nicht gefunden. Installiere es mit: sudo pacman -S --needed pacman-contrib"
|
|
return
|
|
fi
|
|
|
|
if (( APPLY )); then
|
|
execute "Pacman Cache bereinigen; letzte ${PACMAN_KEEP} Versionen installierter Pakete behalten" \
|
|
paccache -r -k "$PACMAN_KEEP"
|
|
|
|
execute "Pacman Cache fuer deinstallierte Pakete bereinigen; ${PACMAN_KEEP_UNINSTALLED} Versionen behalten" \
|
|
paccache -r -u -k "$PACMAN_KEEP_UNINSTALLED"
|
|
else
|
|
run_and_log "Pacman Cache Dry-Run fuer installierte Pakete" \
|
|
paccache -d -r -k "$PACMAN_KEEP"
|
|
|
|
run_and_log "Pacman Cache Dry-Run fuer deinstallierte Pakete" \
|
|
paccache -d -r -u -k "$PACMAN_KEEP_UNINSTALLED"
|
|
fi
|
|
}
|
|
|
|
cleanup_orphans() {
|
|
(( DO_ORPHANS )) || {
|
|
log "Pacman-Orphans: uebersprungen"
|
|
return
|
|
}
|
|
|
|
log "==> Pacman Orphans"
|
|
|
|
if ! have_cmd pacman; then
|
|
warn "pacman nicht gefunden?"
|
|
return
|
|
fi
|
|
|
|
local -a orphans=()
|
|
mapfile -t orphans < <(pacman -Qqdt 2>/dev/null || true)
|
|
|
|
if ((${#orphans[@]} == 0)); then
|
|
log "Keine Orphan-Pakete gefunden."
|
|
return
|
|
fi
|
|
|
|
log "Gefundene Orphan-Pakete:"
|
|
printf ' %s\n' "${orphans[@]}"
|
|
|
|
if (( APPLY )); then
|
|
if confirm "Diese Orphan-Pakete mit pacman -Rns entfernen?"; then
|
|
pacman -Rns --noconfirm "${orphans[@]}" || warn "Orphan-Entfernung fehlgeschlagen."
|
|
else
|
|
log "Orphan-Entfernung uebersprungen."
|
|
fi
|
|
else
|
|
log "DRY-RUN: Orphans wuerden mit pacman -Rns entfernt."
|
|
fi
|
|
}
|
|
|
|
cleanup_journal() {
|
|
log "==> systemd Journal"
|
|
|
|
if ! have_cmd journalctl; then
|
|
warn "journalctl nicht gefunden."
|
|
return
|
|
fi
|
|
|
|
run_and_log "Journal-Groesse vor Bereinigung" journalctl --disk-usage
|
|
|
|
if (( APPLY )); then
|
|
execute "Journal rotieren" journalctl --rotate
|
|
execute "Journal vacuum: max. ${JOURNAL_MAX_AGE}, max. ${JOURNAL_MAX_SIZE}" \
|
|
journalctl --vacuum-time="$JOURNAL_MAX_AGE" --vacuum-size="$JOURNAL_MAX_SIZE"
|
|
run_and_log "Journal-Groesse nach Bereinigung" journalctl --disk-usage
|
|
else
|
|
log "DRY-RUN: Journal wuerde rotiert und mit --vacuum-time=${JOURNAL_MAX_AGE} --vacuum-size=${JOURNAL_MAX_SIZE} begrenzt."
|
|
fi
|
|
}
|
|
|
|
cleanup_tmpfiles() {
|
|
log "==> systemd-tmpfiles"
|
|
|
|
if ! have_cmd systemd-tmpfiles; then
|
|
warn "systemd-tmpfiles nicht gefunden."
|
|
return
|
|
fi
|
|
|
|
execute "Temporäre Dateien nach systemd-tmpfiles-Regeln bereinigen" \
|
|
systemd-tmpfiles --clean
|
|
}
|
|
|
|
cleanup_docker() {
|
|
(( DO_DOCKER )) || {
|
|
log "Docker: uebersprungen"
|
|
return
|
|
}
|
|
|
|
log "==> Docker"
|
|
|
|
if ! have_cmd docker; then
|
|
log "Docker nicht installiert, uebersprungen."
|
|
return
|
|
fi
|
|
|
|
if ! docker info >/dev/null 2>&1; then
|
|
warn "Docker daemon nicht erreichbar oder keine Berechtigung. Docker-Bereinigung uebersprungen."
|
|
return
|
|
fi
|
|
|
|
run_and_log "Docker Speicherbelegung vor Bereinigung" docker system df -v
|
|
|
|
log "Docker-Netze bleiben erhalten, auch wenn gerade kein Container sie verwendet."
|
|
execute "Gestoppte Docker-Container bereinigen, erstellt vor ${DOCKER_UNTIL}" \
|
|
docker container prune -f --filter "until=${DOCKER_UNTIL}"
|
|
|
|
if (( DOCKER_AGGRESSIVE )); then
|
|
execute "Alle ungenutzten Docker-Images bereinigen, erstellt vor ${DOCKER_UNTIL}" \
|
|
docker image prune -a -f --filter "until=${DOCKER_UNTIL}"
|
|
else
|
|
execute "Dangling Docker-Images bereinigen, erstellt vor ${DOCKER_UNTIL}" \
|
|
docker image prune -f --filter "until=${DOCKER_UNTIL}"
|
|
fi
|
|
|
|
execute "Docker Builder Cache bereinigen, aelter als ${DOCKER_UNTIL}" \
|
|
docker builder prune -f --filter "until=${DOCKER_UNTIL}"
|
|
|
|
if (( DOCKER_VOLUMES )); then
|
|
if (( APPLY )); then
|
|
if confirm "Ungenutzte Docker-Volumes entfernen? Das kann Daten loeschen."; then
|
|
execute "Ungenutzte Docker-Volumes entfernen; Volumes mit label keep bleiben erhalten" \
|
|
docker volume prune -f --filter "label!=keep"
|
|
else
|
|
log "Docker-Volumes uebersprungen."
|
|
fi
|
|
else
|
|
log "DRY-RUN: Ungenutzte Docker-Volumes wuerden mit docker volume prune entfernt; nur bei --docker-volumes."
|
|
fi
|
|
else
|
|
log "Docker-Volumes werden nicht bereinigt. Nutze --docker-volumes, wenn du das wirklich willst."
|
|
fi
|
|
|
|
run_and_log "Docker Speicherbelegung nach Bereinigung / Analyse" docker system df -v
|
|
}
|
|
|
|
cleanup_user_caches() {
|
|
(( DO_AUR_CACHE )) || {
|
|
log "User/AUR Cache: uebersprungen"
|
|
return
|
|
}
|
|
|
|
local user home
|
|
user="$(real_user)"
|
|
home="$(home_of_user "$user")"
|
|
|
|
if [[ -z "$home" || ! -d "$home" ]]; then
|
|
warn "Home-Verzeichnis fuer User '$user' nicht gefunden."
|
|
return
|
|
fi
|
|
|
|
log "==> User Cache fuer $user ($home)"
|
|
|
|
local dir
|
|
|
|
for dir in "$home/.cache/yay" "$home/.cache/paru"; do
|
|
[[ -d "$dir" ]] || continue
|
|
|
|
log "AUR Cache Kandidaten in $dir, aelter als ${AUR_CACHE_DAYS} Tage:"
|
|
find "$dir" -mindepth 1 -maxdepth 1 -mtime +"$AUR_CACHE_DAYS" -print 2>/dev/null || true
|
|
|
|
if (( APPLY )); then
|
|
find "$dir" -mindepth 1 -maxdepth 1 -mtime +"$AUR_CACHE_DAYS" -exec rm -rf -- {} + 2>/dev/null \
|
|
|| warn "Konnte AUR Cache nicht vollstaendig bereinigen: $dir"
|
|
else
|
|
log "DRY-RUN: alte Eintraege in $dir wuerden geloescht."
|
|
fi
|
|
done
|
|
|
|
dir="$home/.cache/thumbnails"
|
|
if [[ -d "$dir" ]]; then
|
|
log "Thumbnail Cache Kandidaten in $dir, aelter als ${THUMB_CACHE_DAYS} Tage:"
|
|
find "$dir" -type f -mtime +"$THUMB_CACHE_DAYS" -print 2>/dev/null || true
|
|
|
|
if (( APPLY )); then
|
|
find "$dir" -type f -mtime +"$THUMB_CACHE_DAYS" -delete 2>/dev/null \
|
|
|| warn "Konnte Thumbnail Cache nicht vollstaendig bereinigen."
|
|
find "$dir" -type d -empty -delete 2>/dev/null || true
|
|
else
|
|
log "DRY-RUN: alte Thumbnail-Dateien wuerden geloescht."
|
|
fi
|
|
fi
|
|
}
|
|
|
|
main() {
|
|
parse_args "$@"
|
|
require_root
|
|
init_logging
|
|
|
|
log "Starte Arch-Wartung"
|
|
show_disk_usage
|
|
|
|
cleanup_pacman_cache
|
|
cleanup_orphans
|
|
cleanup_journal
|
|
cleanup_tmpfiles
|
|
cleanup_docker
|
|
cleanup_user_caches
|
|
|
|
show_disk_usage
|
|
log "Fertig. Log: $LOG_FILE"
|
|
}
|
|
|
|
main "$@"
|