1178 lines
41 KiB
Bash
1178 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
|
|
stty -echo -icanon min 1 time 0 </dev/tty || return 1
|
|
|
|
key="$(dd bs=1 count=1 </dev/tty 2>/dev/null || true)"
|
|
if [[ "$key" == $'\x1b' ]]; then
|
|
stty min 0 time 1 </dev/tty
|
|
rest="$(dd bs=1 count=2 </dev/tty 2>/dev/null || true)"
|
|
key+="$rest"
|
|
fi
|
|
|
|
stty "$old" </dev/tty
|
|
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
|
|
|
|
# Bei "curl ... | bash" ist stdin eine Pipe. Die interaktive Oberfläche
|
|
# wird deshalb einmal mit /dev/tty als stdin neu gestartet.
|
|
if [[ ! -t 0 && "${PVE_MANAGER_TTY_REEXEC:-0}" != "1" ]]; then
|
|
export PVE_MANAGER_TTY_REEXEC=1
|
|
tmp_manager="$(mktemp)"
|
|
cat > "$tmp_manager"
|
|
chmod 700 "$tmp_manager"
|
|
exec bash "$tmp_manager" </dev/tty
|
|
fi
|
|
|
|
# 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
|