Files
Proxmox-und-GuestUpdater/manager.sh
T
2026-10-04 21:37:26 +02:00

1173 lines
41 KiB
Bash

#!/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
}
read_key() {
local old key="" rest=""
old="$(stty -g </dev/tty)" || return 1
if ! stty -echo -icanon min 1 time 0 </dev/tty; then
return 1
fi
key="$(dd bs=1 count=1 </dev/tty 2>/dev/null || true)"
if [[ "$key" == $'\x1b' ]]; then
stty min 0 time 1 </dev/tty || true
rest="$(dd bs=1 count=2 </dev/tty 2>/dev/null || true)"
key+="$rest"
fi
stty "$old" </dev/tty || true
[[ -n "$key" ]] || return 1
KEY_RESULT="$key"
}
# 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%shoch/runter auswählen Enter bestätigen%s\n' "$C_DIM" "$C_RESET" >/dev/tty
key=""
if ! read_key; then
die "Terminal-Eingabe konnte nicht gelesen werden."
fi
key="$KEY_RESULT"
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 '%sOK %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." \
"OK 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, hoch/runter 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
key=""
if ! read_key; then
die "Terminal-Eingabe konnte nicht gelesen werden."
fi
key="$KEY_RESULT"
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" \
"OK 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%sOK 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 '%sOK 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 Einstellungen ändern" \
"Update Updater-Datei aus Gitea aktualisieren" \
"OK Update-Check starten" \
"> Update jetzt starten" \
"Info Status / Zeitplan / Log" \
"X 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 '%sOK 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" \
"Info 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