1062 lines
37 KiB
Bash
1062 lines
37 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" --ok-button "OK" --cancel-button "Abbrechen" \
|
|
--menu "$text" 28 105 12 "$@" 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" --yes-button "Ja" --no-button "Nein" \
|
|
--yesno "$text" 14 86 </dev/tty
|
|
}
|
|
wt_input() {
|
|
local title="$1" text="$2" value="${3:-}"
|
|
whiptail --title "$title" --ok-button "Uebernehmen" --cancel-button "Zurueck" \
|
|
--inputbox "$text" 14 86 "$value" 3>&1 1>&2 2>&3 </dev/tty
|
|
}
|
|
wt_msg() {
|
|
whiptail --title "$1" --ok-button "OK" --msgbox "$2" 24 100 </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
|
|
SYSTEM
|
|
Host: $(hostname)
|
|
Proxmox: $(pveversion | head -n1)
|
|
Kernel: $(uname -r)
|
|
Status: $([[ "$INSTALLED" == yes ]] && echo "Installiert" || echo "Nicht installiert")
|
|
|
|
AUTOMATIK
|
|
Zeitplan: $(schedule_desc)
|
|
Naechster Lauf: $(timer_next_run)
|
|
Letzter Lauf: $(last_run_text)
|
|
Proxmox-Backups: $(backup_short)
|
|
Konflikt: $(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 result rc day month interval weekday
|
|
local -a vals=()
|
|
|
|
while true; do
|
|
choice="$(wt_menu "Zeitplan einstellen" \
|
|
"AKTUELL
|
|
$(schedule_desc)
|
|
|
|
PROXMOX-AUTOBACKUPS
|
|
$(backup_jobs)
|
|
|
|
EMPFEHLUNG
|
|
Woechentlich ist fuer normale Systeme sinnvoll.
|
|
Moeglichst mindestens 3 Stunden Abstand zu Backup-Starts halten.
|
|
|
|
Gewuenschten Zeitplan auswaehlen:" \
|
|
"1" "Taeglich" \
|
|
"2" "Woechentlich (empfohlen)" \
|
|
"3" "Monatlich" \
|
|
"4" "Alle X Monate" \
|
|
"5" "Jaehrlich" \
|
|
"6" "Eigener systemd-Zeitplan" \
|
|
"7" "Zurueck")" || return
|
|
|
|
case "$choice" in
|
|
1)
|
|
result="$(whiptail --title "Taeglicher Zeitplan" \
|
|
--ok-button "Weiter" --cancel-button "Zurueck" \
|
|
--inputbox "Taeglicher Lauf
|
|
|
|
Uhrzeit im Format HH:MM eingeben.
|
|
|
|
Beispiel: 04:00" \
|
|
14 72 "$SCHEDULE_TIME" 3>&1 1>&2 2>&3 </dev/tty)" || continue
|
|
[[ "$result" =~ ^([01][0-9]|2[0-3]):[0-5][0-9]$ ]] || {
|
|
wt_msg "Fehler" "Ungueltige Uhrzeit.
|
|
|
|
Beispiel: 04:00"; continue; }
|
|
SCHEDULE_TYPE=daily
|
|
SCHEDULE_TIME="$result"
|
|
;;
|
|
|
|
2)
|
|
weekday="$(whiptail --title "Woechentlicher Zeitplan" \
|
|
--ok-button "Weiter" --cancel-button "Zurueck" \
|
|
--radiolist "Wochentag auswaehlen:" 20 72 8 \
|
|
Mon "Montag" "$([[ "$SCHEDULE_WEEKDAY" == Mon ]] && echo ON || echo OFF)" \
|
|
Tue "Dienstag" "$([[ "$SCHEDULE_WEEKDAY" == Tue ]] && echo ON || echo OFF)" \
|
|
Wed "Mittwoch" "$([[ "$SCHEDULE_WEEKDAY" == Wed ]] && echo ON || echo OFF)" \
|
|
Thu "Donnerstag" "$([[ "$SCHEDULE_WEEKDAY" == Thu ]] && echo ON || echo OFF)" \
|
|
Fri "Freitag" "$([[ "$SCHEDULE_WEEKDAY" == Fri ]] && echo ON || echo OFF)" \
|
|
Sat "Samstag" "$([[ "$SCHEDULE_WEEKDAY" == Sat ]] && echo ON || echo OFF)" \
|
|
Sun "Sonntag" "$([[ "$SCHEDULE_WEEKDAY" == Sun ]] && echo ON || echo OFF)" \
|
|
3>&1 1>&2 2>&3 </dev/tty)" || continue
|
|
|
|
result="$(whiptail --title "Woechentlicher Zeitplan" \
|
|
--ok-button "Weiter" --cancel-button "Zurueck" \
|
|
--inputbox "$(weekday_de "$weekday")
|
|
|
|
Uhrzeit im Format HH:MM:" 12 68 "$SCHEDULE_TIME" \
|
|
3>&1 1>&2 2>&3 </dev/tty)" || continue
|
|
[[ "$result" =~ ^([01][0-9]|2[0-3]):[0-5][0-9]$ ]] || {
|
|
wt_msg "Fehler" "Ungueltige Uhrzeit.
|
|
|
|
Beispiel: 04:00"; continue; }
|
|
SCHEDULE_TYPE=weekly
|
|
SCHEDULE_WEEKDAY="$weekday"
|
|
SCHEDULE_TIME="$result"
|
|
;;
|
|
|
|
3)
|
|
result="$(whiptail --title "Monatlicher Zeitplan" \
|
|
--ok-button "Weiter" --cancel-button "Zurueck" \
|
|
--form "Monatlicher Lauf
|
|
|
|
Tag 1 bis 28 und Uhrzeit angeben." 16 74 5 \
|
|
"Tag des Monats:" 1 1 "$SCHEDULE_MONTHDAY" 1 34 4 0 \
|
|
"Uhrzeit:" 3 1 "$SCHEDULE_TIME" 3 34 8 0 \
|
|
3>&1 1>&2 2>&3 </dev/tty)" || continue
|
|
mapfile -t vals <<<"$result"
|
|
day="${vals[0]:-}"; result="${vals[1]:-}"
|
|
[[ "$day" =~ ^([1-9]|1[0-9]|2[0-8])$ ]] || { wt_msg "Fehler" "Tag muss zwischen 1 und 28 liegen."; continue; }
|
|
[[ "$result" =~ ^([01][0-9]|2[0-3]):[0-5][0-9]$ ]] || { wt_msg "Fehler" "Ungueltige Uhrzeit. Beispiel: 04:00"; continue; }
|
|
SCHEDULE_TYPE=monthly
|
|
SCHEDULE_MONTHDAY="$day"
|
|
SCHEDULE_TIME="$result"
|
|
;;
|
|
|
|
4)
|
|
interval="$(whiptail --title "Alle X Monate" \
|
|
--ok-button "Weiter" --cancel-button "Zurueck" \
|
|
--radiolist "Intervall auswaehlen:" 22 74 10 \
|
|
2 "Alle 2 Monate" "$([[ "$SCHEDULE_INTERVAL_MONTHS" == 2 ]] && echo ON || echo OFF)" \
|
|
3 "Alle 3 Monate" "$([[ "$SCHEDULE_INTERVAL_MONTHS" == 3 ]] && echo ON || echo OFF)" \
|
|
4 "Alle 4 Monate" "$([[ "$SCHEDULE_INTERVAL_MONTHS" == 4 ]] && echo ON || echo OFF)" \
|
|
6 "Alle 6 Monate" "$([[ "$SCHEDULE_INTERVAL_MONTHS" == 6 ]] && echo ON || echo OFF)" \
|
|
12 "Alle 12 Monate" "$([[ "$SCHEDULE_INTERVAL_MONTHS" == 12 ]] && echo ON || echo OFF)" \
|
|
3>&1 1>&2 2>&3 </dev/tty)" || continue
|
|
|
|
month="$(whiptail --title "Alle $interval Monate" \
|
|
--ok-button "Weiter" --cancel-button "Zurueck" \
|
|
--radiolist "Startmonat auswaehlen:" 24 74 12 \
|
|
1 Januar "$([[ "$SCHEDULE_START_MONTH" == 1 ]] && echo ON || echo OFF)" \
|
|
2 Februar "$([[ "$SCHEDULE_START_MONTH" == 2 ]] && echo ON || echo OFF)" \
|
|
3 Maerz "$([[ "$SCHEDULE_START_MONTH" == 3 ]] && echo ON || echo OFF)" \
|
|
4 April "$([[ "$SCHEDULE_START_MONTH" == 4 ]] && echo ON || echo OFF)" \
|
|
5 Mai "$([[ "$SCHEDULE_START_MONTH" == 5 ]] && echo ON || echo OFF)" \
|
|
6 Juni "$([[ "$SCHEDULE_START_MONTH" == 6 ]] && echo ON || echo OFF)" \
|
|
7 Juli "$([[ "$SCHEDULE_START_MONTH" == 7 ]] && echo ON || echo OFF)" \
|
|
8 August "$([[ "$SCHEDULE_START_MONTH" == 8 ]] && echo ON || echo OFF)" \
|
|
9 September "$([[ "$SCHEDULE_START_MONTH" == 9 ]] && echo ON || echo OFF)" \
|
|
10 Oktober "$([[ "$SCHEDULE_START_MONTH" == 10 ]] && echo ON || echo OFF)" \
|
|
11 November "$([[ "$SCHEDULE_START_MONTH" == 11 ]] && echo ON || echo OFF)" \
|
|
12 Dezember "$([[ "$SCHEDULE_START_MONTH" == 12 ]] && echo ON || echo OFF)" \
|
|
3>&1 1>&2 2>&3 </dev/tty)" || continue
|
|
|
|
result="$(whiptail --title "Alle $interval Monate" \
|
|
--ok-button "Weiter" --cancel-button "Zurueck" \
|
|
--form "Start: $(month_de "$month")
|
|
|
|
Tag 1 bis 28 und Uhrzeit angeben." 16 74 5 \
|
|
"Tag des Monats:" 1 1 "$SCHEDULE_MONTHDAY" 1 34 4 0 \
|
|
"Uhrzeit:" 3 1 "$SCHEDULE_TIME" 3 34 8 0 \
|
|
3>&1 1>&2 2>&3 </dev/tty)" || continue
|
|
mapfile -t vals <<<"$result"
|
|
day="${vals[0]:-}"; result="${vals[1]:-}"
|
|
[[ "$day" =~ ^([1-9]|1[0-9]|2[0-8])$ ]] || { wt_msg "Fehler" "Tag muss zwischen 1 und 28 liegen."; continue; }
|
|
[[ "$result" =~ ^([01][0-9]|2[0-3]):[0-5][0-9]$ ]] || { wt_msg "Fehler" "Ungueltige Uhrzeit. Beispiel: 04:00"; continue; }
|
|
SCHEDULE_TYPE=interval
|
|
SCHEDULE_INTERVAL_MONTHS="$interval"
|
|
SCHEDULE_START_MONTH="$month"
|
|
SCHEDULE_MONTHDAY="$day"
|
|
SCHEDULE_TIME="$result"
|
|
;;
|
|
|
|
5)
|
|
month="$(whiptail --title "Jaehrlicher Zeitplan" \
|
|
--ok-button "Weiter" --cancel-button "Zurueck" \
|
|
--radiolist "Monat auswaehlen:" 24 74 12 \
|
|
1 Januar "$([[ "$SCHEDULE_YEAR_MONTH" == 1 ]] && echo ON || echo OFF)" \
|
|
2 Februar "$([[ "$SCHEDULE_YEAR_MONTH" == 2 ]] && echo ON || echo OFF)" \
|
|
3 Maerz "$([[ "$SCHEDULE_YEAR_MONTH" == 3 ]] && echo ON || echo OFF)" \
|
|
4 April "$([[ "$SCHEDULE_YEAR_MONTH" == 4 ]] && echo ON || echo OFF)" \
|
|
5 Mai "$([[ "$SCHEDULE_YEAR_MONTH" == 5 ]] && echo ON || echo OFF)" \
|
|
6 Juni "$([[ "$SCHEDULE_YEAR_MONTH" == 6 ]] && echo ON || echo OFF)" \
|
|
7 Juli "$([[ "$SCHEDULE_YEAR_MONTH" == 7 ]] && echo ON || echo OFF)" \
|
|
8 August "$([[ "$SCHEDULE_YEAR_MONTH" == 8 ]] && echo ON || echo OFF)" \
|
|
9 September "$([[ "$SCHEDULE_YEAR_MONTH" == 9 ]] && echo ON || echo OFF)" \
|
|
10 Oktober "$([[ "$SCHEDULE_YEAR_MONTH" == 10 ]] && echo ON || echo OFF)" \
|
|
11 November "$([[ "$SCHEDULE_YEAR_MONTH" == 11 ]] && echo ON || echo OFF)" \
|
|
12 Dezember "$([[ "$SCHEDULE_YEAR_MONTH" == 12 ]] && echo ON || echo OFF)" \
|
|
3>&1 1>&2 2>&3 </dev/tty)" || continue
|
|
|
|
result="$(whiptail --title "Jaehrlicher Zeitplan" \
|
|
--ok-button "Weiter" --cancel-button "Zurueck" \
|
|
--form "$(month_de "$month")
|
|
|
|
Tag 1 bis 28 und Uhrzeit angeben." 16 74 5 \
|
|
"Tag:" 1 1 "$SCHEDULE_YEAR_DAY" 1 34 4 0 \
|
|
"Uhrzeit:" 3 1 "$SCHEDULE_TIME" 3 34 8 0 \
|
|
3>&1 1>&2 2>&3 </dev/tty)" || continue
|
|
mapfile -t vals <<<"$result"
|
|
day="${vals[0]:-}"; result="${vals[1]:-}"
|
|
[[ "$day" =~ ^([1-9]|1[0-9]|2[0-8])$ ]] || { wt_msg "Fehler" "Tag muss zwischen 1 und 28 liegen."; continue; }
|
|
[[ "$result" =~ ^([01][0-9]|2[0-3]):[0-5][0-9]$ ]] || { wt_msg "Fehler" "Ungueltige Uhrzeit. Beispiel: 04:00"; continue; }
|
|
SCHEDULE_TYPE=yearly
|
|
SCHEDULE_YEAR_MONTH="$month"
|
|
SCHEDULE_YEAR_DAY="$day"
|
|
SCHEDULE_TIME="$result"
|
|
;;
|
|
|
|
6)
|
|
result="$(wt_input "Eigener systemd-Zeitplan" \
|
|
"Nur fuer erfahrene Benutzer.
|
|
|
|
Beispiel:
|
|
Sun *-*-* 04:00:00
|
|
|
|
OnCalendar-Ausdruck:" "$ONCALENDAR")" || continue
|
|
if ! systemd-analyze calendar "$result" >/dev/null 2>&1; then
|
|
wt_msg "Fehler" "systemd akzeptiert diesen Zeitplan nicht."
|
|
continue
|
|
fi
|
|
SCHEDULE_TYPE=custom
|
|
ONCALENDAR="$result"
|
|
;;
|
|
|
|
7) return ;;
|
|
esac
|
|
|
|
build_calendar
|
|
if ! systemd-analyze calendar "$ONCALENDAR" >/dev/null 2>&1; then
|
|
wt_msg "Fehler" "Der erzeugte systemd-Zeitplan ist ungueltig:
|
|
|
|
$ONCALENDAR"
|
|
continue
|
|
fi
|
|
|
|
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 json result name state
|
|
local -a args=()
|
|
|
|
args+=("OFF" "Benachrichtigungen deaktivieren" "$([[ "$NOTIFY_ENABLED" == no ]] && echo ON || echo OFF)")
|
|
|
|
json="$(pvesh get /cluster/notifications/targets --output-format json 2>/dev/null || true)"
|
|
if [[ -n "$json" ]]; then
|
|
while IFS= read -r name; do
|
|
[[ -z "$name" ]] && continue
|
|
state=OFF
|
|
[[ "$NOTIFY_ENABLED" == yes && "$NOTIFY_TARGET" == "$name" ]] && state=ON
|
|
args+=("$name" "Proxmox Notification Target" "$state")
|
|
done < <(TARGETS="$json" python3 - <<'PY'
|
|
import json, os
|
|
try:
|
|
for x in json.loads(os.environ["TARGETS"]):
|
|
n=x.get("name")
|
|
if n: print(n)
|
|
except Exception:
|
|
pass
|
|
PY
|
|
)
|
|
fi
|
|
|
|
result="$(whiptail --title "Benachrichtigungen" \
|
|
--ok-button "Uebernehmen" --cancel-button "Zurueck" \
|
|
--radiolist "Eine Einstellung auswaehlen.
|
|
|
|
Mit LEERTASTE markieren, danach Uebernehmen." \
|
|
20 88 10 "${args[@]}" 3>&1 1>&2 2>&3 </dev/tty)" || return
|
|
|
|
if [[ "$result" == OFF ]]; then
|
|
NOTIFY_ENABLED=no
|
|
NOTIFY_TARGET=""
|
|
else
|
|
NOTIFY_ENABLED=yes
|
|
NOTIFY_TARGET="$result"
|
|
fi
|
|
}
|
|
|
|
advanced_menu() {
|
|
local result a b c
|
|
result="$(whiptail --title "Erweiterte Wartezeiten" \
|
|
--ok-button "Uebernehmen" --cancel-button "Zurueck" \
|
|
--form "Normalerweise muessen diese Werte nicht geaendert werden.
|
|
|
|
Alle Angaben in Sekunden." \
|
|
20 92 8 \
|
|
"APT-Lock warten:" 1 1 "$APT_LOCK_TIMEOUT" 1 42 12 0 \
|
|
"Max. auf Backup warten:" 3 1 "$BACKUP_WAIT_TIMEOUT" 3 42 12 0 \
|
|
"Backup-Pruefintervall:" 5 1 "$BACKUP_WAIT_INTERVAL" 5 42 12 0 \
|
|
3>&1 1>&2 2>&3 </dev/tty)" || return
|
|
|
|
mapfile -t vals <<<"$result"
|
|
a="${vals[0]:-}"; b="${vals[1]:-}"; c="${vals[2]:-}"
|
|
if [[ ! "$a" =~ ^[0-9]+$ || ! "$b" =~ ^[0-9]+$ || ! "$c" =~ ^[0-9]+$ ]]; then
|
|
wt_msg "Ungueltige Eingabe" "Bitte nur ganze Zahlen in Sekunden eingeben."
|
|
return
|
|
fi
|
|
APT_LOCK_TIMEOUT="$a"
|
|
BACKUP_WAIT_TIMEOUT="$b"
|
|
BACKUP_WAIT_INTERVAL="$c"
|
|
}
|
|
|
|
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)"
|
|
}
|
|
|
|
basic_options_menu() {
|
|
local result item
|
|
local h=OFF l=OFF v=OFF st=OFF rb=OFF
|
|
[[ "$UPDATE_HOST" == yes ]] && h=ON
|
|
[[ "$UPDATE_LXC" == yes ]] && l=ON
|
|
[[ "$UPDATE_VMS" == yes ]] && v=ON
|
|
[[ "$UPDATE_STOPPED" == yes ]] && st=ON
|
|
[[ "$AUTO_REBOOT_HOST" == yes ]] && rb=ON
|
|
|
|
result="$(whiptail --title "Update-Optionen" \
|
|
--ok-button "Uebernehmen" --cancel-button "Zurueck" \
|
|
--checklist "Mit LEERTASTE Ja/Nein umschalten. Mehrere Einstellungen koennen geaendert werden, ohne dass das Fenster neu geladen wird.
|
|
|
|
Einstellung Ja/Nein" \
|
|
22 92 10 \
|
|
HOST "Proxmox-Host aktualisieren" "$h" \
|
|
LXC "LXC aktualisieren" "$l" \
|
|
VM "Linux-VMs aktualisieren" "$v" \
|
|
STOPPED "Gestoppte Gaeste temporaer starten" "$st" \
|
|
REBOOT "Host bei Bedarf automatisch neu starten" "$rb" \
|
|
3>&1 1>&2 2>&3 </dev/tty)" || return
|
|
|
|
UPDATE_HOST=no
|
|
UPDATE_LXC=no
|
|
UPDATE_VMS=no
|
|
UPDATE_STOPPED=no
|
|
AUTO_REBOOT_HOST=no
|
|
|
|
result="${result//\"/}"
|
|
for item in $result; do
|
|
case "$item" in
|
|
HOST) UPDATE_HOST=yes ;;
|
|
LXC) UPDATE_LXC=yes ;;
|
|
VM) UPDATE_VMS=yes ;;
|
|
STOPPED) UPDATE_STOPPED=yes ;;
|
|
REBOOT) AUTO_REBOOT_HOST=yes ;;
|
|
esac
|
|
done
|
|
}
|
|
|
|
settings_summary() {
|
|
printf '%-34s %s\n' \
|
|
"Proxmox-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")"
|
|
}
|
|
|
|
settings_menu() {
|
|
local choice
|
|
while true; do
|
|
choice="$(wt_menu "Einstellungen" \
|
|
"AKTUELLE KONFIGURATION
|
|
|
|
$(settings_summary)
|
|
|
|
Benachrichtigungen $(yn "$NOTIFY_ENABLED")${NOTIFY_TARGET:+ ($NOTIFY_TARGET)}
|
|
Gast-Ausschluesse ${EXCLUDE_GUESTS:-keine}
|
|
Automatischer Zeitplan $(schedule_desc)
|
|
|
|
------------------------------------------------------------
|
|
AUSWAHL
|
|
------------------------------------------------------------
|
|
Die Ja/Nein-Schalter werden gemeinsam bearbeitet.
|
|
Innerhalb einer Auswahl wird nicht bei jeder Aenderung neu geladen." \
|
|
"1" "Update-Optionen | alle Ja/Nein-Schalter gemeinsam" \
|
|
"2" "Benachrichtigungen | ein-/ausschalten und Target waehlen" \
|
|
"3" "Gast-Ausschluesse | LXC/VM per Leertaste markieren" \
|
|
"4" "Automatischer Zeitplan | Rhythmus und Uhrzeit festlegen" \
|
|
"5" "Erweiterte Wartezeiten | APT- und Backup-Schutz" \
|
|
"6" "Speichern & anwenden | Konfiguration aktivieren" \
|
|
"7" "Zurueck | ohne Speichern zurueck")" || return
|
|
|
|
case "$choice" in
|
|
1) basic_options_menu ;;
|
|
2) notifications_menu ;;
|
|
3) exclusions_menu ;;
|
|
4) schedule_menu ;;
|
|
5) advanced_menu ;;
|
|
6) save_install; load_config ;;
|
|
7) 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)
|
|
|
|
HINWEIS
|
|
- Ein Update wird nur automatisch nach dem eingestellten Zeitplan gestartet.
|
|
- 'Update-Check' prueft nur und installiert nichts.
|
|
- Laufende Proxmox-Backups werden vor Update und Neustart beruecksichtigt."
|
|
|
|
choice="$(wt_menu "Proxmox Guest Updater" "$info" \
|
|
"1" "Einstellungen | Optionen, Zeitplan, Ausschluesse, Benachrichtigungen" \
|
|
"2" "Updater aktualisieren | Neue updater.sh aus Gitea laden" \
|
|
"3" "Update-Check starten | Verfuegbare Updates anzeigen" \
|
|
"4" "Update jetzt starten | Host, LXC und Linux-VMs aktualisieren" \
|
|
"5" "Status / Zeitplan / Log | Konfiguration und letzte Meldungen anzeigen" \
|
|
"6" "Deinstallieren | Updater vollstaendig entfernen" \
|
|
"7" "Beenden | Manager schliessen")" || 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)
|
|
|
|
EMPFOHLENE ERSTEINRICHTUNG
|
|
- Host, laufende LXC und laufende Linux-VMs aktualisieren
|
|
- Gestoppte Gaeste nicht automatisch starten
|
|
- Woechentlicher Lauf ausserhalb der Backup-Zeiten
|
|
- Backup-Schutz aktiv
|
|
|
|
PROXMOX-AUTOBACKUPS
|
|
$(backup_jobs)"
|
|
|
|
choice="$(wt_menu "Proxmox Guest Updater - Einrichtung" "$info" \
|
|
"1" "Installieren / Einrichten | Einstellungen und Zeitplan festlegen" \
|
|
"2" "Autobackups anzeigen | Vorhandene Proxmox-Backupjobs anzeigen" \
|
|
"3" "Beenden | Manager schliessen")" || 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
|