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

845 lines
27 KiB
Bash

#!/usr/bin/env bash
set -Eeuo pipefail
# Proxmox Guest Updater Manager
# Neuaufbau: stabile whiptail-Oberflaeche statt selbst gezeichneter Cursor-Menues.
RAW="https://gitea.vourx.com/sharky/Proxmox-und-GuestUpdater/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"
UPDATE_HOST="yes"
UPDATE_LXC="yes"
UPDATE_VMS="yes"
UPDATE_STOPPED="no"
AUTO_REBOOT_HOST="yes"
NOTIFY_ENABLED="no"
NOTIFY_TARGET=""
EXCLUDE_GUESTS=""
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"
die() { echo "FEHLER: $*" >&2; exit 1; }
need_base() {
[[ $EUID -eq 0 ]] || die "Bitte als root ausfuehren."
command -v pveversion >/dev/null 2>&1 || die "Proxmox VE wurde nicht erkannt."
command -v python3 >/dev/null 2>&1 || die "python3 fehlt."
if ! command -v whiptail >/dev/null 2>&1; then
echo "Installiere whiptail fuer die Menueoberflaeche ..."
apt-get update
apt-get install -y whiptail
fi
}
# whiptail liest IMMER direkt vom Terminal. Damit funktioniert auch curl ... | bash.
wt_menu() {
local title="$1" text="$2"; shift 2
whiptail --title "$title" --menu "$text" 22 84 13 "$@" 3>&1 1>&2 2>&3 </dev/tty
}
wt_yesno() {
local title="$1" text="$2" default="${3:-no}" args=()
[[ "$default" == "no" ]] && args+=(--defaultno)
whiptail "${args[@]}" --title "$title" --yesno "$text" 12 78 </dev/tty
}
wt_input() {
local title="$1" text="$2" value="${3:-}"
whiptail --title "$title" --inputbox "$text" 12 78 "$value" 3>&1 1>&2 2>&3 </dev/tty
}
wt_msg() {
whiptail --title "$1" --msgbox "$2" 20 84 </dev/tty
}
yn() { [[ "$1" == "yes" ]] && echo "Ja" || echo "Nein"; }
toggle() { [[ "$1" == "yes" ]] && echo "no" || echo "yes"; }
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 Maerz;; 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;;
esac
}
timer_next_run() {
local x
x="$(systemctl show pve-guest-update.timer -p NextElapseUSecRealtime --value 2>/dev/null || true)"
[[ -n "$x" && "$x" != "n/a" ]] && echo "$x" || echo "nicht verfuegbar"
}
last_run_text() {
local active result ts
active="$(systemctl show pve-guest-update.service -p ActiveState --value 2>/dev/null || true)"
result="$(systemctl show pve-guest-update.service -p Result --value 2>/dev/null || true)"
ts="$(systemctl show pve-guest-update.service -p ExecMainExitTimestamp --value 2>/dev/null || true)"
[[ -z "$ts" || "$ts" == "n/a" ]] && { echo "noch kein Lauf"; return; }
if [[ "$result" == "success" ]]; then
echo "$ts (erfolgreich)"
elif [[ -n "$result" ]]; then
echo "$ts ($result)"
else
echo "$ts"
fi
}
backup_short() {
local json
json="$(pvesh get /cluster/backup --output-format json 2>/dev/null || true)"
[[ -n "$json" && "$json" != "[]" ]] || { echo "keine"; return; }
BACKUP_JSON="$json" python3 - <<'PY'
import json, os
out=[]
try:
for j in json.loads(os.environ["BACKUP_JSON"]):
if str(j.get("enabled","1")).lower() in ("0","false","no"):
continue
sc=str(j.get("schedule","?"))
out.append(sc)
except Exception:
pass
print(", ".join(out) if out else "keine")
PY
}
conflict_short() {
local c status
c="$(backup_conflicts)"
status="${c%%|*}"
case "$status" in
WARN) echo "WARNUNG - Zeitkonflikt" ;;
UNKNOWN) echo "nicht vollstaendig pruefbar" ;;
*) echo "kein Konflikt" ;;
esac
}
dashboard_text() {
cat <<EOF
Host: $(hostname)
Proxmox: $(pveversion | head -n1)
Kernel: $(uname -r)
Status: $([[ "$INSTALLED" == yes ]] && echo "Installiert" || echo "Nicht installiert")
Zeitplan: $(schedule_desc)
Naechster Lauf: $(timer_next_run)
Letzter Lauf: $(last_run_text)
Autobackups: $(backup_short)
Backup-Pruefung: $(conflict_short)
EOF
}
load_config() {
INSTALLED="no"
if [[ -f "$CONFIG" ]]; then
INSTALLED="yes"
# shellcheck disable=SC1090
source "$CONFIG"
fi
[[ -x "$UPDATER" ]] && INSTALLED="yes"
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}"
NOTIFY_ENABLED="${NOTIFY_ENABLED:-no}"
NOTIFY_TARGET="${NOTIFY_TARGET:-}"
EXCLUDE_GUESTS="${EXCLUDE_GUESTS:-}"
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:-weekly}"
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
local old
old="$(sed -n 's/^OnCalendar=//p' "$TIMER" | head -n1)"
[[ -n "$old" ]] && ONCALENDAR="$old"
fi
}
write_config() {
cat >"$CONFIG" <<EOF
# Proxmox Guest Updater - verwaltet durch manager.sh
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"
# Nur fuer 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"
}
build_calendar() {
local m months="" mm
case "$SCHEDULE_TYPE" in
daily) ONCALENDAR="*-*-* $SCHEDULE_TIME:00" ;;
weekly) ONCALENDAR="$SCHEDULE_WEEKDAY *-*-* $SCHEDULE_TIME:00" ;;
monthly) ONCALENDAR="*-*-$SCHEDULE_MONTHDAY $SCHEDULE_TIME:00" ;;
interval)
m="$SCHEDULE_START_MONTH"
while ((m<=12)); do
printf -v mm '%02d' "$m"
months+="${months:+,}$mm"
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
}
schedule_desc() {
case "$SCHEDULE_TYPE" in
daily) echo "Taeglich um $SCHEDULE_TIME Uhr" ;;
weekly) echo "Woechentlich: $(weekday_de "$SCHEDULE_WEEKDAY"), $SCHEDULE_TIME Uhr" ;;
monthly) echo "Monatlich: am $SCHEDULE_MONTHDAY., $SCHEDULE_TIME Uhr" ;;
interval) echo "Alle $SCHEDULE_INTERVAL_MONTHS Monate ab $(month_de "$SCHEDULE_START_MONTH"), am $SCHEDULE_MONTHDAY., $SCHEDULE_TIME Uhr" ;;
yearly) echo "Jaehrlich: $SCHEDULE_YEAR_DAY. $(month_de "$SCHEDULE_YEAR_MONTH"), $SCHEDULE_TIME Uhr" ;;
custom) echo "Benutzerdefiniert: $ONCALENDAR" ;;
esac
}
backup_jobs() {
local json
json="$(pvesh get /cluster/backup --output-format json 2>/dev/null || true)"
[[ -n "$json" && "$json" != "[]" ]] || { echo "Keine Proxmox-Autobackups eingerichtet."; return; }
BACKUP_JSON="$json" python3 - <<'PY'
import json,os
for j in json.loads(os.environ["BACKUP_JSON"]):
if str(j.get("enabled","1")).lower() in ("0","false","no"): continue
print(f"{j.get('schedule','?'):16} Storage: {j.get('storage','?'):12} {j.get('id','?')}")
PY
}
backup_conflicts() {
local json
json="$(pvesh get /cluster/backup --output-format json 2>/dev/null || true)"
[[ -n "$json" && "$json" != "[]" ]] || { echo "OK|Keine Autobackups vorhanden."; return; }
BACKUP_JSON="$json" ST="$SCHEDULE_TYPE" TM="$SCHEDULE_TIME" WD="$SCHEDULE_WEEKDAY" \
MD="$SCHEDULE_MONTHDAY" IV="$SCHEDULE_INTERVAL_MONTHS" SM="$SCHEDULE_START_MONTH" \
YM="$SCHEDULE_YEAR_MONTH" YD="$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)
dm={"mon":0,"tue":1,"wed":2,"thu":3,"fri":4,"sat":5,"sun":6}
st=os.environ["ST"]; hh,mi=map(int,os.environ["TM"].split(":"))
wd=dm[os.environ["WD"].lower()[:3]]
md=int(os.environ["MD"]); iv=int(os.environ["IV"]); sm=int(os.environ["SM"])
ym=int(os.environ["YM"]); yd=int(os.environ["YD"])
def updater(d):
if st=="daily": return True
if st=="weekly": return d.weekday()==wd
if st=="monthly": return d.day==md
if st=="interval":
return d.day==md and d.month in range(sm,13,iv)
if st=="yearly": return d.month==ym and d.day==yd
return False
ups=[]
d=now.replace(hour=0,minute=0)
while d<=end:
if updater(d):
x=d.replace(hour=hh,minute=mi)
if x>=now: ups.append(x)
d+=timedelta(days=1)
def days(expr):
if not expr: return set(range(7))
out=set()
for p in re.split(r"[,;]",expr.lower()):
if ".." in p:
a,b=p.split("..",1); a=dm.get(a[:3]); b=dm.get(b[:3])
if a is None or b is None: return None
x=a
while True:
out.add(x)
if x==b: break
x=(x+1)%7
else:
x=dm.get(p[:3])
if x is None:return None
out.add(x)
return out
warn=[]; unknown=[]
for j in json.loads(os.environ["BACKUP_JSON"]):
if str(j.get("enabled","1")).lower() in ("0","false","no"): continue
sc=str(j.get("schedule","")).strip()
m=re.fullmatch(r"(?:(?P<d>[A-Za-z.,]+(?:\.\.[A-Za-z]+)?)\s+)?(?P<h>\d{1,2}):(?P<m>\d{2})",sc)
if not m:
unknown.append(sc); continue
ds=days(m.group("d") or "")
if ds is None:
unknown.append(sc); continue
bh,bm=int(m.group("h")),int(m.group("m"))
d=now.replace(hour=0,minute=0)
bos=[]
while d<=end:
if d.weekday() in ds:
x=d.replace(hour=bh,minute=bm)
if x>=now: bos.append(x)
d+=timedelta(days=1)
hit=None
for u in ups:
for b in bos:
delta=(u-b).total_seconds()/60
if abs(delta)<=120:
hit=delta; break
if b>u+timedelta(hours=2): break
if hit is not None: break
if hit is not None:
if abs(hit)<1: rel="gleiche Startzeit"
elif hit>0: rel=f"Updater {int(hit)} Min. nach Backup-Start"
else: rel=f"Updater {int(abs(hit))} Min. vor Backup-Start"
warn.append(f"{sc} ({rel})")
if warn:
print("WARN|"+ "\n".join(warn))
elif unknown:
print("UNKNOWN|Nicht automatisch auswertbar: " + ", ".join(unknown))
else:
print("OK|Keine Backup-Startzeit innerhalb +/-2 Stunden.")
PY
}
choose_time() {
local x
while true; do
x="$(wt_input "Zeitplan" "Uhrzeit (HH:MM)" "$SCHEDULE_TIME")" || return 1
[[ "$x" =~ ^([01][0-9]|2[0-3]):[0-5][0-9]$ ]] && { SCHEDULE_TIME="$x"; return; }
wt_msg "Fehler" "Bitte eine gueltige Uhrzeit eingeben, z. B. 04:00."
done
}
choose_weekday() {
local x
x="$(wt_menu "Zeitplan" "Wochentag" \
Mon Montag Tue Dienstag Wed Mittwoch Thu Donnerstag Fri Freitag Sat Samstag Sun Sonntag BACK "Zurueck")" || return 1
[[ "$x" == BACK ]] && return 1
SCHEDULE_WEEKDAY="$x"
}
choose_monthday() {
local x
while true; do
x="$(wt_input "Zeitplan" "Tag des Monats (1-28). 1-28 ist in jedem Monat gueltig." "$SCHEDULE_MONTHDAY")" || return 1
[[ "$x" =~ ^([1-9]|1[0-9]|2[0-8])$ ]] && { SCHEDULE_MONTHDAY="$x"; return; }
wt_msg "Fehler" "Bitte 1 bis 28 eingeben."
done
}
choose_month() {
local x
x="$(wt_menu "Zeitplan" "Monat auswaehlen" \
1 Januar 2 Februar 3 Maerz 4 April 5 Mai 6 Juni \
7 Juli 8 August 9 September 10 Oktober 11 November 12 Dezember BACK "Zurueck")" || return 1
[[ "$x" == BACK ]] && return 1
MONTH_RESULT="$x"
}
review_schedule() {
local b c status detail text choice
build_calendar
b="$(backup_jobs)"
c="$(backup_conflicts)"
status="${c%%|*}"; detail="${c#*|}"
text="Gewaehlter Zeitplan:
$(schedule_desc)
systemd:
$ONCALENDAR
Vorhandene Proxmox-Autobackups:
$b
Pruefung:
$detail
Empfehlung:
Mindestens 2 Stunden Abstand zum Backup-Start; besser 3 Stunden oder mehr.
Die echte Backup-Dauer ist aus dem Zeitplan nicht bekannt.
Der Updater wartet zur Laufzeit zusaetzlich auf ein laufendes vzdump-Backup.
Backups innerhalb eines Gasts koennen nicht allgemein erkannt werden."
if [[ "$status" == WARN ]]; then
choice="$(wt_menu "WARNUNG - Backup-Konflikt" "$text" \
CHANGE "Zeitplan aendern (empfohlen)" \
KEEP "Trotzdem uebernehmen" \
BACK "Zurueck")" || return 1
case "$choice" in
CHANGE) return 2 ;;
KEEP)
wt_yesno "WARNUNG" "Backup-Konflikt wurde erkannt.
Diesen Zeitplan trotzdem wirklich uebernehmen?" no || return 2
return 0 ;;
BACK) return 1 ;;
esac
else
choice="$(wt_menu "Zeitplan pruefen" "$text" \
SAVE "Zeitplan uebernehmen" \
CHANGE "Zeitplan aendern" \
BACK "Zurueck")" || return 1
case "$choice" in SAVE) return 0;; CHANGE) return 2;; *) return 1;; esac
fi
}
schedule_menu() {
local choice x rc
while true; do
choice="$(wt_menu "Automatischer Zeitplan" \
"Wie oft soll der Updater laufen?
Aktuell: $(schedule_desc)
Proxmox-Autobackups:
$(backup_jobs)" \
daily "Taeglich" \
weekly "Woechentlich (empfohlen)" \
monthly "Monatlich" \
interval "Alle X Monate" \
yearly "Jaehrlich" \
custom "Eigener systemd-Zeitplan" \
BACK "Zurueck")" || return
[[ "$choice" == BACK ]] && return
SCHEDULE_TYPE="$choice"
case "$choice" in
daily) choose_time || continue ;;
weekly) choose_weekday || continue; choose_time || continue ;;
monthly) choose_monthday || continue; choose_time || continue ;;
interval)
while true; do
x="$(wt_input "Zeitplan" "Alle wie viele Monate? (2-12)" "$SCHEDULE_INTERVAL_MONTHS")" || break
[[ "$x" =~ ^([2-9]|1[0-2])$ ]] && { SCHEDULE_INTERVAL_MONTHS="$x"; break; }
wt_msg "Fehler" "Bitte 2 bis 12 eingeben."
done
choose_month || continue; SCHEDULE_START_MONTH="$MONTH_RESULT"
choose_monthday || continue; choose_time || continue
;;
yearly)
choose_month || continue; SCHEDULE_YEAR_MONTH="$MONTH_RESULT"
choose_monthday || continue; SCHEDULE_YEAR_DAY="$SCHEDULE_MONTHDAY"
choose_time || continue
;;
custom)
x="$(wt_input "Zeitplan" "systemd OnCalendar-Ausdruck" "$ONCALENDAR")" || continue
if command -v systemd-analyze >/dev/null 2>&1 && ! systemd-analyze calendar "$x" >/dev/null 2>&1; then
wt_msg "Fehler" "Dieser systemd-Zeitplan ist ungueltig."
continue
fi
ONCALENDAR="$x"
;;
esac
set +e
review_schedule
rc=$?
set -e
case "$rc" in
0) return ;;
1) return ;;
2) continue ;;
esac
done
}
exclusions_menu() {
local -a args=()
local id name status selected
while read -r id name status _; do
[[ "$id" == VMID ]] && continue
[[ -z "$id" ]] && continue
selected=OFF
[[ " $EXCLUDE_GUESTS " == *" $id "* ]] && selected=ON
args+=("$id" "LXC $name [$status]" "$selected")
done < <(pct list 2>/dev/null || true)
while read -r id name status _; do
[[ "$id" == VMID ]] && continue
[[ -z "$id" ]] && continue
selected=OFF
[[ " $EXCLUDE_GUESTS " == *" $id "* ]] && selected=ON
args+=("$id" "VM $name [$status]" "$selected")
done < <(qm list 2>/dev/null || true)
if (( ${#args[@]} == 0 )); then
wt_msg "Ausschluesse" "Keine Gaeste gefunden."
return
fi
local result
result="$(whiptail --title "Ausschluesse" \
--checklist "Leertaste = markieren/entfernen
Enter = uebernehmen
Esc = zurueck
Markierte Gaeste werden NICHT automatisch aktualisiert." \
24 90 15 "${args[@]}" 3>&1 1>&2 2>&3 </dev/tty)" || return
result="${result//\"/}"
EXCLUDE_GUESTS="$result"
}
notifications_menu() {
local choice json
choice="$(wt_menu "Benachrichtigungen" "Proxmox-Benachrichtigung nach jedem Lauf" \
yes "Aktivieren" no "Deaktivieren" BACK "Zurueck")" || return
[[ "$choice" == BACK ]] && return
NOTIFY_ENABLED="$choice"
[[ "$choice" == no ]] && { NOTIFY_TARGET=""; return; }
json="$(pvesh get /cluster/notifications/targets --output-format json 2>/dev/null || true)"
local -a args=()
if [[ -n "$json" ]]; then
while IFS= read -r choice; do
[[ -n "$choice" ]] && args+=("$choice" "Notification-Target")
done < <(TARGETS="$json" python3 - <<'PY'
import json,os
try:
for x in json.loads(os.environ["TARGETS"]):
if x.get("name"): print(x["name"])
except: pass
PY
)
fi
(( ${#args[@]} > 0 )) || { NOTIFY_ENABLED="no"; wt_msg "Benachrichtigungen" "Keine Notification-Targets gefunden."; return; }
args+=(BACK "Zurueck")
choice="$(wt_menu "Benachrichtigungen" "Target auswaehlen" "${args[@]}")" || return
[[ "$choice" == BACK ]] && return
NOTIFY_TARGET="$choice"
}
advanced_menu() {
local x
x="$(wt_input "Erweitert" "APT-Lock-Wartezeit in Sekunden" "$APT_LOCK_TIMEOUT")" || return
[[ "$x" =~ ^[0-9]+$ ]] && APT_LOCK_TIMEOUT="$x"
x="$(wt_input "Erweitert" "Maximale Wartezeit auf laufendes Proxmox-Backup in Sekunden" "$BACKUP_WAIT_TIMEOUT")" || return
[[ "$x" =~ ^[0-9]+$ ]] && BACKUP_WAIT_TIMEOUT="$x"
x="$(wt_input "Erweitert" "Pruefintervall fuer laufendes Backup in Sekunden" "$BACKUP_WAIT_INTERVAL")" || return
[[ "$x" =~ ^[0-9]+$ ]] && BACKUP_WAIT_INTERVAL="$x"
}
write_units() {
build_calendar
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
}
download_updater() {
local tmp
tmp="$(mktemp)"
if ! curl -fsSL "$RAW/updater.sh" -o "$tmp"; then
rm -f "$tmp"; wt_msg "Fehler" "updater.sh konnte nicht geladen werden."; return 1
fi
if ! bash -n "$tmp"; then
rm -f "$tmp"; wt_msg "Fehler" "Die geladene updater.sh hat einen Syntaxfehler."; return 1
fi
install -m 0750 "$tmp" "$UPDATER"
rm -f "$tmp"
}
save_install() {
local c status detail
build_calendar
c="$(backup_conflicts)"; status="${c%%|*}"; detail="${c#*|}"
local summary="Host aktualisieren: $(yn "$UPDATE_HOST")
LXC aktualisieren: $(yn "$UPDATE_LXC")
Linux-VMs aktualisieren: $(yn "$UPDATE_VMS")
Gestoppte Gaeste starten: $(yn "$UPDATE_STOPPED")
Host automatisch neu starten: $(yn "$AUTO_REBOOT_HOST")
Benachrichtigungen: $(yn "$NOTIFY_ENABLED") ${NOTIFY_TARGET:+($NOTIFY_TARGET)}
Ausschluesse: ${EXCLUDE_GUESTS:-keine}
Zeitplan: $(schedule_desc)
Autobackup-Pruefung:
$detail"
if [[ "$status" == WARN ]]; then
wt_yesno "WARNUNG - Backup-Konflikt" "$summary
Trotzdem speichern?" no || return
else
wt_yesno "Speichern & anwenden" "$summary
Einstellungen jetzt anwenden?" yes || return
fi
download_updater || return
write_config
write_units
INSTALLED="yes"
wt_msg "Fertig" "Proxmox Guest Updater wurde gespeichert und aktiviert.
Es wurde KEIN Update-Lauf gestartet.
Zeitplan:
$(schedule_desc)
Naechster Lauf:
$(systemctl list-timers pve-guest-update.timer --no-pager 2>/dev/null | tail -n +2 | head -n2)"
}
settings_menu() {
local choice
while true; do
choice="$(wt_menu "Einstellungen" "Aktuelle Konfiguration
Aenderungen werden erst mit 'Speichern & anwenden' geschrieben." \
"1" "Host aktualisieren: $(yn "$UPDATE_HOST")" \
"2" "LXC aktualisieren: $(yn "$UPDATE_LXC")" \
"3" "Linux-VMs aktualisieren: $(yn "$UPDATE_VMS")" \
"4" "Gestoppte Gaeste starten: $(yn "$UPDATE_STOPPED")" \
"5" "Host automatisch neu starten: $(yn "$AUTO_REBOOT_HOST")" \
"6" "Benachrichtigungen: $(yn "$NOTIFY_ENABLED") ${NOTIFY_TARGET:+($NOTIFY_TARGET)}" \
"7" "Gast-Ausschluesse: ${EXCLUDE_GUESTS:-keine}" \
"8" "Automatischer Zeitplan: $(schedule_desc)" \
"9" "Erweiterte Wartezeiten" \
"10" "Speichern & anwenden" \
"11" "Zurueck")" || return
case "$choice" in
1) UPDATE_HOST="$(toggle "$UPDATE_HOST")" ;;
2) UPDATE_LXC="$(toggle "$UPDATE_LXC")" ;;
3) UPDATE_VMS="$(toggle "$UPDATE_VMS")" ;;
4) UPDATE_STOPPED="$(toggle "$UPDATE_STOPPED")" ;;
5) AUTO_REBOOT_HOST="$(toggle "$AUTO_REBOOT_HOST")" ;;
6) notifications_menu ;;
7) exclusions_menu ;;
8) schedule_menu ;;
9) advanced_menu ;;
10) save_install; load_config ;;
11) return ;;
esac
done
}
show_status() {
wt_msg "Status" "Installation: $INSTALLED
Host: $(hostname)
Proxmox: $(pveversion | head -n1)
Zeitplan:
$(schedule_desc)
Ausschluesse:
${EXCLUDE_GUESTS:-keine}
Autobackups:
$(backup_jobs)
Timer:
$(systemctl list-timers pve-guest-update.timer --no-pager 2>/dev/null | tail -n +2 | head -n3)
Letzte Logzeilen:
$(tail -n 8 "$LOGFILE" 2>/dev/null || echo 'Noch kein Log vorhanden.')"
}
uninstall_all() {
wt_yesno "Deinstallieren" "Proxmox Guest Updater wirklich entfernen?
Entfernt werden:
- Updater
- Konfiguration
- systemd Service
- systemd Timer
Das Log bleibt zunaechst erhalten." no || 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 "$UPDATER" "$CONFIG" "$SERVICE" "$TIMER"
systemctl daemon-reload
INSTALLED="no"
if wt_yesno "Log" "Auch $LOGFILE loeschen?" no; then
rm -f "$LOGFILE"
fi
wt_msg "Deinstalliert" "Proxmox Guest Updater wurde entfernt."
}
run_check() {
[[ -x "$UPDATER" ]] || { wt_msg "Fehler" "Updater ist nicht installiert."; return; }
clear
echo "Proxmox Guest Updater - Check"
echo
"$UPDATER" --check </dev/tty || true
echo
read -r -p "Enter fuer Hauptmenue ..." _ </dev/tty
}
run_now() {
[[ -x "$UPDATER" ]] || { wt_msg "Fehler" "Updater ist nicht installiert."; return; }
wt_yesno "Update jetzt" "Vollstaendigen Update-Lauf jetzt starten?" no || return
clear
"$UPDATER" </dev/tty || true
echo
read -r -p "Enter fuer Hauptmenue ..." _ </dev/tty
}
main_menu() {
local choice info
while true; do
load_config
if [[ "$INSTALLED" == yes ]]; then
info="$(dashboard_text)
------------------------------------------------------------
HAUPTMENUE
------------------------------------------------------------
Einstellungen Optionen, Zeitplan, Ausschluesse und Benachrichtigungen
Updater aktualisieren Neue updater.sh aus Gitea laden
Update-Check Verfuegbare Updates pruefen, nichts installieren
Update starten Host, LXC und Linux-VMs jetzt aktualisieren
Status / Log Konfiguration, Zeitplan und letzte Meldungen
Deinstallieren Updater vollstaendig entfernen
Beenden Manager schliessen
Hinweis:
Automatische Updates laufen nur nach dem eingestellten Zeitplan.
Ein manueller Check installiert nichts.
Laufende Proxmox-Backups werden vom Updater beruecksichtigt."
choice="$(wt_menu "Proxmox Guest Updater" "$info" \
"1" "Einstellungen" \
"2" "Updater aus Gitea aktualisieren" \
"3" "Update-Check starten" \
"4" "Update jetzt starten" \
"5" "Status / Zeitplan / Log" \
"6" "Deinstallieren" \
"7" "Beenden")" || exit 0
case "$choice" in
1) settings_menu ;;
2) download_updater && wt_msg "Fertig" "updater.sh wurde erfolgreich aus Gitea aktualisiert." ;;
3) run_check ;;
4) run_now ;;
5) show_status ;;
6) uninstall_all ;;
7) exit 0 ;;
esac
else
info="$(dashboard_text)
------------------------------------------------------------
ERSTEINRICHTUNG
------------------------------------------------------------
Empfehlung:
- Proxmox-Host aktualisieren
- laufende LXC aktualisieren
- laufende Linux-VMs aktualisieren
- gestoppte Gaeste nicht automatisch starten
- woechentlicher Lauf ausserhalb der Backup-Zeiten
- Backup-Schutz aktiv
Vorhandene Proxmox-Autobackups:
$(backup_jobs)"
choice="$(wt_menu "Proxmox Guest Updater - Einrichtung" "$info" \
"1" "Installieren / Einrichten" \
"2" "Proxmox-Autobackups anzeigen" \
"3" "Beenden")" || exit 0
case "$choice" in
1) settings_menu ;;
2) wt_msg "Proxmox-Autobackups" "$(backup_jobs)" ;;
3) exit 0 ;;
esac
fi
done
}
need_base
load_config
main_menu