Files
Proxmox-und-GuestUpdater/settings.sh
T
2026-10-04 21:29:19 +02:00

1152 lines
40 KiB
Bash
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
#!/usr/bin/env bash
set -Eeuo pipefail
# ============================================================
# Proxmox Guest Updater - Manager
# Installation, Konfiguration, Zeitplan, Status, Deinstallation
# ============================================================
REPO="https://gitea.vourx.com/sharky/Proxmox-und-GuestUpdater"
RAW="${REPO}/raw/branch/main"
UPDATER="/usr/local/sbin/pve-guest-update"
CONFIG="/etc/pve-guest-update.conf"
SERVICE="/etc/systemd/system/pve-guest-update.service"
TIMER="/etc/systemd/system/pve-guest-update.timer"
LOGFILE="/var/log/pve-guest-update.log"
NOTIFY_MATCHER="proxmox-updater"
NOTIFY_TEMPLATE="proxmox-updater"
# ---------- Farben ----------
if [[ -t 1 ]]; then
C_RESET=$'\033[0m'
C_BOLD=$'\033[1m'
C_DIM=$'\033[2m'
C_RED=$'\033[1;31m'
C_GREEN=$'\033[1;32m'
C_YELLOW=$'\033[1;33m'
C_BLUE=$'\033[1;34m'
C_CYAN=$'\033[1;36m'
C_WHITE=$'\033[1;37m'
C_INV=$'\033[7m'
else
C_RESET=""; C_BOLD=""; C_DIM=""; C_RED=""; C_GREEN=""
C_YELLOW=""; C_BLUE=""; C_CYAN=""; C_WHITE=""; C_INV=""
fi
# ---------- Standardwerte ----------
UPDATE_HOST="yes"
UPDATE_LXC="yes"
UPDATE_VMS="yes"
UPDATE_STOPPED="no"
AUTO_REBOOT_HOST="yes"
EXCLUDE_GUESTS=""
NOTIFY_ENABLED="no"
NOTIFY_TARGET=""
APT_LOCK_TIMEOUT="600"
BACKUP_WAIT_TIMEOUT="7200"
BACKUP_WAIT_INTERVAL="60"
LOG_FILE="$LOGFILE"
SCHEDULE_TYPE="weekly"
SCHEDULE_TIME="04:00"
SCHEDULE_WEEKDAY="Sun"
SCHEDULE_MONTHDAY="1"
SCHEDULE_INTERVAL_MONTHS="3"
SCHEDULE_START_MONTH="1"
SCHEDULE_YEAR_MONTH="1"
SCHEDULE_YEAR_DAY="1"
ONCALENDAR="Sun *-*-* 04:00:00"
INSTALLED="no"
DIRTY="no"
# ============================================================
# Basis / UI
# ============================================================
die() {
printf '\n%sFEHLER:%s %s\n' "$C_RED" "$C_RESET" "$*" >&2
exit 1
}
cleanup_terminal() {
printf '%s' "$C_RESET" >/dev/tty 2>/dev/null || true
stty sane </dev/tty 2>/dev/null || true
}
trap cleanup_terminal EXIT
need_root_and_pve() {
[[ $EUID -eq 0 ]] || die "Bitte als root auf dem Proxmox-Host ausführen."
command -v pveversion >/dev/null 2>&1 || die "Proxmox VE wurde nicht erkannt."
[[ -r /dev/tty && -w /dev/tty ]] || die "Für den Manager wird ein interaktives Terminal benötigt."
}
clear_screen() {
printf '\033[2J\033[H' >/dev/tty
}
header() {
local title="$1"
clear_screen
printf '%s%s============================================================%s\n' "$C_CYAN" "$C_BOLD" "$C_RESET" >/dev/tty
printf '%s%s Proxmox Guest Updater - %-31s%s\n' "$C_CYAN" "$C_BOLD" "$title" "$C_RESET" >/dev/tty
printf '%s%s============================================================%s\n' "$C_CYAN" "$C_BOLD" "$C_RESET" >/dev/tty
printf 'Host: %s Proxmox: %s\n\n' "$(hostname)" "$(pveversion 2>/dev/null | head -n1)" >/dev/tty
}
pause_key() {
printf '\n%sWeiter mit Enter ...%s' "$C_DIM" "$C_RESET" >/dev/tty
IFS= read -r _ </dev/tty || true
}
yn_de() {
[[ "$1" == "yes" ]] && printf 'Ja' || printf 'Nein'
}
weekday_de() {
case "$1" in
Mon) echo "Montag" ;;
Tue) echo "Dienstag" ;;
Wed) echo "Mittwoch" ;;
Thu) echo "Donnerstag" ;;
Fri) echo "Freitag" ;;
Sat) echo "Samstag" ;;
Sun) echo "Sonntag" ;;
*) echo "$1" ;;
esac
}
month_de() {
case "$1" in
1) echo "Januar" ;; 2) echo "Februar" ;; 3) echo "März" ;;
4) echo "April" ;; 5) echo "Mai" ;; 6) echo "Juni" ;;
7) echo "Juli" ;; 8) echo "August" ;; 9) echo "September" ;;
10) echo "Oktober" ;; 11) echo "November" ;; 12) echo "Dezember" ;;
*) echo "$1" ;;
esac
}
# Cursor-Menü. Ergebnis steht in MENU_RESULT.
menu_select() {
local title="$1"
local hint="$2"
shift 2
local -a items=("$@")
local pos=0 key rest i
while true; do
header "$title"
[[ -n "$hint" ]] && printf '%s\n\n' "$hint" >/dev/tty
for ((i=0; i<${#items[@]}; i++)); do
if (( i == pos )); then
printf ' %s%s▶ %-52s%s\n' "$C_INV" "$C_BOLD" "${items[$i]}" "$C_RESET" >/dev/tty
else
printf ' %-52s\n' "${items[$i]}" >/dev/tty
fi
done
printf '\n%s↑/↓ auswählen Enter bestätigen%s\n' "$C_DIM" "$C_RESET" >/dev/tty
IFS= read -rsn1 key </dev/tty || true
if [[ "$key" == $'\x1b' ]]; then
IFS= read -rsn2 -t 0.1 rest </dev/tty || true
key+="$rest"
fi
case "$key" in
$'\x1b[A') (( pos > 0 )) && ((pos--)) || pos=$((${#items[@]}-1)) ;;
$'\x1b[B') (( pos < ${#items[@]}-1 )) && ((pos++)) || pos=0 ;;
"") MENU_RESULT="$pos"; return 0 ;;
esac
done
}
confirm_menu() {
local title="$1" text="$2" default="${3:-no}"
local -a opts
if [[ "$default" == "yes" ]]; then
opts=("Ja" "Nein")
else
opts=("Nein" "Ja")
fi
menu_select "$title" "$text" "${opts[@]}"
if [[ "${opts[$MENU_RESULT]}" == "Ja" ]]; then
REPLY="yes"
else
REPLY="no"
fi
}
input_text() {
local title="$1" prompt="$2" current="$3" regex="${4:-}" error="${5:-Ungültige Eingabe.}"
local value
while true; do
header "$title"
printf '%s\n\n' "$prompt" >/dev/tty
printf 'Aktuell: %s%s%s\n\n' "$C_BOLD" "${current:-keine}" "$C_RESET" >/dev/tty
printf '> ' >/dev/tty
IFS= read -r value </dev/tty
value="${value:-$current}"
if [[ -z "$regex" || "$value" =~ $regex ]]; then
INPUT_RESULT="$value"
return
fi
printf '\n%s%s%s\n' "$C_RED" "$error" "$C_RESET" >/dev/tty
sleep 1
done
}
# ============================================================
# Konfiguration lesen / schreiben
# ============================================================
load_existing() {
if [[ -f "$CONFIG" ]]; then
INSTALLED="yes"
# shellcheck disable=SC1090
source "$CONFIG"
fi
UPDATE_HOST="${UPDATE_HOST:-yes}"
UPDATE_LXC="${UPDATE_LXC:-yes}"
UPDATE_VMS="${UPDATE_VMS:-yes}"
UPDATE_STOPPED="${UPDATE_STOPPED:-no}"
AUTO_REBOOT_HOST="${AUTO_REBOOT_HOST:-yes}"
EXCLUDE_GUESTS="${EXCLUDE_GUESTS:-}"
NOTIFY_ENABLED="${NOTIFY_ENABLED:-no}"
NOTIFY_TARGET="${NOTIFY_TARGET:-}"
APT_LOCK_TIMEOUT="${APT_LOCK_TIMEOUT:-600}"
BACKUP_WAIT_TIMEOUT="${BACKUP_WAIT_TIMEOUT:-7200}"
BACKUP_WAIT_INTERVAL="${BACKUP_WAIT_INTERVAL:-60}"
LOG_FILE="${LOG_FILE:-$LOGFILE}"
SCHEDULE_TYPE="${SCHEDULE_TYPE:-}"
SCHEDULE_TIME="${SCHEDULE_TIME:-04:00}"
SCHEDULE_WEEKDAY="${SCHEDULE_WEEKDAY:-Sun}"
SCHEDULE_MONTHDAY="${SCHEDULE_MONTHDAY:-1}"
SCHEDULE_INTERVAL_MONTHS="${SCHEDULE_INTERVAL_MONTHS:-3}"
SCHEDULE_START_MONTH="${SCHEDULE_START_MONTH:-1}"
SCHEDULE_YEAR_MONTH="${SCHEDULE_YEAR_MONTH:-1}"
SCHEDULE_YEAR_DAY="${SCHEDULE_YEAR_DAY:-1}"
if [[ -f "$TIMER" ]]; then
ONCALENDAR="$(sed -n 's/^[[:space:]]*OnCalendar=//p' "$TIMER" | head -n1)"
fi
ONCALENDAR="${ONCALENDAR:-Sun *-*-* 04:00:00}"
# Alte Installation ohne neue SCHEDULE_* Variablen erkennen.
if [[ -z "$SCHEDULE_TYPE" ]]; then
if [[ "$ONCALENDAR" =~ ^(Mon|Tue|Wed|Thu|Fri|Sat|Sun)[[:space:]]+\*-\*-\*[[:space:]]+([0-9]{2}:[0-9]{2}):[0-9]{2}$ ]]; then
SCHEDULE_TYPE="weekly"
SCHEDULE_WEEKDAY="${BASH_REMATCH[1]}"
SCHEDULE_TIME="${BASH_REMATCH[2]}"
elif [[ "$ONCALENDAR" =~ ^\*-\*-\*[[:space:]]+([0-9]{2}:[0-9]{2}):[0-9]{2}$ ]]; then
SCHEDULE_TYPE="daily"
SCHEDULE_TIME="${BASH_REMATCH[1]}"
else
SCHEDULE_TYPE="custom"
fi
fi
}
write_config() {
cat > "$CONFIG" <<EOF
# Proxmox Guest Updater
# Automatisch durch manager.sh erzeugt
UPDATE_HOST="$UPDATE_HOST"
UPDATE_LXC="$UPDATE_LXC"
UPDATE_VMS="$UPDATE_VMS"
UPDATE_STOPPED="$UPDATE_STOPPED"
AUTO_REBOOT_HOST="$AUTO_REBOOT_HOST"
NOTIFY_ENABLED="$NOTIFY_ENABLED"
NOTIFY_TARGET="$NOTIFY_TARGET"
EXCLUDE_GUESTS="$EXCLUDE_GUESTS"
APT_LOCK_TIMEOUT="$APT_LOCK_TIMEOUT"
BACKUP_WAIT_TIMEOUT="$BACKUP_WAIT_TIMEOUT"
BACKUP_WAIT_INTERVAL="$BACKUP_WAIT_INTERVAL"
LOG_FILE="$LOG_FILE"
# Zeitplan-Metadaten für den Manager
SCHEDULE_TYPE="$SCHEDULE_TYPE"
SCHEDULE_TIME="$SCHEDULE_TIME"
SCHEDULE_WEEKDAY="$SCHEDULE_WEEKDAY"
SCHEDULE_MONTHDAY="$SCHEDULE_MONTHDAY"
SCHEDULE_INTERVAL_MONTHS="$SCHEDULE_INTERVAL_MONTHS"
SCHEDULE_START_MONTH="$SCHEDULE_START_MONTH"
SCHEDULE_YEAR_MONTH="$SCHEDULE_YEAR_MONTH"
SCHEDULE_YEAR_DAY="$SCHEDULE_YEAR_DAY"
EOF
chmod 600 "$CONFIG"
}
# ============================================================
# Zeitplan
# ============================================================
schedule_description() {
case "$SCHEDULE_TYPE" in
daily)
echo "Täglich um $SCHEDULE_TIME Uhr"
;;
weekly)
echo "Wöchentlich am $(weekday_de "$SCHEDULE_WEEKDAY") um $SCHEDULE_TIME Uhr"
;;
monthly)
echo "Monatlich am $SCHEDULE_MONTHDAY. um $SCHEDULE_TIME Uhr"
;;
interval_months)
echo "Alle $SCHEDULE_INTERVAL_MONTHS Monate, ab $(month_de "$SCHEDULE_START_MONTH"), am $SCHEDULE_MONTHDAY. um $SCHEDULE_TIME Uhr"
;;
yearly)
echo "Jährlich am $SCHEDULE_YEAR_DAY. $(month_de "$SCHEDULE_YEAR_MONTH") um $SCHEDULE_TIME Uhr"
;;
custom)
echo "Benutzerdefiniert: $ONCALENDAR"
;;
*)
echo "$ONCALENDAR"
;;
esac
}
build_oncalendar() {
local months="" m first=1
case "$SCHEDULE_TYPE" in
daily)
ONCALENDAR="*-*-* $SCHEDULE_TIME:00"
;;
weekly)
ONCALENDAR="$SCHEDULE_WEEKDAY *-*-* $SCHEDULE_TIME:00"
;;
monthly)
ONCALENDAR="*-*-$SCHEDULE_MONTHDAY $SCHEDULE_TIME:00"
;;
interval_months)
months=""
m="$SCHEDULE_START_MONTH"
while (( m <= 12 )); do
printf -v mm '%02d' "$m"
if [[ -z "$months" ]]; then months="$mm"; else months="$months,$mm"; fi
m=$((m + SCHEDULE_INTERVAL_MONTHS))
done
ONCALENDAR="*-$months-$SCHEDULE_MONTHDAY $SCHEDULE_TIME:00"
;;
yearly)
printf -v mm '%02d' "$SCHEDULE_YEAR_MONTH"
ONCALENDAR="*-$mm-$SCHEDULE_YEAR_DAY $SCHEDULE_TIME:00"
;;
custom)
:
;;
esac
}
choose_time() {
input_text "Zeitplan" "Uhrzeit im Format HH:MM eingeben." "$SCHEDULE_TIME" '^([01][0-9]|2[0-3]):[0-5][0-9]$' "Bitte HH:MM verwenden, z. B. 04:00."
SCHEDULE_TIME="$INPUT_RESULT"
}
choose_weekday() {
local -a days=("Montag" "Dienstag" "Mittwoch" "Donnerstag" "Freitag" "Samstag" "Sonntag" "← Zurück")
menu_select "Zeitplan" "Wochentag auswählen." "${days[@]}"
case "$MENU_RESULT" in
0) SCHEDULE_WEEKDAY="Mon" ;; 1) SCHEDULE_WEEKDAY="Tue" ;;
2) SCHEDULE_WEEKDAY="Wed" ;; 3) SCHEDULE_WEEKDAY="Thu" ;;
4) SCHEDULE_WEEKDAY="Fri" ;; 5) SCHEDULE_WEEKDAY="Sat" ;;
6) SCHEDULE_WEEKDAY="Sun" ;; 7) return 1 ;;
esac
return 0
}
choose_monthday() {
input_text "Zeitplan" "Tag des Monats auswählen. Empfehlung: 1–28, damit jeder Monat gültig ist." "$SCHEDULE_MONTHDAY" '^([1-9]|1[0-9]|2[0-8])$' "Bitte einen Tag von 1 bis 28 eingeben."
SCHEDULE_MONTHDAY="$INPUT_RESULT"
}
choose_month() {
local title="$1" current="$2"
local -a months=("Januar" "Februar" "März" "April" "Mai" "Juni" "Juli" "August" "September" "Oktober" "November" "Dezember" "← Zurück")
menu_select "$title" "Monat auswählen." "${months[@]}"
if (( MENU_RESULT == 12 )); then return 1; fi
MONTH_RESULT=$((MENU_RESULT + 1))
return 0
}
backup_jobs_text() {
if ! command -v pvesh >/dev/null 2>&1; then
echo "Keine Backup-Daten verfügbar."
return
fi
local json
json="$(pvesh get /cluster/backup --output-format json 2>/dev/null || true)"
if [[ -z "$json" || "$json" == "[]" ]]; then
echo "Keine Proxmox-Backup-Jobs eingerichtet."
return
fi
BACKUP_JSON="$json" python3 - <<'PY'
import json, os
jobs=json.loads(os.environ["BACKUP_JSON"])
enabled=[]
for j in jobs:
if str(j.get("enabled","1")).lower() in ("0","false","no"):
continue
enabled.append(j)
if not enabled:
print("Keine aktivierten Proxmox-Backup-Jobs.")
else:
for j in enabled:
jid=j.get("id","?")
sched=j.get("schedule","ohne Zeitplan")
storage=j.get("storage","?")
mode=j.get("mode","snapshot")
print(f"• {sched:<20} Storage: {storage:<12} Modus: {mode} ({jid})")
PY
}
backup_recommendation() {
local json
json="$(pvesh get /cluster/backup --output-format json 2>/dev/null || true)"
[[ -n "$json" && "$json" != "[]" ]] || { echo "Keine Backup-Jobs vorhanden."; return; }
BACKUP_JSON="$json" python3 - <<'PY'
import json, os, re
jobs=json.loads(os.environ["BACKUP_JSON"])
times=[]
for j in jobs:
if str(j.get("enabled","1")).lower() in ("0","false","no"):
continue
s=str(j.get("schedule",""))
m=re.search(r'(\d{1,2}):([0-5]\d)$', s)
if m:
times.append((int(m.group(1)),int(m.group(2))))
if not times:
print("Empfehlung: Update möglichst außerhalb der Backup-Zeiten planen.")
else:
h,m=max(times)
total=(h*60+m+180)%(24*60)
print(f"Empfehlung: mindestens ca. 3 Stunden Abstand zu Backup-Starts einplanen; als Orientierung z. B. {total//60:02d}:{total%60:02d} Uhr.")
print("Hinweis: Die echte Backup-Dauer ist aus dem Zeitplan nicht bekannt.")
PY
}
# Prüft die gewählte Wiederholung gegen häufige Proxmox-Backup-Zeitpläne.
# Es werden Vorkommen der nächsten 400 Tage erzeugt und ±2 Stunden verglichen.
check_backup_conflicts() {
local json result
json="$(pvesh get /cluster/backup --output-format json 2>/dev/null || true)"
if [[ -z "$json" || "$json" == "[]" ]]; then
BACKUP_CHECK_STATUS="ok"
BACKUP_CHECK_TEXT="Keine Proxmox-Backup-Jobs vorhanden."
return
fi
result="$(
BACKUP_JSON="$json" \
S_TYPE="$SCHEDULE_TYPE" S_TIME="$SCHEDULE_TIME" S_WDAY="$SCHEDULE_WEEKDAY" \
S_MDAY="$SCHEDULE_MONTHDAY" S_INT="$SCHEDULE_INTERVAL_MONTHS" \
S_START_MONTH="$SCHEDULE_START_MONTH" S_YMONTH="$SCHEDULE_YEAR_MONTH" \
S_YDAY="$SCHEDULE_YEAR_DAY" \
python3 - <<'PY'
import json, os, re
from datetime import datetime, timedelta
now=datetime.now().replace(second=0,microsecond=0)
end=now+timedelta(days=400)
daymap={"mon":0,"tue":1,"wed":2,"thu":3,"fri":4,"sat":5,"sun":6}
stype=os.environ["S_TYPE"]
hh,mm=map(int,os.environ["S_TIME"].split(":"))
uw=daymap.get(os.environ["S_WDAY"].lower()[:3],6)
md=int(os.environ["S_MDAY"]); inter=int(os.environ["S_INT"])
startm=int(os.environ["S_START_MONTH"]); ym=int(os.environ["S_YMONTH"]); yd=int(os.environ["S_YDAY"])
def updater_occurs(d):
if stype=="daily": return True
if stype=="weekly": return d.weekday()==uw
if stype=="monthly": return d.day==md
if stype=="interval_months":
months=[]
m=startm
while m<=12:
months.append(m); m+=inter
return d.month in months and d.day==md
if stype=="yearly": return d.month==ym and d.day==yd
return False
up=[]
d=now.replace(hour=0,minute=0)
while d<=end:
if updater_occurs(d):
x=d.replace(hour=hh,minute=mm)
if x>=now: up.append(x)
d+=timedelta(days=1)
def parse_days(expr):
expr=(expr or "").lower().strip()
if not expr or expr=="*": return set(range(7))
out=set()
for p in re.split(r"[,;]",expr):
p=p.strip()
if ".." in p:
a,b=p.split("..",1)
a=daymap.get(a[:3]); b=daymap.get(b[:3])
if a is None or b is None: return None
i=a
while True:
out.add(i)
if i==b: break
i=(i+1)%7
else:
x=daymap.get(p[:3])
if x is None: return None
out.add(x)
return out
def backup_occurrences(s):
s=s.strip().lower()
# Häufig: "1:00", "01:00", "sun 01:00", "mon..fri 03:00", "sat,sun 02:00"
m=re.fullmatch(r"(?:(?P<days>[a-z.,]+(?:\.\.[a-z]+)?)\s+)?(?P<h>\d{1,2}):(?P<m>\d{2})",s)
if not m: return None
days=parse_days(m.group("days") or "*")
if days is None: return None
bh=int(m.group("h")); bm=int(m.group("m"))
arr=[]
d=now.replace(hour=0,minute=0)
while d<=end:
if d.weekday() in days:
x=d.replace(hour=bh,minute=bm)
if x>=now: arr.append(x)
d+=timedelta(days=1)
return arr
jobs=json.loads(os.environ["BACKUP_JSON"])
conf=[]
unknown=[]
for j in jobs:
if str(j.get("enabled","1")).lower() in ("0","false","no"): continue
sched=str(j.get("schedule","")).strip()
bo=backup_occurrences(sched)
if bo is None:
unknown.append((j.get("id","?"),sched))
continue
# linear enough for <=400 days
found=None
for u in up:
for b in bo:
diff=(u-b).total_seconds()/60
if abs(diff)<=120:
found=(u,b,diff)
break
if b>u+timedelta(hours=2): break
if found: break
if found:
conf.append((j.get("id","?"),sched,found[2]))
if conf:
print("WARN")
for jid,sched,diff in conf:
if abs(diff)<0.5: rel="gleiche Startzeit"
elif diff>0: rel=f"Updater {int(abs(diff))} Min. nach Backup-Start"
else: rel=f"Updater {int(abs(diff))} Min. vor Backup-Start"
print(f"{sched} | {jid} | {rel}")
elif unknown:
print("UNKNOWN")
for jid,sched in unknown:
print(f"{sched} | {jid}")
else:
print("OK")
PY
)"
case "$result" in
WARN*)
BACKUP_CHECK_STATUS="warn"
BACKUP_CHECK_TEXT="$(printf '%s\n' "$result" | tail -n +2)"
;;
UNKNOWN*)
BACKUP_CHECK_STATUS="unknown"
BACKUP_CHECK_TEXT="$(printf '%s\n' "$result" | tail -n +2)"
;;
*)
BACKUP_CHECK_STATUS="ok"
BACKUP_CHECK_TEXT="Keine zeitliche Überschneidung innerhalb ±2 Stunden erkannt."
;;
esac
}
schedule_review() {
while true; do
build_oncalendar
check_backup_conflicts
header "Zeitplan prüfen"
printf '%sGewählter Zeitplan:%s\n %s\n systemd: %s\n\n' "$C_BOLD" "$C_RESET" "$(schedule_description)" "$ONCALENDAR" >/dev/tty
printf '%sVorhandene Proxmox-Autobackups:%s\n' "$C_BOLD" "$C_RESET" >/dev/tty
backup_jobs_text | while IFS= read -r line; do printf ' %s\n' "$line" >/dev/tty; done
printf '\n' >/dev/tty
backup_recommendation | while IFS= read -r line; do printf '%s%s%s\n' "$C_CYAN" "$line" "$C_RESET" >/dev/tty; done
printf '\n' >/dev/tty
case "$BACKUP_CHECK_STATUS" in
warn)
printf '%s%sWARNUNG: Mögliche Überschneidung mit Autobackup!%s\n' "$C_RED" "$C_BOLD" "$C_RESET" >/dev/tty
while IFS='|' read -r sched jid rel; do
printf ' %s• %s (%s) – %s%s\n' "$C_YELLOW" "$sched" "$jid" "$rel" "$C_RESET" >/dev/tty
done <<< "$BACKUP_CHECK_TEXT"
printf '\n%sDie tatsächliche Backup-Dauer kann länger als das ±2-Stunden-Fenster sein.%s\n' "$C_YELLOW" "$C_RESET" >/dev/tty
;;
unknown)
printf '%sEinige Backup-Zeitpläne konnten nicht automatisch bewertet werden:%s\n' "$C_YELLOW" "$C_RESET" >/dev/tty
printf '%s\n' "$BACKUP_CHECK_TEXT" >/dev/tty
;;
ok)
printf '%s✓ %s%s\n' "$C_GREEN" "$BACKUP_CHECK_TEXT" "$C_RESET" >/dev/tty
;;
esac
printf '\n%sDer Updater wartet zur Laufzeit zusätzlich auf ein bereits laufendes vzdump-Backup.%s\n' "$C_DIM" "$C_RESET" >/dev/tty
printf '%sBackups innerhalb einer VM/eines LXC sind nicht allgemein erkennbar.%s\n' "$C_DIM" "$C_RESET" >/dev/tty
printf '\n%sEnter = Menü öffnen%s' "$C_DIM" "$C_RESET" >/dev/tty
IFS= read -r _ </dev/tty
if [[ "$BACKUP_CHECK_STATUS" == "warn" ]]; then
menu_select "Zeitplan prüfen" "Es besteht eine mögliche Backup-Überschneidung." \
"Zeitplan ändern (empfohlen)" \
"Trotzdem übernehmen" \
"← Zurück"
case "$MENU_RESULT" in
0) return 2 ;;
1)
confirm_menu "Konflikt bestätigen" "Zeitplan trotz erkannter Backup-Überschneidung wirklich übernehmen?" "no"
[[ "$REPLY" == "yes" ]] && return 0
;;
2) return 1 ;;
esac
else
menu_select "Zeitplan prüfen" "Zeitplan kontrollieren." \
"✓ Zeitplan übernehmen" \
"Zeitplan ändern" \
"← Zurück"
case "$MENU_RESULT" in
0) return 0 ;;
1) return 2 ;;
2) return 1 ;;
esac
fi
done
}
configure_schedule() {
while true; do
header "Zeitplan"
printf '%sAktuell:%s %s\n\n' "$C_BOLD" "$C_RESET" "$(schedule_description)" >/dev/tty
printf '%sVorhandene Proxmox-Autobackups:%s\n' "$C_BOLD" "$C_RESET" >/dev/tty
backup_jobs_text | while IFS= read -r line; do printf ' %s\n' "$line" >/dev/tty; done
printf '\n' >/dev/tty
backup_recommendation | while IFS= read -r line; do printf '%s%s%s\n' "$C_CYAN" "$line" "$C_RESET" >/dev/tty; done
printf '\n%sEnter = Häufigkeit auswählen%s' "$C_DIM" "$C_RESET" >/dev/tty
IFS= read -r _ </dev/tty
menu_select "Zeitplan" "Wie oft soll der Updater automatisch laufen?" \
"Täglich" \
"Wöchentlich (empfohlen)" \
"Monatlich" \
"Alle X Monate" \
"Jährlich" \
"Benutzerdefinierter systemd-Zeitplan" \
"← Zurück"
case "$MENU_RESULT" in
0)
SCHEDULE_TYPE="daily"
choose_time
;;
1)
SCHEDULE_TYPE="weekly"
choose_weekday || continue
choose_time
;;
2)
SCHEDULE_TYPE="monthly"
choose_monthday
choose_time
;;
3)
SCHEDULE_TYPE="interval_months"
input_text "Zeitplan" "Intervall in Monaten eingeben (2–12)." "$SCHEDULE_INTERVAL_MONTHS" '^([2-9]|1[0-2])$' "Bitte 2 bis 12 eingeben."
SCHEDULE_INTERVAL_MONTHS="$INPUT_RESULT"
choose_month "Startmonat" "$SCHEDULE_START_MONTH" || continue
SCHEDULE_START_MONTH="$MONTH_RESULT"
choose_monthday
choose_time
;;
4)
SCHEDULE_TYPE="yearly"
choose_month "Monat" "$SCHEDULE_YEAR_MONTH" || continue
SCHEDULE_YEAR_MONTH="$MONTH_RESULT"
input_text "Zeitplan" "Tag des Monats (1–28)." "$SCHEDULE_YEAR_DAY" '^([1-9]|1[0-9]|2[0-8])$' "Bitte 1 bis 28 eingeben."
SCHEDULE_YEAR_DAY="$INPUT_RESULT"
choose_time
;;
5)
SCHEDULE_TYPE="custom"
input_text "Zeitplan" "systemd OnCalendar-Ausdruck eingeben.\nBeispiel: Mon,Wed,Fri *-*-* 04:00:00" "$ONCALENDAR"
ONCALENDAR="$INPUT_RESULT"
if command -v systemd-analyze >/dev/null 2>&1; then
if ! systemd-analyze calendar "$ONCALENDAR" >/dev/null 2>&1; then
header "Zeitplan"
printf '%sUngültiger systemd-Kalenderausdruck.%s\n' "$C_RED" "$C_RESET" >/dev/tty
pause_key
continue
fi
fi
;;
6) return 1 ;;
esac
build_oncalendar
schedule_review
case "$?" in
0) DIRTY="yes"; return 0 ;;
1) return 1 ;;
2) continue ;;
esac
done
}
# ============================================================
# Einstellungen
# ============================================================
toggle_setting() {
local var="$1" label="$2" current
current="${!var}"
confirm_menu "$label" "$label" "$current"
printf -v "$var" '%s' "$REPLY"
DIRTY="yes"
}
configure_notifications() {
local json
confirm_menu "Benachrichtigungen" "Nach jedem Update-Lauf eine Proxmox-Benachrichtigung senden?" "$NOTIFY_ENABLED"
NOTIFY_ENABLED="$REPLY"
DIRTY="yes"
if [[ "$NOTIFY_ENABLED" != "yes" ]]; then
NOTIFY_TARGET=""
return
fi
json="$(pvesh get /cluster/notifications/targets --output-format json 2>/dev/null || true)"
local -a targets=()
if [[ -n "$json" ]]; then
mapfile -t targets < <(TARGET_JSON="$json" python3 - <<'PY'
import json, os
try:
data=json.loads(os.environ["TARGET_JSON"])
for x in data:
n=x.get("name")
if n: print(n)
except Exception:
pass
PY
)
fi
if (( ${#targets[@]} == 0 )); then
header "Benachrichtigungen"
printf '%sKeine Proxmox-Notification-Targets gefunden.%s\n' "$C_YELLOW" "$C_RESET" >/dev/tty
printf 'Benachrichtigungen wurden deaktiviert.\n' >/dev/tty
NOTIFY_ENABLED="no"
NOTIFY_TARGET=""
pause_key
return
fi
targets+=("← Zurück")
menu_select "Benachrichtigungen" "Notification-Target auswählen." "${targets[@]}"
if (( MENU_RESULT == ${#targets[@]}-1 )); then return; fi
NOTIFY_TARGET="${targets[$MENU_RESULT]}"
}
configure_exclusions() {
local -a rows ids names types selected
local line id name type key rest pos=0 i
mapfile -t rows < <(
{
pct list 2>/dev/null | awk 'NR>1 {id=$1; name=$3; if(name=="")name="?"; print id"|LXC|"name}'
qm list 2>/dev/null | awk 'NR>1 {id=$1; name=$2; if(name=="")name="?"; print id"|VM|"name}'
} | sort -n
)
if (( ${#rows[@]} == 0 )); then
header "Ausschlüsse"
printf 'Keine Gäste gefunden.\n' >/dev/tty
pause_key
return
fi
for line in "${rows[@]}"; do
IFS='|' read -r id type name <<< "$line"
ids+=("$id"); types+=("$type"); names+=("$name")
if [[ " $EXCLUDE_GUESTS " == *" $id "* ]]; then selected+=("1"); else selected+=("0"); fi
done
while true; do
header "Ausschlüsse"
printf 'Mit %sLeertaste%s markieren/entfernen, ↑/↓ bewegen.\n\n' "$C_BOLD" "$C_RESET" >/dev/tty
for ((i=0;i<${#ids[@]};i++)); do
local mark="[ ]"
[[ "${selected[$i]}" == "1" ]] && mark="[x]"
if (( i == pos )); then
printf ' %s▶ %s %-4s %-5s %s%s\n' "$C_INV" "$mark" "${ids[$i]}" "${types[$i]}" "${names[$i]}" "$C_RESET" >/dev/tty
else
printf ' %s %-4s %-5s %s\n' "$mark" "${ids[$i]}" "${types[$i]}" "${names[$i]}" >/dev/tty
fi
done
printf '\n%sLeertaste = umschalten Enter = Weiter B = Zurück C = alle löschen%s\n' "$C_DIM" "$C_RESET" >/dev/tty
IFS= read -rsn1 key </dev/tty || true
if [[ "$key" == $'\x1b' ]]; then
IFS= read -rsn2 -t 0.1 rest </dev/tty || true
key+="$rest"
fi
case "$key" in
$'\x1b[A') (( pos > 0 )) && ((pos--)) || pos=$((${#ids[@]}-1)) ;;
$'\x1b[B') (( pos < ${#ids[@]}-1 )) && ((pos++)) || pos=0 ;;
" ") [[ "${selected[$pos]}" == "1" ]] && selected[$pos]="0" || selected[$pos]="1" ;;
c|C) for ((i=0;i<${#selected[@]};i++)); do selected[$i]="0"; done ;;
b|B) return ;;
"")
EXCLUDE_GUESTS=""
for ((i=0;i<${#ids[@]};i++)); do
if [[ "${selected[$i]}" == "1" ]]; then
EXCLUDE_GUESTS+="${EXCLUDE_GUESTS:+ }${ids[$i]}"
fi
done
DIRTY="yes"
return
;;
esac
done
}
settings_menu() {
while true; do
menu_select "Einstellungen" "Mit Cursor auswählen. Änderungen werden erst bei „Speichern & anwenden“ geschrieben." \
"Host aktualisieren: $(yn_de "$UPDATE_HOST")" \
"LXC aktualisieren: $(yn_de "$UPDATE_LXC")" \
"Linux-VMs aktualisieren: $(yn_de "$UPDATE_VMS")" \
"Gestoppte Gäste starten: $(yn_de "$UPDATE_STOPPED")" \
"Host automatisch neu starten: $(yn_de "$AUTO_REBOOT_HOST")" \
"Benachrichtigungen: $(yn_de "$NOTIFY_ENABLED") ${NOTIFY_TARGET:+($NOTIFY_TARGET)}" \
"Ausschlüsse: ${EXCLUDE_GUESTS:-keine}" \
"Zeitplan: $(schedule_description)" \
"Erweiterte Wartezeiten" \
"✓ Speichern & anwenden" \
"← Zurück"
case "$MENU_RESULT" in
0) toggle_setting UPDATE_HOST "Host automatisch aktualisieren?" ;;
1) toggle_setting UPDATE_LXC "LXC automatisch aktualisieren?" ;;
2) toggle_setting UPDATE_VMS "Linux-VMs automatisch aktualisieren?" ;;
3) toggle_setting UPDATE_STOPPED "Gestoppte Gäste für Updates automatisch starten?" ;;
4) toggle_setting AUTO_REBOOT_HOST "Host automatisch neu starten, wenn erforderlich?" ;;
5) configure_notifications ;;
6) configure_exclusions ;;
7) configure_schedule || true ;;
8)
input_text "Erweiterte Wartezeiten" "APT-Lock-Wartezeit in Sekunden." "$APT_LOCK_TIMEOUT" '^[0-9]+$'
APT_LOCK_TIMEOUT="$INPUT_RESULT"
input_text "Erweiterte Wartezeiten" "Maximale Wartezeit auf laufendes Proxmox-Backup in Sekunden." "$BACKUP_WAIT_TIMEOUT" '^[0-9]+$'
BACKUP_WAIT_TIMEOUT="$INPUT_RESULT"
input_text "Erweiterte Wartezeiten" "Prüfintervall für laufendes Backup in Sekunden." "$BACKUP_WAIT_INTERVAL" '^[0-9]+$'
BACKUP_WAIT_INTERVAL="$INPUT_RESULT"
DIRTY="yes"
;;
9) apply_installation; return ;;
10)
if [[ "$DIRTY" == "yes" ]]; then
confirm_menu "Zurück" "Ungespeicherte Änderungen verwerfen?" "no"
[[ "$REPLY" == "yes" ]] && load_existing && DIRTY="no" && return
else
return
fi
;;
esac
done
}
# ============================================================
# Installation / systemd
# ============================================================
download_updater() {
local tmp
tmp="$(mktemp)"
if ! curl -fsSL "${RAW}/updater.sh" -o "$tmp"; then
rm -f "$tmp"
die "updater.sh konnte nicht von Gitea geladen werden."
fi
[[ -s "$tmp" ]] || { rm -f "$tmp"; die "Heruntergeladene updater.sh ist leer."; }
bash -n "$tmp" || { rm -f "$tmp"; die "updater.sh enthält einen Syntaxfehler."; }
install -m 0750 "$tmp" "$UPDATER"
rm -f "$tmp"
}
write_service_timer() {
build_oncalendar
cat > "$SERVICE" <<'EOF'
[Unit]
Description=Proxmox Guest Updater
After=network-online.target pve-cluster.service
Wants=network-online.target
[Service]
Type=oneshot
ExecStart=/usr/local/sbin/pve-guest-update
Nice=10
IOSchedulingClass=best-effort
IOSchedulingPriority=7
TimeoutStartSec=infinity
EOF
cat > "$TIMER" <<EOF
[Unit]
Description=Proxmox Guest Updater - automatischer Zeitplan
[Timer]
OnCalendar=$ONCALENDAR
Persistent=true
RandomizedDelaySec=0
Unit=pve-guest-update.service
[Install]
WantedBy=timers.target
EOF
systemctl daemon-reload
systemctl enable --now pve-guest-update.timer >/dev/null
systemctl restart pve-guest-update.timer
}
apply_installation() {
build_oncalendar
check_backup_conflicts
header "Zusammenfassung"
printf '%-34s %s\n' "Host aktualisieren:" "$(yn_de "$UPDATE_HOST")" >/dev/tty
printf '%-34s %s\n' "LXC aktualisieren:" "$(yn_de "$UPDATE_LXC")" >/dev/tty
printf '%-34s %s\n' "Linux-VMs aktualisieren:" "$(yn_de "$UPDATE_VMS")" >/dev/tty
printf '%-34s %s\n' "Gestoppte Gäste starten:" "$(yn_de "$UPDATE_STOPPED")" >/dev/tty
printf '%-34s %s\n' "Automatischer Host-Neustart:" "$(yn_de "$AUTO_REBOOT_HOST")" >/dev/tty
printf '%-34s %s\n' "Benachrichtigungen:" "$(yn_de "$NOTIFY_ENABLED") ${NOTIFY_TARGET:+($NOTIFY_TARGET)}" >/dev/tty
printf '%-34s %s\n' "Ausschlüsse:" "${EXCLUDE_GUESTS:-keine}" >/dev/tty
printf '%-34s %s\n' "Zeitplan:" "$(schedule_description)" >/dev/tty
printf '%-34s %s\n' "OnCalendar:" "$ONCALENDAR" >/dev/tty
printf '\n%sAutobackups:%s\n' "$C_BOLD" "$C_RESET" >/dev/tty
backup_jobs_text | while IFS= read -r line; do printf ' %s\n' "$line" >/dev/tty; done
if [[ "$BACKUP_CHECK_STATUS" == "warn" ]]; then
printf '\n%s%sWARNUNG: Der gewählte Zeitplan überschneidet sich möglicherweise mit einem Backup.%s\n' "$C_RED" "$C_BOLD" "$C_RESET" >/dev/tty
fi
printf '\n' >/dev/tty
confirm_menu "Zusammenfassung" "Diese Einstellungen jetzt speichern und anwenden?" "yes"
[[ "$REPLY" == "yes" ]] || return
if [[ "$BACKUP_CHECK_STATUS" == "warn" ]]; then
confirm_menu "Backup-Konflikt" "Trotz erkannter Backup-Überschneidung wirklich anwenden?" "no"
[[ "$REPLY" == "yes" ]] || { configure_schedule || true; return; }
fi
header "Installation"
printf 'Lade aktuelle updater.sh ...\n' >/dev/tty
command -v curl >/dev/null 2>&1 || { apt-get update && apt-get install -y curl; }
download_updater
write_config
write_service_timer
INSTALLED="yes"
DIRTY="no"
printf '\n%s✓ Proxmox Guest Updater wurde erfolgreich installiert/aktualisiert.%s\n\n' "$C_GREEN" "$C_RESET" >/dev/tty
printf 'Zeitplan: %s\n' "$(schedule_description)" >/dev/tty
printf 'Nächster Lauf:\n' >/dev/tty
systemctl list-timers pve-guest-update.timer --no-pager 2>/dev/null | tail -n +2 >/dev/tty || true
printf '\nEs wurde kein Update-Lauf gestartet.\n' >/dev/tty
pause_key
}
uninstall_manager() {
header "Deinstallation"
printf '%sEntfernt werden:%s\n' "$C_BOLD" "$C_RESET" >/dev/tty
printf ' • Updater\n • Konfiguration\n • systemd Service und Timer\n • Updater-Notification-Template/Matcher\n\n' >/dev/tty
printf 'Das Log %s bleibt standardmäßig erhalten.\n' "$LOGFILE" >/dev/tty
confirm_menu "Deinstallation" "Proxmox Guest Updater wirklich vollständig entfernen?" "no"
[[ "$REPLY" == "yes" ]] || return
systemctl disable --now pve-guest-update.timer >/dev/null 2>&1 || true
systemctl stop pve-guest-update.service >/dev/null 2>&1 || true
rm -f "$TIMER" "$SERVICE" "$UPDATER" "$CONFIG"
rm -f \
"/etc/pve/notification-templates/default/${NOTIFY_TEMPLATE}-subject.txt.hbs" \
"/etc/pve/notification-templates/default/${NOTIFY_TEMPLATE}-body.txt.hbs" \
"/etc/pve/notification-templates/default/${NOTIFY_TEMPLATE}-body.html.hbs"
pvesh delete "/cluster/notifications/matchers/${NOTIFY_MATCHER}" >/dev/null 2>&1 || true
systemctl daemon-reload
systemctl reset-failed pve-guest-update.service >/dev/null 2>&1 || true
confirm_menu "Deinstallation" "Auch das bisherige Log löschen?" "no"
[[ "$REPLY" == "yes" ]] && rm -f "$LOGFILE"
INSTALLED="no"
header "Deinstallation"
printf '%s✓ Proxmox Guest Updater wurde entfernt.%s\n' "$C_GREEN" "$C_RESET" >/dev/tty
pause_key
}
# ============================================================
# Status / Aktionen
# ============================================================
show_status() {
header "Status"
if [[ "$INSTALLED" != "yes" ]]; then
printf '%sNicht installiert.%s\n' "$C_YELLOW" "$C_RESET" >/dev/tty
pause_key
return
fi
printf '%sInstallation:%s vorhanden\n' "$C_BOLD" "$C_RESET" >/dev/tty
printf 'Updater: %s\n' "$UPDATER" >/dev/tty
printf 'Konfiguration: %s\n' "$CONFIG" >/dev/tty
printf 'Zeitplan: %s\n' "$(schedule_description)" >/dev/tty
printf 'Ausschlüsse: %s\n\n' "${EXCLUDE_GUESTS:-keine}" >/dev/tty
printf '%sTimer:%s\n' "$C_BOLD" "$C_RESET" >/dev/tty
systemctl list-timers pve-guest-update.timer --no-pager 2>/dev/null >/dev/tty || true
printf '\n%sAutobackups:%s\n' "$C_BOLD" "$C_RESET" >/dev/tty
backup_jobs_text | while IFS= read -r line; do printf ' %s\n' "$line" >/dev/tty; done
printf '\n%sLetzte Logzeilen:%s\n' "$C_BOLD" "$C_RESET" >/dev/tty
tail -n 12 "$LOGFILE" 2>/dev/null >/dev/tty || echo " Noch kein Log vorhanden." >/dev/tty
pause_key
}
run_check() {
[[ -x "$UPDATER" ]] || { header "Update-Check"; printf 'Updater ist nicht installiert.\n' >/dev/tty; pause_key; return; }
header "Update-Check"
printf 'Starte nur die Prüfung. Es werden keine Pakete installiert.\n\n' >/dev/tty
"$UPDATER" --check </dev/tty >/dev/tty 2>&1 || true
pause_key
}
run_update_now() {
[[ -x "$UPDATER" ]] || { header "Update starten"; printf 'Updater ist nicht installiert.\n' >/dev/tty; pause_key; return; }
confirm_menu "Update starten" "Vollständigen Update-Lauf jetzt manuell starten?" "no"
[[ "$REPLY" == "yes" ]] || return
header "Update läuft"
"$UPDATER" </dev/tty >/dev/tty 2>&1 || true
pause_key
}
# ============================================================
# Hauptmenü
# ============================================================
first_install_wizard() {
# Sinnvolle Empfehlung anzeigen, dann Einstellungen.
header "Ersteinrichtung"
printf '%sEmpfohlene Grundeinstellung:%s\n' "$C_BOLD" "$C_RESET" >/dev/tty
printf ' • Host, laufende LXC und Linux-VMs aktualisieren\n' >/dev/tty
printf ' • Gestoppte Gäste nicht automatisch starten\n' >/dev/tty
printf ' • Host-Neustart nur bei erfolgreichem Host-Update\n' >/dev/tty
printf ' • Wöchentlicher Lauf außerhalb der Backup-Zeiten\n' >/dev/tty
printf ' • Proxmox-Backup-Schutz bleibt zur Laufzeit aktiv\n\n' >/dev/tty
printf '%sVorhandene Autobackups:%s\n' "$C_BOLD" "$C_RESET" >/dev/tty
backup_jobs_text | while IFS= read -r line; do printf ' %s\n' "$line" >/dev/tty; done
printf '\n' >/dev/tty
backup_recommendation | while IFS= read -r line; do printf '%s%s%s\n' "$C_CYAN" "$line" "$C_RESET" >/dev/tty; done
pause_key
settings_menu
}
main_menu() {
while true; do
load_existing
local state
if [[ "$INSTALLED" == "yes" ]]; then state="${C_GREEN}installiert${C_RESET}"; else state="${C_YELLOW}nicht installiert${C_RESET}"; fi
if [[ "$INSTALLED" == "yes" ]]; then
menu_select "Manager" "Status: installiert | $(schedule_description)" \
"⚙ Einstellungen ändern" \
"↻ Updater-Datei aus Gitea aktualisieren" \
"✓ Update-Check starten" \
"▶ Update jetzt starten" \
"ℹ Status / Zeitplan / Log" \
"✖ Deinstallieren" \
"Beenden"
case "$MENU_RESULT" in
0) settings_menu ;;
1)
header "Updater aktualisieren"
printf 'Lade aktuelle updater.sh aus Gitea ...\n\n' >/dev/tty
download_updater
printf '%s✓ updater.sh wurde aktualisiert.%s\n' "$C_GREEN" "$C_RESET" >/dev/tty
pause_key
;;
2) run_check ;;
3) run_update_now ;;
4) show_status ;;
5) uninstall_manager ;;
6) clear_screen; return ;;
esac
else
menu_select "Manager" "Status: nicht installiert" \
"▶ Installieren / Einrichten" \
"ℹ Proxmox-Autobackups anzeigen" \
"Beenden"
case "$MENU_RESULT" in
0) first_install_wizard ;;
1)
header "Autobackups"
backup_jobs_text | while IFS= read -r line; do printf '%s\n' "$line" >/dev/tty; done
printf '\n' >/dev/tty
backup_recommendation | while IFS= read -r line; do printf '%s%s%s\n' "$C_CYAN" "$line" "$C_RESET" >/dev/tty; done
pause_key
;;
2) clear_screen; return ;;
esac
fi
done
}
# ============================================================
# Start
# ============================================================
need_root_and_pve
# python3 wird auf Proxmox normalerweise bereits benötigt/vorhanden.
command -v python3 >/dev/null 2>&1 || die "python3 wird für den Manager benötigt."
load_existing
main_menu