first commit
This commit is contained in:
duffyduck
@@ -0,0 +1,268 @@
|
||||
# pvesnap — automatische Snapshots für Proxmox VE
|
||||
|
||||
Ein systemd-Dienst, der nach frei definierbaren Zeitplänen Snapshots von VMs und
|
||||
Containern anlegt und alte Snapshots nach einer einstellbaren Vorhaltezeit wieder
|
||||
löscht. Alles wird über **eine INI-Datei** gesteuert, die sich auch bequem in einem
|
||||
**ncurses-Editor** bearbeiten lässt.
|
||||
|
||||
* Beliebig viele **Gruppen** — z. B. „diese VMs stündlich, jene täglich, der Rest monatlich“
|
||||
* **VM-Auswahl** nach VMID, Name (mit `*`-Mustern), Tag, Pool oder einfach „alle“
|
||||
* **Vorhaltezeit** je Gruppe nach Anzahl *und/oder* Alter
|
||||
* Jeder Snapshot bekommt eine **Beschreibung**, an der er sich wiedererkennen lässt
|
||||
* Läuft cluster-weit (alle Nodes) über `pvesh`
|
||||
* Nur Python-Standardbibliothek — keine zusätzlichen Pakete nötig
|
||||
|
||||
---
|
||||
|
||||
## Installation
|
||||
|
||||
Auf dem Proxmox-Host als root:
|
||||
|
||||
```bash
|
||||
git clone <dieses-repo> pvesnap && cd pvesnap
|
||||
./install.sh
|
||||
```
|
||||
|
||||
Das Skript legt an:
|
||||
|
||||
| Pfad | Inhalt |
|
||||
|---|---|
|
||||
| `/usr/lib/pvesnap/` | Programmcode |
|
||||
| `/usr/local/bin/pvesnap` | Startbefehl |
|
||||
| `/etc/pvesnap/pvesnap.conf` | Konfiguration (wird bei Updates **nicht** überschrieben) |
|
||||
| `/var/lib/pvesnap/state.json` | merkt sich die letzten Läufe |
|
||||
| `/etc/systemd/system/pvesnap.service` | systemd-Unit |
|
||||
|
||||
In der mitgelieferten Beispielkonfiguration sind alle Gruppen auf `enabled = no`
|
||||
gesetzt — es passiert also erst etwas, wenn du eine Gruppe aktivierst.
|
||||
|
||||
**Deinstallation:**
|
||||
|
||||
```bash
|
||||
./uninstall.sh # Programm und Dienst entfernen, Konfiguration bleibt
|
||||
./uninstall.sh --purge # zusätzlich /etc/pvesnap und /var/lib/pvesnap löschen
|
||||
```
|
||||
|
||||
Bereits angelegte Snapshots werden dabei **nie** angerührt.
|
||||
|
||||
---
|
||||
|
||||
## Konfiguration im ncurses-Editor
|
||||
|
||||
```bash
|
||||
pvesnap config
|
||||
```
|
||||
|
||||
* **Gruppenliste** — `Enter` bearbeiten, `n` neu, `c` kopieren, `d` löschen,
|
||||
`Leertaste` an/aus, `g` globale Einstellungen, `v` Übersicht welche VM in
|
||||
welcher Gruppe landet, `s` speichern, `q` Ende
|
||||
* **Gruppe bearbeiten** — Feld auswählen, `Enter` ändern, `Leertaste` umschalten.
|
||||
Ganz unten steht live, auf wie viele Gäste die Auswahl gerade zutrifft.
|
||||
* **VM-Auswahl** (`v`) — Liste aller VMs und Container mit Node, Status und Tags;
|
||||
`Leertaste` auswählen, `a` alle, `n` keine, `i` umkehren, `/` filtern,
|
||||
`Enter` übernehmen.
|
||||
|
||||
> Beim Speichern wird die INI-Datei neu geschrieben. Eigene Kommentare und ein
|
||||
> `[defaults]`-Abschnitt gehen dabei verloren (die Werte bleiben inhaltlich
|
||||
> erhalten, sie stehen danach in jeder Gruppe einzeln). Eine Sicherung wird als
|
||||
> `pvesnap.conf.bak` abgelegt.
|
||||
|
||||
---
|
||||
|
||||
## Konfiguration von Hand
|
||||
|
||||
```ini
|
||||
[global]
|
||||
prefix = auto # Namenspräfix aller pvesnap-Snapshots
|
||||
check_interval = 60s # wie oft der Dienst nach Fälligem schaut
|
||||
state_file = /var/lib/pvesnap/state.json
|
||||
log_level = INFO
|
||||
task_timeout = 15m
|
||||
run_on_start = no # beim Start sofort einen Durchlauf machen?
|
||||
dry_run = no # yes = nichts wirklich tun, nur protokollieren
|
||||
description = pvesnap | Gruppe: {group} | erstellt: {datetime} | Vorhaltezeit: {keep_time}
|
||||
|
||||
[defaults] # Vorgaben für alle Gruppen (optional)
|
||||
skip_stopped = no
|
||||
|
||||
[group:stündlich]
|
||||
interval = 1h
|
||||
align = yes # an der Uhr ausrichten: 00:00, 01:00, ...
|
||||
keep_count = 24 # höchstens 24 Snapshots je VM
|
||||
keep_time = 2d # nichts älter als 2 Tage
|
||||
tags = stuendlich # alle VMs mit diesem Tag
|
||||
skip_stopped = yes
|
||||
|
||||
[group:täglich]
|
||||
schedule = daily
|
||||
at = 02:30
|
||||
keep_count = 14
|
||||
keep_time = 21d
|
||||
names = web-*, db-*
|
||||
|
||||
[group:monatlich]
|
||||
schedule = monthly
|
||||
day_of_month = 1
|
||||
at = 04:00
|
||||
keep_count = 6
|
||||
all = yes
|
||||
exclude_tags = nosnap
|
||||
```
|
||||
|
||||
Nach jeder Änderung:
|
||||
|
||||
```bash
|
||||
pvesnap check # Konfiguration prüfen
|
||||
systemctl reload pvesnap # Dienst übernimmt die Änderung ohne Neustart
|
||||
```
|
||||
|
||||
### Zeitplan
|
||||
|
||||
Entweder ein Intervall …
|
||||
|
||||
```ini
|
||||
interval = 30m # 30m, 1h, 6h, 2d12h, 1w ...
|
||||
align = yes # yes: an der Uhr ausgerichtet (00:00, 00:30, 01:00, ...)
|
||||
# no: 30 Minuten nach dem letzten Lauf
|
||||
```
|
||||
|
||||
… oder ein fester Termin:
|
||||
|
||||
| `schedule` | zusätzliche Angaben | Beispiel |
|
||||
|---|---|---|
|
||||
| `hourly` | `minute = 15` | jede Stunde um :15 |
|
||||
| `daily` | `at = 02:30` | täglich um 02:30 |
|
||||
| `weekly` | `at`, `day_of_week = so` | sonntags um 03:00 |
|
||||
| `monthly` | `at`, `day_of_month = 1` | am 1. jedes Monats |
|
||||
| `yearly` | `at`, `day_of_month`, `month` | einmal jährlich |
|
||||
|
||||
`day_of_month = 31` wird in kürzeren Monaten automatisch auf den letzten Tag
|
||||
gezogen. Läuft der Host zum Termin nicht, wird der Lauf beim nächsten Start
|
||||
nachgeholt.
|
||||
|
||||
### Vorhaltezeit
|
||||
|
||||
```ini
|
||||
keep_count = 24 # höchstens 24 Snapshots je VM und Gruppe (0 = unbegrenzt)
|
||||
keep_time = 7d # nichts älter als 7 Tage (0 = unbegrenzt)
|
||||
keep_min = 1 # so viele bleiben in jedem Fall stehen
|
||||
```
|
||||
|
||||
Beides ist kombinierbar — gelöscht wird, was *eine* der beiden Grenzen reißt.
|
||||
Mindestens eine der beiden Angaben muss gesetzt sein, sonst würde die Zahl der
|
||||
Snapshots unbegrenzt wachsen (`pvesnap check` weist darauf hin).
|
||||
|
||||
### Welche VMs?
|
||||
|
||||
Alle Angaben wirken als **ODER**, Ausschlüsse gewinnen immer:
|
||||
|
||||
```ini
|
||||
all = yes # alle VMs und Container
|
||||
vmids = 100,101,105-110 # nach ID, auch Bereiche
|
||||
names = web-*, db-0? # nach Name, mit Platzhaltern
|
||||
tags = prod, wichtig # nach Proxmox-Tag
|
||||
pools = Kunden # nach Proxmox-Pool
|
||||
types = qemu # nur VMs (bzw. lxc = nur Container; leer = beides)
|
||||
|
||||
exclude_vmids = 999
|
||||
exclude_names = *-test
|
||||
exclude_tags = nosnap
|
||||
```
|
||||
|
||||
### Snapshot-Optionen
|
||||
|
||||
```ini
|
||||
vmstate = yes # RAM mitsichern (nur QEMU und nur bei laufender VM)
|
||||
skip_stopped = yes # gestoppte Gäste überspringen
|
||||
description = Sicherung von {name} ({vmid}) vom {date}
|
||||
```
|
||||
|
||||
Platzhalter der Beschreibung: `{group}` `{group_slug}` `{vmid}` `{name}` `{node}`
|
||||
`{type}` `{pool}` `{tags}` `{date}` `{time}` `{datetime}` `{timestamp}`
|
||||
`{keep_time}` `{keep_count}` `{schedule}`
|
||||
|
||||
---
|
||||
|
||||
## Namensschema und Sicherheit
|
||||
|
||||
```
|
||||
auto-taeglich-20260730-023000
|
||||
│ │ │ └── Uhrzeit
|
||||
│ │ └────────── Datum
|
||||
│ └──────────────────── Kurzname der Gruppe
|
||||
└─────────────────────────── prefix aus [global]
|
||||
```
|
||||
|
||||
pvesnap löscht **ausschließlich** Snapshots, deren Name exakt auf dieses Muster
|
||||
passt und deren Gruppen-Kurzname zur jeweiligen Gruppe gehört. Von Hand oder von
|
||||
anderen Werkzeugen angelegte Snapshots bleiben garantiert unangetastet.
|
||||
|
||||
Umlaute und Sonderzeichen im Gruppennamen werden für den Kurznamen umgeschrieben
|
||||
(`täglich` → `taeglich`). Wenn zwei Gruppen denselben Kurznamen ergäben, meldet
|
||||
das `pvesnap check`.
|
||||
|
||||
---
|
||||
|
||||
## Befehle
|
||||
|
||||
```bash
|
||||
pvesnap status # Übersicht: Gruppen, letzte und nächste Läufe
|
||||
pvesnap vms # alle VMs und die Gruppen, in denen sie stecken
|
||||
pvesnap list # vorhandene pvesnap-Snapshots (-a = auch fremde)
|
||||
pvesnap check # Konfiguration prüfen
|
||||
pvesnap config # ncurses-Editor
|
||||
|
||||
pvesnap run # jetzt fällige Gruppen ausführen
|
||||
pvesnap run --force -g täglich # eine Gruppe sofort ausführen
|
||||
pvesnap run --force --dry-run # Probelauf, ändert nichts
|
||||
pvesnap prune -g stündlich # nur aufräumen, keine neuen Snapshots
|
||||
|
||||
systemctl status pvesnap
|
||||
systemctl reload pvesnap # Konfiguration neu einlesen (SIGHUP)
|
||||
journalctl -u pvesnap -f # Protokoll mitlesen
|
||||
```
|
||||
|
||||
Ein manueller `pvesnap run` ist auch möglich, während der Dienst läuft — beide
|
||||
teilen sich eine Sperre und kommen sich nicht in die Quere.
|
||||
|
||||
Mit `-c /pfad/zur.conf` lässt sich jederzeit eine andere Konfiguration verwenden,
|
||||
z. B. zum Ausprobieren.
|
||||
|
||||
---
|
||||
|
||||
## Hinweise aus der Praxis
|
||||
|
||||
* **Snapshot ist kein Backup.** Snapshots liegen auf demselben Storage wie die VM.
|
||||
Für echte Sicherungen zusätzlich `vzdump` / Proxmox Backup Server verwenden.
|
||||
* **Speicherplatz:** Jeder Snapshot hält alte Blöcke fest. Bei schreibfreudigen
|
||||
VMs lieber kurze Vorhaltezeiten wählen und den Storage im Auge behalten.
|
||||
* **Nicht jedes Storage kann Snapshots** — LVM-thick und Verzeichnis-Storage mit
|
||||
`raw`-Images können es nicht. Solche VMs melden einen Fehler im Protokoll; die
|
||||
übrigen laufen normal weiter.
|
||||
* **`vmstate = yes`** friert die VM kurz ein und braucht Platz in Höhe des
|
||||
zugewiesenen RAM. Für regelmäßige Läufe meist unnötig.
|
||||
* **Gruppe umbenennen:** Der neue Name bekommt einen eigenen Kurznamen. Snapshots
|
||||
unter dem alten Namen werden dann nicht mehr automatisch aufgeräumt — vorher
|
||||
aufräumen lassen oder die alten Snapshots von Hand entfernen.
|
||||
* **Zeitumstellung:** Es wird mit lokaler Zeit gerechnet. Ein täglicher Termin um
|
||||
02:30 kann in der Umstellungsnacht ausfallen oder doppelt anstehen.
|
||||
|
||||
---
|
||||
|
||||
## Aufbau
|
||||
|
||||
```
|
||||
pvesnap/
|
||||
config.py INI lesen und schreiben, Gruppen- und Globaleinstellungen
|
||||
schedule.py Berechnung des nächsten Termins
|
||||
naming.py Namensschema und Beschreibungs-Vorlagen
|
||||
proxmox.py pvesh-Anbindung (Inventar, Snapshots anlegen/löschen)
|
||||
engine.py Auswahl der Gäste, Anlegen, Aufräumen
|
||||
daemon.py Hauptschleife, Signale, Sperren
|
||||
state.py merkt sich die letzten Läufe
|
||||
tui.py ncurses-Editor
|
||||
cli.py Kommandozeile
|
||||
config/pvesnap.conf.example
|
||||
systemd/pvesnap.service
|
||||
install.sh uninstall.sh
|
||||
```
|
||||
@@ -0,0 +1,112 @@
|
||||
# =====================================================================
|
||||
# pvesnap - Konfiguration
|
||||
# =====================================================================
|
||||
#
|
||||
# Nach jeder Aenderung: systemctl reload pvesnap
|
||||
# Pruefen: pvesnap check
|
||||
# Komfortabel bearbeiten: pvesnap config (ncurses-Editor)
|
||||
#
|
||||
# Zeitangaben ueberall: 30m 1h 6h 2d12h 1w (0 = unbegrenzt)
|
||||
# ---------------------------------------------------------------------
|
||||
|
||||
[global]
|
||||
# Praefix aller von pvesnap angelegten Snapshots. Nur Snapshots, die mit
|
||||
# diesem Praefix beginnen, werden jemals automatisch geloescht - von Hand
|
||||
# angelegte Snapshots bleiben also garantiert unangetastet.
|
||||
# Namensschema: <prefix>-<gruppe>-<JJJJMMTT>-<HHMMSS>
|
||||
prefix = auto
|
||||
|
||||
# Wie oft der Dienst prueft, ob eine Gruppe faellig ist.
|
||||
check_interval = 60s
|
||||
|
||||
# Merkt sich, wann welche Gruppe zuletzt gelaufen ist.
|
||||
state_file = /var/lib/pvesnap/state.json
|
||||
|
||||
log_level = INFO
|
||||
# log_file = /var/log/pvesnap.log
|
||||
|
||||
# Maximale Wartezeit auf einen einzelnen Snapshot-Task in Proxmox.
|
||||
task_timeout = 15m
|
||||
|
||||
# yes = beim Dienststart sofort einen Durchlauf machen,
|
||||
# no = auf den naechsten regulaeren Termin warten.
|
||||
run_on_start = no
|
||||
|
||||
# yes = nichts wirklich anlegen/loeschen, nur protokollieren.
|
||||
dry_run = no
|
||||
|
||||
# Beschreibung, die an jedem Snapshot haengt (in der Proxmox-Oberflaeche
|
||||
# sichtbar). Platzhalter:
|
||||
# {group} {group_slug} {vmid} {name} {node} {type} {pool} {tags}
|
||||
# {date} {time} {datetime} {timestamp} {keep_time} {keep_count} {schedule}
|
||||
description = pvesnap | Gruppe: {group} | erstellt: {datetime} | Vorhaltezeit: {keep_time} | max: {keep_count}
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------
|
||||
# [defaults] gilt als Vorgabe fuer *alle* Gruppen und kann in jeder
|
||||
# Gruppe einzeln ueberschrieben werden.
|
||||
# ---------------------------------------------------------------------
|
||||
[defaults]
|
||||
enabled = yes
|
||||
skip_stopped = no
|
||||
vmstate = no
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------
|
||||
# Gruppen - beliebig viele, Abschnittsname: [group:NAME]
|
||||
# ---------------------------------------------------------------------
|
||||
#
|
||||
# Zeitplan (entweder ... oder):
|
||||
# interval = 30m alle 30 Minuten
|
||||
# align = yes an der Uhr ausrichten (00:00, 00:30, 01:00 ...)
|
||||
# oder
|
||||
# schedule = hourly + minute = 15
|
||||
# schedule = daily + at = 02:30
|
||||
# schedule = weekly + at = 03:00, day_of_week = so
|
||||
# schedule = monthly + at = 04:00, day_of_month = 1
|
||||
# schedule = yearly + at = 04:00, day_of_month = 1, month = 1
|
||||
#
|
||||
# Vorhaltezeit (beides kombinierbar, 0 = unbegrenzt):
|
||||
# keep_count = 24 hoechstens 24 Snapshots je VM
|
||||
# keep_time = 7d nichts aelter als 7 Tage
|
||||
# keep_min = 1 so viele bleiben immer stehen
|
||||
#
|
||||
# Auswahl der Gaeste (alles kombinierbar, wirkt als ODER):
|
||||
# all = yes
|
||||
# vmids = 100,101,105-110
|
||||
# names = web-*, db-*
|
||||
# tags = prod, wichtig
|
||||
# pools = Kunden
|
||||
# types = qemu (oder lxc; leer = beides)
|
||||
# exclude_vmids = 999
|
||||
# exclude_names = *-test
|
||||
# exclude_tags = nosnap
|
||||
# ---------------------------------------------------------------------
|
||||
|
||||
[group:stuendlich]
|
||||
enabled = no
|
||||
interval = 1h
|
||||
align = yes
|
||||
keep_count = 24
|
||||
keep_time = 2d
|
||||
tags = stuendlich
|
||||
skip_stopped = yes
|
||||
|
||||
[group:taeglich]
|
||||
enabled = no
|
||||
schedule = daily
|
||||
at = 02:30
|
||||
keep_count = 14
|
||||
keep_time = 21d
|
||||
names = web-*, db-*
|
||||
|
||||
[group:monatlich]
|
||||
enabled = no
|
||||
schedule = monthly
|
||||
day_of_month = 1
|
||||
at = 04:00
|
||||
keep_count = 6
|
||||
keep_time = 400d
|
||||
all = yes
|
||||
exclude_tags = nosnap
|
||||
description = Monatssicherung {name} ({vmid}) vom {date}
|
||||
Executable
+133
@@ -0,0 +1,133 @@
|
||||
#!/bin/bash
|
||||
# ---------------------------------------------------------------------
|
||||
# pvesnap - Installation
|
||||
#
|
||||
# ./install.sh installieren, Dienst aktivieren und starten
|
||||
# ./install.sh --no-start installieren, aber Dienst nicht starten
|
||||
# ./install.sh --force auch ohne erkanntes Proxmox VE installieren
|
||||
# ---------------------------------------------------------------------
|
||||
set -euo pipefail
|
||||
|
||||
LIB_DIR="/usr/lib/pvesnap"
|
||||
BIN="/usr/local/bin/pvesnap"
|
||||
CONF_DIR="/etc/pvesnap"
|
||||
CONF="${CONF_DIR}/pvesnap.conf"
|
||||
STATE_DIR="/var/lib/pvesnap"
|
||||
DOC_DIR="/usr/share/doc/pvesnap"
|
||||
UNIT="/etc/systemd/system/pvesnap.service"
|
||||
SRC="$(cd "$(dirname "$0")" && pwd)"
|
||||
|
||||
START=1
|
||||
FORCE=0
|
||||
for arg in "$@"; do
|
||||
case "$arg" in
|
||||
--no-start) START=0 ;;
|
||||
--force) FORCE=1 ;;
|
||||
-h|--help) sed -n '2,8p' "$0" | sed 's/^#[[:space:]]\{0,1\}//'; exit 0 ;;
|
||||
*) echo "Unbekannte Option: $arg" >&2; exit 1 ;;
|
||||
esac
|
||||
done
|
||||
|
||||
info() { printf '\033[1;32m==>\033[0m %s\n' "$*"; }
|
||||
warn() { printf '\033[1;33m==>\033[0m %s\n' "$*" >&2; }
|
||||
fail() { printf '\033[1;31m==>\033[0m %s\n' "$*" >&2; exit 1; }
|
||||
|
||||
[ "$(id -u)" -eq 0 ] || fail "Bitte als root ausfuehren (sudo ./install.sh)."
|
||||
|
||||
command -v python3 >/dev/null 2>&1 || fail "python3 wird benoetigt."
|
||||
python3 - <<'PY' || fail "Python 3.7 oder neuer wird benoetigt."
|
||||
import sys
|
||||
sys.exit(0 if sys.version_info >= (3, 7) else 1)
|
||||
PY
|
||||
|
||||
if ! command -v pvesh >/dev/null 2>&1; then
|
||||
if [ "$FORCE" -eq 1 ]; then
|
||||
warn "pvesh nicht gefunden - installiere trotzdem (--force)."
|
||||
START=0
|
||||
else
|
||||
fail "pvesh nicht gefunden. pvesnap gehoert auf einen Proxmox-VE-Host.
|
||||
Mit --force laesst sich die Installation trotzdem erzwingen."
|
||||
fi
|
||||
fi
|
||||
|
||||
command -v systemctl >/dev/null 2>&1 || fail "systemd wird benoetigt."
|
||||
[ -d "${SRC}/pvesnap" ] || fail "Verzeichnis 'pvesnap' nicht gefunden (Aufruf aus dem Projektordner?)."
|
||||
|
||||
# --- Programm ---------------------------------------------------------
|
||||
info "Installiere Programm nach ${LIB_DIR}"
|
||||
rm -rf "${LIB_DIR}/pvesnap"
|
||||
install -d -m 0755 "${LIB_DIR}"
|
||||
cp -r "${SRC}/pvesnap" "${LIB_DIR}/pvesnap"
|
||||
find "${LIB_DIR}/pvesnap" -name '__pycache__' -type d -exec rm -rf {} + 2>/dev/null || true
|
||||
chmod -R go-w "${LIB_DIR}/pvesnap"
|
||||
|
||||
info "Installiere Startbefehl ${BIN}"
|
||||
cat > "${BIN}" <<EOF
|
||||
#!/bin/sh
|
||||
# von install.sh erzeugt
|
||||
PYTHONPATH="${LIB_DIR}\${PYTHONPATH:+:\$PYTHONPATH}" exec /usr/bin/python3 -m pvesnap "\$@"
|
||||
EOF
|
||||
chmod 0755 "${BIN}"
|
||||
|
||||
# --- Konfiguration ----------------------------------------------------
|
||||
install -d -m 0755 "${CONF_DIR}" "${STATE_DIR}" "${DOC_DIR}"
|
||||
if [ -f "${CONF}" ]; then
|
||||
info "Vorhandene Konfiguration bleibt unveraendert: ${CONF}"
|
||||
install -m 0644 "${SRC}/config/pvesnap.conf.example" "${CONF_DIR}/pvesnap.conf.example"
|
||||
else
|
||||
info "Lege Beispielkonfiguration an: ${CONF}"
|
||||
install -m 0640 "${SRC}/config/pvesnap.conf.example" "${CONF}"
|
||||
install -m 0644 "${SRC}/config/pvesnap.conf.example" "${CONF_DIR}/pvesnap.conf.example"
|
||||
NEW_CONFIG=1
|
||||
fi
|
||||
if [ -f "${SRC}/README.md" ]; then
|
||||
install -m 0644 "${SRC}/README.md" "${DOC_DIR}/README.md"
|
||||
fi
|
||||
|
||||
# --- systemd ----------------------------------------------------------
|
||||
info "Installiere systemd-Unit ${UNIT}"
|
||||
install -m 0644 "${SRC}/systemd/pvesnap.service" "${UNIT}"
|
||||
systemctl daemon-reload
|
||||
|
||||
info "Pruefe Konfiguration"
|
||||
if ! "${BIN}" --config "${CONF}" check; then
|
||||
warn "Die Konfiguration ist noch nicht vollstaendig - Dienst wird nicht gestartet."
|
||||
START=0
|
||||
fi
|
||||
|
||||
if systemctl enable pvesnap.service >/dev/null 2>&1; then
|
||||
info "Dienst beim Systemstart aktiviert"
|
||||
else
|
||||
warn "Dienst konnte nicht aktiviert werden - bitte 'systemctl enable pvesnap' pruefen."
|
||||
fi
|
||||
|
||||
if [ "$START" -eq 1 ]; then
|
||||
info "Starte Dienst"
|
||||
systemctl restart pvesnap.service
|
||||
sleep 1
|
||||
systemctl --no-pager --lines=5 status pvesnap.service || true
|
||||
else
|
||||
warn "Dienst wurde nicht gestartet."
|
||||
fi
|
||||
|
||||
cat <<EOF
|
||||
|
||||
Fertig.
|
||||
|
||||
Konfiguration bearbeiten : pvesnap config (ncurses-Editor)
|
||||
nano ${CONF}
|
||||
Konfiguration pruefen : pvesnap check
|
||||
Uebersicht : pvesnap status
|
||||
VMs und Gruppen : pvesnap vms
|
||||
Testlauf ohne Aenderung : pvesnap run --force --dry-run
|
||||
Nach Aenderungen : systemctl reload pvesnap
|
||||
Protokoll : journalctl -u pvesnap -f
|
||||
EOF
|
||||
|
||||
if [ "${NEW_CONFIG:-0}" -eq 1 ]; then
|
||||
cat <<EOF
|
||||
|
||||
Hinweis: In der Beispielkonfiguration sind alle Gruppen mit "enabled = no"
|
||||
angelegt. Erst nach dem Aktivieren einer Gruppe werden Snapshots erstellt.
|
||||
EOF
|
||||
fi
|
||||
@@ -0,0 +1,8 @@
|
||||
"""pvesnap - automatische Snapshots fuer Proxmox VE.
|
||||
|
||||
Gruppenbasierte Zeitplanung und Vorhaltezeiten, konfiguriert ueber eine
|
||||
INI-Datei, betrieben als systemd-Dienst.
|
||||
"""
|
||||
|
||||
__version__ = "1.0.0"
|
||||
__all__ = ["__version__"]
|
||||
@@ -0,0 +1,6 @@
|
||||
import sys
|
||||
|
||||
from .cli import main
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main())
|
||||
+430
@@ -0,0 +1,430 @@
|
||||
"""Kommandozeile von pvesnap."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import logging
|
||||
import os
|
||||
import sys
|
||||
from datetime import datetime
|
||||
|
||||
from . import __version__
|
||||
from .config import DEFAULT_CONFIG_PATH, ConfigError, load_config
|
||||
from .daemon import Daemon, SingleInstanceLock
|
||||
from .engine import run_group, select_guests
|
||||
from .naming import parse_name
|
||||
from .proxmox import Proxmox, ProxmoxError, pvesh_available
|
||||
from .schedule import describe, next_due
|
||||
from .state import State
|
||||
from .util import format_duration, truncate
|
||||
|
||||
log = logging.getLogger("pvesnap")
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Hilfsfunktionen
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
def setup_logging(level, log_file=""):
|
||||
root = logging.getLogger("pvesnap")
|
||||
root.setLevel(getattr(logging, str(level).upper(), logging.INFO))
|
||||
for handler in list(root.handlers):
|
||||
root.removeHandler(handler)
|
||||
|
||||
# Unter systemd steht der Zeitstempel schon im Journal.
|
||||
plain = os.environ.get("JOURNAL_STREAM") or os.environ.get("INVOCATION_ID")
|
||||
fmt = "%(levelname)s %(message)s" if plain else "%(asctime)s %(levelname)s %(message)s"
|
||||
|
||||
stream = logging.StreamHandler(sys.stderr)
|
||||
stream.setFormatter(logging.Formatter(fmt, datefmt="%Y-%m-%d %H:%M:%S"))
|
||||
root.addHandler(stream)
|
||||
|
||||
if log_file:
|
||||
try:
|
||||
handler = logging.FileHandler(log_file, encoding="utf-8")
|
||||
handler.setFormatter(logging.Formatter(
|
||||
"%(asctime)s %(levelname)s %(message)s", datefmt="%Y-%m-%d %H:%M:%S"))
|
||||
root.addHandler(handler)
|
||||
except OSError as exc:
|
||||
root.warning("Logdatei %s nicht beschreibbar: %s", log_file, exc)
|
||||
|
||||
|
||||
def _load(args):
|
||||
config = load_config(args.config)
|
||||
problems = config.validate()
|
||||
if problems:
|
||||
raise ConfigError("Konfiguration fehlerhaft:\n - %s" % "\n - ".join(problems))
|
||||
if args.dry_run:
|
||||
config.globals.dry_run = True
|
||||
setup_logging("DEBUG" if args.verbose else config.globals.log_level,
|
||||
config.globals.log_file)
|
||||
return config
|
||||
|
||||
|
||||
def _table(rows, headers):
|
||||
if not rows:
|
||||
return ""
|
||||
widths = [len(h) for h in headers]
|
||||
for row in rows:
|
||||
for index, cell in enumerate(row):
|
||||
widths[index] = max(widths[index], len(str(cell)))
|
||||
lines = [" ".join(h.ljust(widths[i]) for i, h in enumerate(headers)).rstrip()]
|
||||
lines.append(" ".join("-" * widths[i] for i in range(len(headers))))
|
||||
for row in rows:
|
||||
lines.append(" ".join(str(cell).ljust(widths[i])
|
||||
for i, cell in enumerate(row)).rstrip())
|
||||
return "\n".join(lines)
|
||||
|
||||
|
||||
def _age(moment, now):
|
||||
seconds = int((now - moment).total_seconds())
|
||||
if seconds < 0:
|
||||
return "in " + format_duration(-seconds, zero="0s")
|
||||
return format_duration(seconds, zero="0s")
|
||||
|
||||
|
||||
def _require_pve():
|
||||
if not pvesh_available():
|
||||
raise ProxmoxError("'pvesh' nicht gefunden - dieser Befehl muss auf einem "
|
||||
"Proxmox-VE-Host ausgefuehrt werden.")
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Befehle
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
def cmd_daemon(args):
|
||||
config = _load(args)
|
||||
daemon = Daemon(args.config, dry_run=args.dry_run)
|
||||
daemon.config = config
|
||||
daemon.run()
|
||||
return 0
|
||||
|
||||
|
||||
def cmd_run(args):
|
||||
config = _load(args)
|
||||
_require_pve()
|
||||
state = State(config.globals.state_file).load()
|
||||
now = datetime.now()
|
||||
|
||||
if args.group:
|
||||
wanted = []
|
||||
for name in args.group:
|
||||
group = config.group(name)
|
||||
if group is None:
|
||||
print("Unbekannte Gruppe: %s" % name, file=sys.stderr)
|
||||
return 2
|
||||
wanted.append(group)
|
||||
else:
|
||||
wanted = [g for g in config.groups if g.enabled]
|
||||
|
||||
if not args.force:
|
||||
due = []
|
||||
for group in wanted:
|
||||
last = state.last_run(group.name)
|
||||
if last is None or next_due(group, last, now) <= now:
|
||||
due.append(group)
|
||||
wanted = due
|
||||
|
||||
if not wanted:
|
||||
print("Zurzeit ist keine Gruppe faellig. (--force erzwingt den Lauf)")
|
||||
return 0
|
||||
|
||||
proxmox = Proxmox(dry_run=config.globals.dry_run,
|
||||
task_timeout=config.globals.task_timeout)
|
||||
guests = proxmox.inventory()
|
||||
|
||||
failed = False
|
||||
with SingleInstanceLock(config.globals.lock_file, wait=600,
|
||||
busy_message="Ein anderer pvesnap-Lauf ist gerade aktiv. "
|
||||
"Bitte spaeter erneut versuchen."):
|
||||
for group in wanted:
|
||||
result = run_group(proxmox, config, group, now=datetime.now(),
|
||||
prune=not args.no_prune, guests=guests)
|
||||
if not config.globals.dry_run:
|
||||
state.record_run(group.name, datetime.now(),
|
||||
created=len(result.created),
|
||||
deleted=len(result.deleted), errors=result.errors)
|
||||
print(result.summary())
|
||||
failed = failed or bool(result.errors)
|
||||
state.save()
|
||||
return 1 if failed else 0
|
||||
|
||||
|
||||
def cmd_prune(args):
|
||||
config = _load(args)
|
||||
_require_pve()
|
||||
groups = []
|
||||
for name in (args.group or [g.name for g in config.groups]):
|
||||
group = config.group(name)
|
||||
if group is None:
|
||||
print("Unbekannte Gruppe: %s" % name, file=sys.stderr)
|
||||
return 2
|
||||
groups.append(group)
|
||||
|
||||
proxmox = Proxmox(dry_run=config.globals.dry_run,
|
||||
task_timeout=config.globals.task_timeout)
|
||||
guests = proxmox.inventory()
|
||||
failed = False
|
||||
with SingleInstanceLock(config.globals.lock_file, wait=600,
|
||||
busy_message="Ein anderer pvesnap-Lauf ist gerade aktiv. "
|
||||
"Bitte spaeter erneut versuchen."):
|
||||
for group in groups:
|
||||
result = run_group(proxmox, config, group, now=datetime.now(),
|
||||
create=False, prune=True, guests=guests)
|
||||
print(result.summary())
|
||||
failed = failed or bool(result.errors)
|
||||
return 1 if failed else 0
|
||||
|
||||
|
||||
def cmd_status(args):
|
||||
config = _load(args)
|
||||
state = State(config.globals.state_file).load()
|
||||
now = datetime.now()
|
||||
|
||||
guests = None
|
||||
if pvesh_available():
|
||||
try:
|
||||
guests = Proxmox().inventory()
|
||||
except ProxmoxError as exc:
|
||||
print("Hinweis: Inventar nicht lesbar (%s)\n" % exc, file=sys.stderr)
|
||||
|
||||
print("pvesnap %s - Konfiguration: %s" % (__version__, config.path))
|
||||
print("Praefix: %s Zustand: %s%s\n"
|
||||
% (config.globals.prefix, config.globals.state_file,
|
||||
" [TESTLAUF aktiv]" if config.globals.dry_run else ""))
|
||||
|
||||
rows = []
|
||||
for group in config.groups:
|
||||
last = state.last_run(group.name)
|
||||
info = state.info(group.name)
|
||||
if group.enabled:
|
||||
try:
|
||||
upcoming = next_due(group, last, now)
|
||||
next_text = upcoming.strftime("%d.%m. %H:%M")
|
||||
if upcoming <= now:
|
||||
next_text = "faellig"
|
||||
except ValueError:
|
||||
next_text = "?"
|
||||
else:
|
||||
next_text = "-"
|
||||
|
||||
matched = "?" if guests is None else str(len(select_guests(group, guests)))
|
||||
rows.append([
|
||||
group.name,
|
||||
"ja" if group.enabled else "nein",
|
||||
describe(group),
|
||||
"%s / %s" % (group.keep_count or "unbegr.", format_duration(group.keep_time)),
|
||||
matched,
|
||||
last.strftime("%d.%m. %H:%M") if last else "nie",
|
||||
next_text,
|
||||
info.get("status", "-"),
|
||||
])
|
||||
|
||||
if rows:
|
||||
print(_table(rows, ["Gruppe", "Aktiv", "Zeitplan", "Behalte (Anz./Zeit)",
|
||||
"VMs", "Letzter Lauf", "Naechster", "Status"]))
|
||||
else:
|
||||
print("Keine Gruppen konfiguriert.")
|
||||
|
||||
errors = [(name, info.get("errors") or [])
|
||||
for name, info in state.data.get("groups", {}).items()]
|
||||
errors = [(name, msgs) for name, msgs in errors if msgs]
|
||||
if errors:
|
||||
print("\nLetzte Fehler:")
|
||||
for name, messages in errors:
|
||||
for message in messages:
|
||||
print(" [%s] %s" % (name, message))
|
||||
return 0
|
||||
|
||||
|
||||
def cmd_list(args):
|
||||
config = _load(args)
|
||||
_require_pve()
|
||||
proxmox = Proxmox()
|
||||
guests = proxmox.inventory()
|
||||
now = datetime.now()
|
||||
prefix = config.globals.prefix
|
||||
|
||||
if args.group:
|
||||
groups = []
|
||||
for name in args.group:
|
||||
group = config.group(name)
|
||||
if group is None:
|
||||
print("Unbekannte Gruppe: %s" % name, file=sys.stderr)
|
||||
return 2
|
||||
groups.append(group)
|
||||
else:
|
||||
groups = config.groups
|
||||
|
||||
interesting = {}
|
||||
for group in groups:
|
||||
for guest in select_guests(group, guests):
|
||||
interesting[guest.vmid] = guest
|
||||
|
||||
rows = []
|
||||
for vmid in sorted(interesting):
|
||||
guest = interesting[vmid]
|
||||
try:
|
||||
snapshots = proxmox.list_snapshots(guest)
|
||||
except ProxmoxError as exc:
|
||||
print("%s: %s" % (guest.label, exc), file=sys.stderr)
|
||||
continue
|
||||
for snap in sorted(snapshots, key=lambda s: s.snaptime, reverse=True):
|
||||
parsed = parse_name(prefix, snap.name)
|
||||
if parsed is None and not args.all:
|
||||
continue
|
||||
created = (datetime.fromtimestamp(snap.snaptime) if snap.snaptime
|
||||
else (parsed or {}).get("created"))
|
||||
rows.append([
|
||||
guest.vmid,
|
||||
truncate(guest.name, 20),
|
||||
snap.name,
|
||||
(parsed or {}).get("slug", "-"),
|
||||
created.strftime("%d.%m.%y %H:%M") if created else "?",
|
||||
_age(created, now) if created else "?",
|
||||
truncate(snap.description.replace("\n", " "), 44),
|
||||
])
|
||||
|
||||
if rows:
|
||||
print(_table(rows, ["VMID", "Name", "Snapshot", "Gruppe", "Erstellt",
|
||||
"Alter", "Beschreibung"]))
|
||||
print("\n%d Snapshot(s)%s" % (len(rows), "" if args.all else " von pvesnap"))
|
||||
else:
|
||||
print("Keine passenden Snapshots gefunden.")
|
||||
return 0
|
||||
|
||||
|
||||
def cmd_vms(args):
|
||||
config = _load(args)
|
||||
_require_pve()
|
||||
guests = Proxmox().inventory()
|
||||
assignment = {}
|
||||
for group in config.groups:
|
||||
for guest in select_guests(group, guests):
|
||||
assignment.setdefault(guest.vmid, []).append(group.name)
|
||||
|
||||
rows = [[guest.vmid,
|
||||
"LXC" if guest.type == "lxc" else "VM",
|
||||
truncate(guest.name, 28),
|
||||
guest.node,
|
||||
guest.status,
|
||||
",".join(guest.tags) or "-",
|
||||
guest.pool or "-",
|
||||
", ".join(assignment.get(guest.vmid, [])) or "-"]
|
||||
for guest in guests]
|
||||
if rows:
|
||||
print(_table(rows, ["VMID", "Typ", "Name", "Node", "Status", "Tags",
|
||||
"Pool", "Gruppen"]))
|
||||
else:
|
||||
print("Keine VMs/Container gefunden.")
|
||||
return 0
|
||||
|
||||
|
||||
def cmd_check(args):
|
||||
try:
|
||||
config = load_config(args.config)
|
||||
except ConfigError as exc:
|
||||
print(str(exc), file=sys.stderr)
|
||||
return 1
|
||||
problems = config.validate()
|
||||
if problems:
|
||||
print("Konfiguration fehlerhaft:", file=sys.stderr)
|
||||
for problem in problems:
|
||||
print(" - %s" % problem, file=sys.stderr)
|
||||
return 1
|
||||
print("Konfiguration in Ordnung: %d Gruppe(n)." % len(config.groups))
|
||||
for group in config.groups:
|
||||
print(" - %s: %s, behalte %s / %s%s"
|
||||
% (group.name, describe(group),
|
||||
group.keep_count or "unbegrenzt", format_duration(group.keep_time),
|
||||
"" if group.enabled else " [deaktiviert]"))
|
||||
return 0
|
||||
|
||||
|
||||
def cmd_config(args):
|
||||
from .tui import run_editor
|
||||
return run_editor(args.config)
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Argumente
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
def build_parser():
|
||||
parser = argparse.ArgumentParser(
|
||||
prog="pvesnap",
|
||||
description="Automatische Proxmox-Snapshots mit Gruppen, Zeitplan und Vorhaltezeit.")
|
||||
parser.add_argument("-c", "--config", default=os.environ.get("PVESNAP_CONFIG",
|
||||
DEFAULT_CONFIG_PATH),
|
||||
help="Pfad zur INI-Datei (Vorgabe: %(default)s)")
|
||||
parser.add_argument("-n", "--dry-run", action="store_true",
|
||||
help="nichts wirklich anlegen oder loeschen, nur anzeigen")
|
||||
parser.add_argument("-v", "--verbose", action="store_true", help="ausfuehrliche Ausgabe")
|
||||
parser.add_argument("-V", "--version", action="version",
|
||||
version="pvesnap %s" % __version__)
|
||||
|
||||
sub = parser.add_subparsers(dest="command")
|
||||
|
||||
p_daemon = sub.add_parser("daemon", help="Dienst im Vordergrund starten (fuer systemd)")
|
||||
p_daemon.set_defaults(func=cmd_daemon)
|
||||
|
||||
p_run = sub.add_parser("run", help="faellige Gruppen jetzt ausfuehren")
|
||||
p_run.add_argument("-g", "--group", action="append", help="nur diese Gruppe (mehrfach moeglich)")
|
||||
p_run.add_argument("-f", "--force", action="store_true",
|
||||
help="unabhaengig vom Zeitplan ausfuehren")
|
||||
p_run.add_argument("--no-prune", action="store_true", help="nicht aufraeumen")
|
||||
p_run.set_defaults(func=cmd_run)
|
||||
|
||||
p_prune = sub.add_parser("prune", help="nur alte Snapshots aufraeumen")
|
||||
p_prune.add_argument("-g", "--group", action="append", help="nur diese Gruppe")
|
||||
p_prune.set_defaults(func=cmd_prune)
|
||||
|
||||
p_status = sub.add_parser("status", help="Uebersicht ueber Gruppen und Termine")
|
||||
p_status.set_defaults(func=cmd_status)
|
||||
|
||||
p_list = sub.add_parser("list", help="vorhandene Snapshots anzeigen")
|
||||
p_list.add_argument("-g", "--group", action="append", help="nur diese Gruppe")
|
||||
p_list.add_argument("-a", "--all", action="store_true",
|
||||
help="auch fremde/manuelle Snapshots anzeigen")
|
||||
p_list.set_defaults(func=cmd_list)
|
||||
|
||||
p_vms = sub.add_parser("vms", help="alle VMs/Container und ihre Gruppen anzeigen")
|
||||
p_vms.set_defaults(func=cmd_vms)
|
||||
|
||||
p_check = sub.add_parser("check", help="Konfiguration pruefen")
|
||||
p_check.set_defaults(func=cmd_check)
|
||||
|
||||
for name in ("config", "edit"):
|
||||
p_config = sub.add_parser(name, help="Konfiguration im ncurses-Editor bearbeiten")
|
||||
p_config.set_defaults(func=cmd_config)
|
||||
|
||||
return parser
|
||||
|
||||
|
||||
def main(argv=None):
|
||||
parser = build_parser()
|
||||
args = parser.parse_args(argv)
|
||||
if not getattr(args, "func", None):
|
||||
args.command = "status"
|
||||
args.func = cmd_status
|
||||
|
||||
setup_logging("DEBUG" if args.verbose else "INFO")
|
||||
try:
|
||||
return args.func(args)
|
||||
except ConfigError as exc:
|
||||
print(str(exc), file=sys.stderr)
|
||||
return 2
|
||||
except ProxmoxError as exc:
|
||||
print("Proxmox-Fehler: %s" % exc, file=sys.stderr)
|
||||
return 3
|
||||
except RuntimeError as exc:
|
||||
print(str(exc), file=sys.stderr)
|
||||
return 4
|
||||
except KeyboardInterrupt:
|
||||
print("\nAbgebrochen.", file=sys.stderr)
|
||||
return 130
|
||||
|
||||
|
||||
if __name__ == "__main__": # pragma: no cover
|
||||
sys.exit(main())
|
||||
@@ -0,0 +1,501 @@
|
||||
"""Einlesen und Schreiben der pvesnap-INI-Datei."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import configparser
|
||||
import os
|
||||
import re
|
||||
from dataclasses import dataclass, field, replace
|
||||
|
||||
from .util import (format_bool, format_duration, format_vmid_list, parse_bool,
|
||||
parse_duration, parse_list, parse_vmid_list, slugify)
|
||||
|
||||
DEFAULT_CONFIG_PATH = "/etc/pvesnap/pvesnap.conf"
|
||||
|
||||
GROUP_SECTION_RE = re.compile(r"^(?:group|gruppe)\s*[:\.]\s*(.+)$", re.IGNORECASE)
|
||||
|
||||
SCHEDULE_KINDS = ("hourly", "daily", "weekly", "monthly", "yearly")
|
||||
|
||||
WEEKDAYS = {
|
||||
"mon": 0, "monday": 0, "mo": 0, "montag": 0,
|
||||
"tue": 1, "tuesday": 1, "di": 1, "dienstag": 1, "tues": 1,
|
||||
"wed": 2, "wednesday": 2, "mi": 2, "mittwoch": 2,
|
||||
"thu": 3, "thursday": 3, "do": 3, "donnerstag": 3, "thur": 3, "thurs": 3,
|
||||
"fri": 4, "friday": 4, "fr": 4, "freitag": 4,
|
||||
"sat": 5, "saturday": 5, "sa": 5, "samstag": 5,
|
||||
"sun": 6, "sunday": 6, "so": 6, "sonntag": 6,
|
||||
}
|
||||
|
||||
WEEKDAY_NAMES = ["Mo", "Di", "Mi", "Do", "Fr", "Sa", "So"]
|
||||
|
||||
DEFAULT_DESCRIPTION = (
|
||||
"pvesnap | Gruppe: {group} | erstellt: {datetime} | "
|
||||
"Vorhaltezeit: {keep_time} | max: {keep_count}"
|
||||
)
|
||||
|
||||
|
||||
class ConfigError(Exception):
|
||||
"""Fehler beim Lesen oder Pruefen der Konfiguration."""
|
||||
|
||||
|
||||
def parse_weekday(text):
|
||||
value = str(text).strip().lower()
|
||||
if value in WEEKDAYS:
|
||||
return WEEKDAYS[value]
|
||||
if value.isdigit():
|
||||
number = int(value)
|
||||
if 0 <= number <= 6:
|
||||
return number
|
||||
if number == 7:
|
||||
return 6
|
||||
raise ValueError("ungueltiger Wochentag: %r" % text)
|
||||
|
||||
|
||||
def parse_time_of_day(text):
|
||||
"""'02:30' -> (2, 30). Auch '2', '2:5', '02:30:00' werden akzeptiert."""
|
||||
value = str(text).strip()
|
||||
match = re.match(r"^(\d{1,2})(?::(\d{1,2}))?(?::(\d{1,2}))?$", value)
|
||||
if not match:
|
||||
raise ValueError("ungueltige Uhrzeit: %r (erwartet HH:MM)" % text)
|
||||
hour = int(match.group(1))
|
||||
minute = int(match.group(2) or 0)
|
||||
if hour > 23 or minute > 59:
|
||||
raise ValueError("ungueltige Uhrzeit: %r" % text)
|
||||
return hour, minute
|
||||
|
||||
|
||||
@dataclass
|
||||
class Group:
|
||||
"""Eine Snapshot-Gruppe: Zeitplan + Vorhaltezeit + VM-Auswahl."""
|
||||
|
||||
name: str
|
||||
enabled: bool = True
|
||||
|
||||
# --- Zeitplan -------------------------------------------------------
|
||||
interval: int = 0 # Sekunden; > 0 = intervallbasiert
|
||||
schedule: str = "" # hourly/daily/weekly/monthly/yearly
|
||||
at: str = "00:00" # Uhrzeit fuer daily/weekly/monthly/yearly
|
||||
minute: int = 0 # Minute fuer schedule = hourly
|
||||
day_of_week: int = 0 # 0 = Montag (weekly)
|
||||
day_of_month: int = 1 # 1..31 (monthly/yearly)
|
||||
month: int = 1 # 1..12 (yearly)
|
||||
align: bool = True # Intervalle an der Uhr ausrichten
|
||||
|
||||
# --- Vorhaltezeit ---------------------------------------------------
|
||||
keep_count: int = 0 # max. Anzahl je VM (0 = unbegrenzt)
|
||||
keep_time: int = 0 # max. Alter in Sekunden (0 = unbegrenzt)
|
||||
keep_min: int = 0 # so viele bleiben immer stehen
|
||||
|
||||
# --- Auswahl der Gaeste ---------------------------------------------
|
||||
all: bool = False
|
||||
vmids: list = field(default_factory=list)
|
||||
names: list = field(default_factory=list) # Glob-Muster
|
||||
tags: list = field(default_factory=list)
|
||||
pools: list = field(default_factory=list)
|
||||
types: list = field(default_factory=list) # qemu / lxc
|
||||
exclude_vmids: list = field(default_factory=list)
|
||||
exclude_names: list = field(default_factory=list)
|
||||
exclude_tags: list = field(default_factory=list)
|
||||
|
||||
# --- Snapshot-Optionen ----------------------------------------------
|
||||
vmstate: bool = False # RAM mitsichern (nur QEMU, nur laufend)
|
||||
skip_stopped: bool = False # gestoppte Gaeste ueberspringen
|
||||
description: str = "" # Vorlage; leer = globale Vorlage
|
||||
|
||||
@property
|
||||
def slug(self):
|
||||
"""Kurzform des Gruppennamens, taucht im Snapshot-Namen auf."""
|
||||
return slugify(self.name)
|
||||
|
||||
def selects_anything(self):
|
||||
return bool(self.all or self.vmids or self.names or self.tags or self.pools)
|
||||
|
||||
def validate(self):
|
||||
problems = []
|
||||
if not self.name.strip():
|
||||
problems.append("Gruppe ohne Namen")
|
||||
if self.interval <= 0 and not self.schedule:
|
||||
problems.append("[%s] weder 'interval' noch 'schedule' gesetzt" % self.name)
|
||||
if self.interval > 0 and self.schedule:
|
||||
problems.append("[%s] 'interval' und 'schedule' schliessen sich aus" % self.name)
|
||||
if self.schedule and self.schedule not in SCHEDULE_KINDS:
|
||||
problems.append("[%s] unbekannter Zeitplan %r (erlaubt: %s)"
|
||||
% (self.name, self.schedule, ", ".join(SCHEDULE_KINDS)))
|
||||
if self.interval > 0 and self.interval < 60:
|
||||
problems.append("[%s] 'interval' muss mindestens 60s betragen" % self.name)
|
||||
if not self.selects_anything():
|
||||
problems.append("[%s] keine VMs ausgewaehlt (all/vmids/names/tags/pools)" % self.name)
|
||||
if self.keep_count <= 0 and self.keep_time <= 0:
|
||||
problems.append("[%s] weder 'keep_count' noch 'keep_time' gesetzt - "
|
||||
"Snapshots wuerden nie geloescht" % self.name)
|
||||
for kind in self.types:
|
||||
if kind not in ("qemu", "lxc"):
|
||||
problems.append("[%s] unbekannter Typ %r (erlaubt: qemu, lxc)" % (self.name, kind))
|
||||
try:
|
||||
parse_time_of_day(self.at)
|
||||
except ValueError as exc:
|
||||
problems.append("[%s] %s" % (self.name, exc))
|
||||
if not 1 <= self.day_of_month <= 31:
|
||||
problems.append("[%s] 'day_of_month' muss zwischen 1 und 31 liegen" % self.name)
|
||||
return problems
|
||||
|
||||
|
||||
@dataclass
|
||||
class GlobalConfig:
|
||||
prefix: str = "auto"
|
||||
check_interval: int = 60
|
||||
state_file: str = "/var/lib/pvesnap/state.json"
|
||||
log_level: str = "INFO"
|
||||
log_file: str = ""
|
||||
dry_run: bool = False
|
||||
task_timeout: int = 900
|
||||
run_on_start: bool = False
|
||||
description: str = DEFAULT_DESCRIPTION
|
||||
lock_file: str = "/run/pvesnap.lock"
|
||||
|
||||
def validate(self):
|
||||
problems = []
|
||||
if not re.match(r"^[A-Za-z][A-Za-z0-9]{0,15}$", self.prefix):
|
||||
problems.append("[global] 'prefix' muss mit einem Buchstaben beginnen und darf "
|
||||
"nur Buchstaben/Ziffern enthalten (max. 16 Zeichen)")
|
||||
if self.check_interval < 5:
|
||||
problems.append("[global] 'check_interval' muss mindestens 5 Sekunden betragen")
|
||||
if self.log_level.upper() not in ("DEBUG", "INFO", "WARNING", "ERROR"):
|
||||
problems.append("[global] unbekannter 'log_level': %s" % self.log_level)
|
||||
return problems
|
||||
|
||||
|
||||
@dataclass
|
||||
class Config:
|
||||
globals: GlobalConfig = field(default_factory=GlobalConfig)
|
||||
groups: list = field(default_factory=list)
|
||||
defaults: dict = field(default_factory=dict)
|
||||
path: str = DEFAULT_CONFIG_PATH
|
||||
|
||||
def group(self, name):
|
||||
for group in self.groups:
|
||||
if group.name.lower() == str(name).lower():
|
||||
return group
|
||||
return None
|
||||
|
||||
def validate(self):
|
||||
from .naming import effective_slug
|
||||
|
||||
problems = list(self.globals.validate())
|
||||
seen = {}
|
||||
for group in self.groups:
|
||||
problems.extend(group.validate())
|
||||
# Der Kurzname wird im Snapshot-Namen ggf. gekuerzt - Kollisionen
|
||||
# muessen also auf der gekuerzten Form geprueft werden.
|
||||
slug = effective_slug(self.globals.prefix, group.slug)
|
||||
if slug in seen:
|
||||
problems.append("Gruppen %r und %r ergeben denselben Kurznamen %r - "
|
||||
"bitte unterscheidbarer benennen" % (seen[slug], group.name, slug))
|
||||
seen[slug] = group.name
|
||||
return problems
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Lesen
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
_GROUP_KEYS = {
|
||||
"enabled", "interval", "schedule", "at", "minute", "day_of_week", "day_of_month",
|
||||
"month", "align", "keep_count", "keep_time", "keep_min", "all", "vmids", "names",
|
||||
"tags", "pools", "types", "exclude_vmids", "exclude_names", "exclude_tags",
|
||||
"vmstate", "skip_stopped", "description",
|
||||
}
|
||||
|
||||
# Deutsche Schreibweisen als Synonyme, damit die INI lesbar bleibt.
|
||||
_KEY_ALIASES = {
|
||||
"aktiv": "enabled", "aktiviert": "enabled",
|
||||
"intervall": "interval",
|
||||
"zeitplan": "schedule",
|
||||
"uhrzeit": "at", "zeit": "at",
|
||||
"wochentag": "day_of_week",
|
||||
"monatstag": "day_of_month",
|
||||
"monat": "month",
|
||||
"anzahl": "keep_count", "max_anzahl": "keep_count", "behalte_anzahl": "keep_count",
|
||||
"vorhaltezeit": "keep_time", "behalte_zeit": "keep_time", "max_alter": "keep_time",
|
||||
"mindestens": "keep_min",
|
||||
"alle": "all",
|
||||
"namen": "names",
|
||||
"typen": "types",
|
||||
"beschreibung": "description",
|
||||
"ausschluss_vmids": "exclude_vmids",
|
||||
"ausschluss_namen": "exclude_names",
|
||||
"gestoppte_ueberspringen": "skip_stopped",
|
||||
}
|
||||
|
||||
|
||||
def _canonical_key(key):
|
||||
key = key.strip().lower().replace("-", "_")
|
||||
return _KEY_ALIASES.get(key, key)
|
||||
|
||||
|
||||
def _normalize_section(section):
|
||||
return {_canonical_key(k): v for k, v in section.items()}
|
||||
|
||||
|
||||
def load_config(path=DEFAULT_CONFIG_PATH):
|
||||
"""Liest die INI-Datei und gibt eine geprueft-parsierte Config zurueck."""
|
||||
if not os.path.exists(path):
|
||||
raise ConfigError("Konfigurationsdatei nicht gefunden: %s" % path)
|
||||
|
||||
parser = configparser.ConfigParser(interpolation=None)
|
||||
parser.optionxform = str # Gross-/Kleinschreibung selbst behandeln
|
||||
try:
|
||||
with open(path, "r", encoding="utf-8") as handle:
|
||||
parser.read_file(handle)
|
||||
except (configparser.Error, OSError) as exc:
|
||||
raise ConfigError("Konfiguration nicht lesbar (%s): %s" % (path, exc))
|
||||
|
||||
config = Config(path=path)
|
||||
errors = []
|
||||
|
||||
# [global]
|
||||
for name in parser.sections():
|
||||
if name.strip().lower() in ("global", "allgemein", "main"):
|
||||
config.globals = _parse_global(_normalize_section(parser[name]), errors)
|
||||
break
|
||||
|
||||
# [defaults] - Vorgabewerte fuer alle Gruppen
|
||||
defaults = {}
|
||||
for name in parser.sections():
|
||||
if name.strip().lower() in ("defaults", "default", "vorgaben", "standard"):
|
||||
defaults = _normalize_section(parser[name])
|
||||
break
|
||||
config.defaults = dict(defaults)
|
||||
|
||||
# [group:NAME]
|
||||
for name in parser.sections():
|
||||
match = GROUP_SECTION_RE.match(name.strip())
|
||||
if not match:
|
||||
continue
|
||||
group_name = match.group(1).strip()
|
||||
merged = dict(defaults)
|
||||
merged.update(_normalize_section(parser[name]))
|
||||
config.groups.append(_parse_group(group_name, merged, errors))
|
||||
|
||||
if errors:
|
||||
raise ConfigError("Fehler in %s:\n - %s" % (path, "\n - ".join(errors)))
|
||||
return config
|
||||
|
||||
|
||||
def _parse_global(section, errors):
|
||||
result = GlobalConfig()
|
||||
|
||||
def take(key, parser_fn, target=None):
|
||||
if key not in section:
|
||||
return
|
||||
try:
|
||||
setattr(result, target or key, parser_fn(section[key]))
|
||||
except ValueError as exc:
|
||||
errors.append("[global] %s: %s" % (key, exc))
|
||||
|
||||
take("prefix", lambda v: str(v).strip())
|
||||
take("check_interval", lambda v: parse_duration(v, default_unit="s"))
|
||||
take("state_file", lambda v: str(v).strip())
|
||||
take("log_level", lambda v: str(v).strip().upper())
|
||||
take("log_file", lambda v: str(v).strip())
|
||||
take("lock_file", lambda v: str(v).strip())
|
||||
take("dry_run", parse_bool)
|
||||
take("task_timeout", lambda v: parse_duration(v, default_unit="s"))
|
||||
take("run_on_start", parse_bool)
|
||||
take("description", lambda v: str(v).strip())
|
||||
# Synonyme
|
||||
if "description_template" in section:
|
||||
result.description = str(section["description_template"]).strip()
|
||||
if "testlauf" in section:
|
||||
try:
|
||||
result.dry_run = parse_bool(section["testlauf"])
|
||||
except ValueError as exc:
|
||||
errors.append("[global] testlauf: %s" % exc)
|
||||
|
||||
for key in section:
|
||||
if key not in ("prefix", "check_interval", "state_file", "log_level", "log_file",
|
||||
"lock_file", "dry_run", "task_timeout", "run_on_start", "description",
|
||||
"description_template", "testlauf"):
|
||||
errors.append("[global] unbekannter Schluessel: %s" % key)
|
||||
return result
|
||||
|
||||
|
||||
def _parse_group(name, section, errors):
|
||||
group = Group(name=name)
|
||||
prefix = "[group:%s]" % name
|
||||
|
||||
def take(key, parser_fn, target=None):
|
||||
if key not in section:
|
||||
return
|
||||
raw = section[key]
|
||||
try:
|
||||
setattr(group, target or key, parser_fn(raw))
|
||||
except ValueError as exc:
|
||||
errors.append("%s %s: %s" % (prefix, key, exc))
|
||||
|
||||
take("enabled", parse_bool)
|
||||
take("interval", lambda v: parse_duration(v, default_unit="m"))
|
||||
take("schedule", lambda v: str(v).strip().lower())
|
||||
take("at", lambda v: "%02d:%02d" % parse_time_of_day(v))
|
||||
take("minute", lambda v: int(str(v).strip()))
|
||||
take("day_of_week", parse_weekday)
|
||||
take("day_of_month", lambda v: int(str(v).strip()))
|
||||
take("month", lambda v: int(str(v).strip()))
|
||||
take("align", parse_bool)
|
||||
|
||||
take("keep_count", lambda v: max(0, int(str(v).strip())))
|
||||
take("keep_time", lambda v: parse_duration(v, default_unit="d"))
|
||||
take("keep_min", lambda v: max(0, int(str(v).strip())))
|
||||
|
||||
take("all", parse_bool)
|
||||
take("vmids", parse_vmid_list)
|
||||
take("names", parse_list)
|
||||
take("tags", lambda v: [t.lower() for t in parse_list(v)])
|
||||
take("pools", parse_list)
|
||||
take("types", lambda v: [t.lower() for t in parse_list(v)])
|
||||
take("exclude_vmids", parse_vmid_list)
|
||||
take("exclude_names", parse_list)
|
||||
take("exclude_tags", lambda v: [t.lower() for t in parse_list(v)])
|
||||
|
||||
take("vmstate", parse_bool)
|
||||
take("skip_stopped", parse_bool)
|
||||
take("description", lambda v: str(v).strip())
|
||||
|
||||
# Bequemlichkeit: "schedule = 1h" wird als Intervall verstanden.
|
||||
if group.schedule and group.schedule not in SCHEDULE_KINDS and not group.interval:
|
||||
try:
|
||||
group.interval = parse_duration(group.schedule, default_unit="m")
|
||||
group.schedule = ""
|
||||
except ValueError:
|
||||
pass
|
||||
|
||||
for key in section:
|
||||
if key not in _GROUP_KEYS:
|
||||
errors.append("%s unbekannter Schluessel: %s" % (prefix, key))
|
||||
|
||||
return group
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Schreiben (wird vom ncurses-Editor benutzt)
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
_HEADER = """\
|
||||
# pvesnap - Konfiguration
|
||||
#
|
||||
# Diese Datei wurde vom Konfigurationseditor geschrieben ("pvesnap config").
|
||||
# Sie kann jederzeit auch von Hand bearbeitet werden.
|
||||
#
|
||||
# Zeitangaben: 30m, 1h, 6h, 2d12h, 1w ... (0 / "nie" = unbegrenzt)
|
||||
# Nach Aenderungen: systemctl reload pvesnap
|
||||
"""
|
||||
|
||||
|
||||
def _group_to_lines(group, globals_):
|
||||
lines = ["[group:%s]" % group.name]
|
||||
lines.append("enabled = %s" % format_bool(group.enabled))
|
||||
if group.schedule:
|
||||
lines.append("schedule = %s" % group.schedule)
|
||||
if group.schedule == "hourly":
|
||||
lines.append("minute = %d" % group.minute)
|
||||
else:
|
||||
lines.append("at = %s" % group.at)
|
||||
if group.schedule == "weekly":
|
||||
lines.append("day_of_week = %s" % WEEKDAY_NAMES[group.day_of_week].lower())
|
||||
if group.schedule in ("monthly", "yearly"):
|
||||
lines.append("day_of_month = %d" % group.day_of_month)
|
||||
if group.schedule == "yearly":
|
||||
lines.append("month = %d" % group.month)
|
||||
else:
|
||||
lines.append("interval = %s" % format_duration(group.interval, zero="1h"))
|
||||
lines.append("align = %s" % format_bool(group.align))
|
||||
|
||||
lines.append("keep_count = %d" % group.keep_count)
|
||||
lines.append("keep_time = %s" % format_duration(group.keep_time, zero="0"))
|
||||
if group.keep_min:
|
||||
lines.append("keep_min = %d" % group.keep_min)
|
||||
|
||||
if group.all:
|
||||
lines.append("all = yes")
|
||||
if group.vmids:
|
||||
lines.append("vmids = %s" % format_vmid_list(group.vmids))
|
||||
if group.names:
|
||||
lines.append("names = %s" % ", ".join(group.names))
|
||||
if group.tags:
|
||||
lines.append("tags = %s" % ", ".join(group.tags))
|
||||
if group.pools:
|
||||
lines.append("pools = %s" % ", ".join(group.pools))
|
||||
if group.types:
|
||||
lines.append("types = %s" % ", ".join(group.types))
|
||||
if group.exclude_vmids:
|
||||
lines.append("exclude_vmids = %s" % format_vmid_list(group.exclude_vmids))
|
||||
if group.exclude_names:
|
||||
lines.append("exclude_names = %s" % ", ".join(group.exclude_names))
|
||||
if group.exclude_tags:
|
||||
lines.append("exclude_tags = %s" % ", ".join(group.exclude_tags))
|
||||
|
||||
if group.vmstate:
|
||||
lines.append("vmstate = yes")
|
||||
if group.skip_stopped:
|
||||
lines.append("skip_stopped = yes")
|
||||
if group.description and group.description != globals_.description:
|
||||
lines.append("description = %s" % group.description)
|
||||
return lines
|
||||
|
||||
|
||||
def dump_config(config):
|
||||
"""Erzeugt den kompletten INI-Text zu einer Config."""
|
||||
g = config.globals
|
||||
lines = [_HEADER, "[global]"]
|
||||
lines.append("prefix = %s" % g.prefix)
|
||||
lines.append("check_interval = %s" % format_duration(g.check_interval, zero="60s"))
|
||||
lines.append("state_file = %s" % g.state_file)
|
||||
if g.lock_file != GlobalConfig.lock_file:
|
||||
lines.append("lock_file = %s" % g.lock_file)
|
||||
lines.append("log_level = %s" % g.log_level)
|
||||
if g.log_file:
|
||||
lines.append("log_file = %s" % g.log_file)
|
||||
lines.append("task_timeout = %s" % format_duration(g.task_timeout, zero="900s"))
|
||||
lines.append("run_on_start = %s" % format_bool(g.run_on_start))
|
||||
lines.append("dry_run = %s" % format_bool(g.dry_run))
|
||||
lines.append("description = %s" % g.description)
|
||||
lines.append("")
|
||||
|
||||
for group in config.groups:
|
||||
lines.extend(_group_to_lines(group, g))
|
||||
lines.append("")
|
||||
|
||||
return "\n".join(lines).rstrip() + "\n"
|
||||
|
||||
|
||||
def save_config(config, path=None):
|
||||
"""Schreibt die Config atomar; legt vorher eine .bak-Kopie an."""
|
||||
target = path or config.path
|
||||
directory = os.path.dirname(os.path.abspath(target))
|
||||
os.makedirs(directory, exist_ok=True)
|
||||
|
||||
if os.path.exists(target):
|
||||
try:
|
||||
with open(target, "r", encoding="utf-8") as handle:
|
||||
previous = handle.read()
|
||||
with open(target + ".bak", "w", encoding="utf-8") as handle:
|
||||
handle.write(previous)
|
||||
except OSError:
|
||||
pass # Backup ist Kuer, kein Muss
|
||||
|
||||
tmp = target + ".tmp"
|
||||
with open(tmp, "w", encoding="utf-8") as handle:
|
||||
handle.write(dump_config(config))
|
||||
handle.flush()
|
||||
os.fsync(handle.fileno())
|
||||
os.replace(tmp, target)
|
||||
return target
|
||||
|
||||
|
||||
def clone_group(group, new_name):
|
||||
return replace(group, name=new_name,
|
||||
vmids=list(group.vmids), names=list(group.names),
|
||||
tags=list(group.tags), pools=list(group.pools),
|
||||
types=list(group.types), exclude_vmids=list(group.exclude_vmids),
|
||||
exclude_names=list(group.exclude_names),
|
||||
exclude_tags=list(group.exclude_tags))
|
||||
@@ -0,0 +1,232 @@
|
||||
"""Der eigentliche Dienst: Zeitplan ueberwachen und Gruppen ausfuehren."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import errno
|
||||
import fcntl
|
||||
import logging
|
||||
import os
|
||||
import signal
|
||||
import threading
|
||||
import time
|
||||
from datetime import datetime
|
||||
|
||||
from .config import ConfigError, load_config
|
||||
from .engine import run_group
|
||||
from .proxmox import Proxmox, ProxmoxError
|
||||
from .schedule import next_due
|
||||
from .state import State
|
||||
|
||||
log = logging.getLogger("pvesnap.daemon")
|
||||
|
||||
|
||||
class SingleInstanceLock:
|
||||
"""Dateisperre.
|
||||
|
||||
Zwei Sperren sind im Spiel:
|
||||
* <lock_file>.daemon haelt der Dienst waehrend seiner gesamten Laufzeit,
|
||||
damit er nicht doppelt startet.
|
||||
* <lock_file> wird nur waehrend der eigentlichen Snapshot-Arbeit
|
||||
gehalten - so kann man jederzeit auch von Hand `pvesnap run` aufrufen,
|
||||
ohne dass sich die Laeufe in die Quere kommen.
|
||||
"""
|
||||
|
||||
def __init__(self, path, wait=0, busy_message=None):
|
||||
self.path = path
|
||||
self.wait = wait
|
||||
self.busy_message = busy_message or "pvesnap laeuft bereits (Sperrdatei %s)" % path
|
||||
self._handle = None
|
||||
|
||||
def __enter__(self):
|
||||
# Die Datei anzulegen muss sofort klappen - fehlende Rechte sind ein
|
||||
# harter Fehler und kein "gerade belegt".
|
||||
try:
|
||||
os.makedirs(os.path.dirname(os.path.abspath(self.path)), exist_ok=True)
|
||||
self._handle = open(self.path, "w")
|
||||
except OSError as exc:
|
||||
self._handle = None
|
||||
raise RuntimeError("Sperrdatei %s nicht nutzbar: %s" % (self.path, exc))
|
||||
|
||||
deadline = time.monotonic() + max(0, self.wait)
|
||||
while True:
|
||||
try:
|
||||
fcntl.flock(self._handle, fcntl.LOCK_EX | fcntl.LOCK_NB)
|
||||
self._handle.write("%d\n" % os.getpid())
|
||||
self._handle.flush()
|
||||
return self
|
||||
except OSError as exc:
|
||||
busy = exc.errno in (errno.EAGAIN, errno.EWOULDBLOCK, errno.EACCES)
|
||||
if not busy or time.monotonic() >= deadline:
|
||||
self._handle.close()
|
||||
self._handle = None
|
||||
if busy:
|
||||
raise RuntimeError(self.busy_message)
|
||||
raise RuntimeError("Sperrdatei %s nicht nutzbar: %s" % (self.path, exc))
|
||||
time.sleep(1.0)
|
||||
|
||||
def __exit__(self, *_exc):
|
||||
if self._handle:
|
||||
try:
|
||||
fcntl.flock(self._handle, fcntl.LOCK_UN)
|
||||
except OSError:
|
||||
pass
|
||||
self._handle.close()
|
||||
self._handle = None
|
||||
return False
|
||||
|
||||
|
||||
class Daemon:
|
||||
def __init__(self, config_path, dry_run=False):
|
||||
self.config_path = config_path
|
||||
self.dry_run_override = dry_run
|
||||
self.config = None
|
||||
self.state = None
|
||||
self._stop = threading.Event()
|
||||
self._reload = threading.Event()
|
||||
self._wake = threading.Event() # bricht das Warten bei Signalen ab
|
||||
|
||||
# -- Signale ----------------------------------------------------------
|
||||
|
||||
def install_signal_handlers(self):
|
||||
signal.signal(signal.SIGTERM, self._on_stop)
|
||||
signal.signal(signal.SIGINT, self._on_stop)
|
||||
signal.signal(signal.SIGHUP, self._on_reload)
|
||||
|
||||
def _on_stop(self, signum, _frame):
|
||||
log.info("Signal %s empfangen - beende nach dem aktuellen Durchlauf", signum)
|
||||
self._stop.set()
|
||||
self._wake.set()
|
||||
|
||||
def _on_reload(self, _signum, _frame):
|
||||
log.info("SIGHUP empfangen - Konfiguration wird neu geladen")
|
||||
self._reload.set()
|
||||
self._wake.set()
|
||||
|
||||
# -- Konfiguration ----------------------------------------------------
|
||||
|
||||
def load(self):
|
||||
config = load_config(self.config_path)
|
||||
problems = config.validate()
|
||||
if problems:
|
||||
raise ConfigError("Konfiguration fehlerhaft:\n - %s" % "\n - ".join(problems))
|
||||
if self.dry_run_override:
|
||||
config.globals.dry_run = True
|
||||
self.config = config
|
||||
if self.state is None or self.state.path != config.globals.state_file:
|
||||
self.state = State(config.globals.state_file).load()
|
||||
return config
|
||||
|
||||
def _reload_if_requested(self):
|
||||
if not self._reload.is_set():
|
||||
return
|
||||
self._reload.clear()
|
||||
try:
|
||||
self.load()
|
||||
log.info("Konfiguration neu geladen: %d Gruppe(n)", len(self.config.groups))
|
||||
except ConfigError as exc:
|
||||
log.error("Neuladen fehlgeschlagen, behalte alte Konfiguration: %s", exc)
|
||||
|
||||
# -- Hauptschleife ----------------------------------------------------
|
||||
|
||||
def run(self):
|
||||
self.load()
|
||||
self.install_signal_handlers()
|
||||
|
||||
globals_ = self.config.globals
|
||||
log.info("pvesnap gestartet (%d Gruppe(n), Praefix '%s'%s)",
|
||||
len(self.config.groups), globals_.prefix,
|
||||
", TESTLAUF" if globals_.dry_run else "")
|
||||
|
||||
daemon_lock = SingleInstanceLock(
|
||||
globals_.lock_file + ".daemon",
|
||||
busy_message="Der pvesnap-Dienst laeuft bereits (%s.daemon)" % globals_.lock_file)
|
||||
with daemon_lock:
|
||||
while not self._stop.is_set():
|
||||
self._wake.clear()
|
||||
self._reload_if_requested()
|
||||
try:
|
||||
self.tick()
|
||||
except ProxmoxError as exc:
|
||||
log.error("Proxmox nicht erreichbar: %s", exc)
|
||||
except Exception: # pragma: no cover - Dienst darf nie sterben
|
||||
log.exception("Unerwarteter Fehler im Durchlauf")
|
||||
self._sleep()
|
||||
|
||||
if self.state:
|
||||
self.state.save()
|
||||
log.info("pvesnap beendet")
|
||||
|
||||
def tick(self, now=None):
|
||||
"""Einmal alle Gruppen pruefen und faellige ausfuehren."""
|
||||
now = now or datetime.now()
|
||||
config = self.config
|
||||
state = self.state
|
||||
state.prune_unknown([g.name for g in config.groups])
|
||||
|
||||
due = []
|
||||
for group in config.groups:
|
||||
if not group.enabled:
|
||||
continue
|
||||
last = state.last_run(group.name)
|
||||
if last is None and not config.globals.run_on_start:
|
||||
# Erster Start: nicht sofort feuern, sondern auf den naechsten
|
||||
# regulaeren Termin warten.
|
||||
state.record_run(group.name, now, created=0, deleted=0)
|
||||
log.info("Gruppe '%s': erster Termin am %s", group.name,
|
||||
next_due(group, now, now).strftime("%Y-%m-%d %H:%M:%S"))
|
||||
continue
|
||||
if last is None or next_due(group, last, now) <= now:
|
||||
due.append(group)
|
||||
|
||||
if not due:
|
||||
state.save()
|
||||
return []
|
||||
|
||||
proxmox = Proxmox(dry_run=config.globals.dry_run,
|
||||
task_timeout=config.globals.task_timeout)
|
||||
|
||||
results = []
|
||||
# Die Arbeitssperre wird nur waehrend des Laufs gehalten, damit
|
||||
# `pvesnap run` von Hand weiterhin moeglich bleibt.
|
||||
work_lock = SingleInstanceLock(
|
||||
config.globals.lock_file, wait=300,
|
||||
busy_message="Ein anderer pvesnap-Lauf ist noch aktiv - "
|
||||
"dieser Durchlauf wird uebersprungen")
|
||||
try:
|
||||
with work_lock:
|
||||
guests = proxmox.inventory(refresh=True)
|
||||
for group in due:
|
||||
if self._stop.is_set():
|
||||
break
|
||||
result = run_group(proxmox, config, group, now=datetime.now(),
|
||||
guests=guests)
|
||||
state.record_run(group.name, datetime.now(),
|
||||
created=len(result.created),
|
||||
deleted=len(result.deleted), errors=result.errors)
|
||||
results.append(result)
|
||||
except RuntimeError as exc:
|
||||
log.warning("%s", exc)
|
||||
|
||||
state.save()
|
||||
return results
|
||||
|
||||
def _sleep(self):
|
||||
"""Bis zum naechsten Termin schlafen, hoechstens aber check_interval."""
|
||||
interval = self.config.globals.check_interval
|
||||
now = datetime.now()
|
||||
wait = float(interval)
|
||||
for group in self.config.groups:
|
||||
if not group.enabled:
|
||||
continue
|
||||
last = self.state.last_run(group.name)
|
||||
if last is None:
|
||||
continue
|
||||
try:
|
||||
remaining = (next_due(group, last, now) - now).total_seconds()
|
||||
except ValueError:
|
||||
continue
|
||||
wait = min(wait, max(1.0, remaining))
|
||||
# Auf Signale reagieren wir sofort - das Event bricht das Warten ab.
|
||||
# Geleert wird es am Anfang des Schleifendurchlaufs, damit ein Signal
|
||||
# waehrend tick() nicht verloren geht.
|
||||
self._wake.wait(max(1.0, min(wait, float(interval))))
|
||||
@@ -0,0 +1,181 @@
|
||||
"""Kernlogik: Gaeste auswaehlen, Snapshots anlegen, alte Snapshots aufraeumen."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import fnmatch
|
||||
import logging
|
||||
from dataclasses import dataclass, field
|
||||
from datetime import datetime
|
||||
|
||||
from .naming import build_name, effective_slug, parse_name, render_description
|
||||
from .proxmox import ProxmoxError
|
||||
|
||||
log = logging.getLogger("pvesnap.engine")
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Auswahl der Gaeste
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
def _matches_any_glob(text, patterns):
|
||||
lowered = (text or "").lower()
|
||||
return any(fnmatch.fnmatch(lowered, pattern.lower()) for pattern in patterns)
|
||||
|
||||
|
||||
def select_guests(group, guests):
|
||||
"""Alle Gaeste, auf die die Auswahlregeln der Gruppe zutreffen."""
|
||||
wanted_vmids = set(group.vmids)
|
||||
wanted_tags = set(group.tags)
|
||||
wanted_pools = set(p.lower() for p in group.pools)
|
||||
|
||||
excluded_vmids = set(group.exclude_vmids)
|
||||
excluded_tags = set(group.exclude_tags)
|
||||
|
||||
selected = []
|
||||
for guest in guests:
|
||||
if group.types and guest.type not in group.types:
|
||||
continue
|
||||
|
||||
if group.all:
|
||||
hit = True
|
||||
else:
|
||||
hit = (guest.vmid in wanted_vmids
|
||||
or (group.names and _matches_any_glob(guest.name, group.names))
|
||||
or (wanted_tags and wanted_tags.intersection(guest.tags))
|
||||
or (wanted_pools and guest.pool.lower() in wanted_pools))
|
||||
if not hit:
|
||||
continue
|
||||
|
||||
if guest.vmid in excluded_vmids:
|
||||
continue
|
||||
if group.exclude_names and _matches_any_glob(guest.name, group.exclude_names):
|
||||
continue
|
||||
if excluded_tags and excluded_tags.intersection(guest.tags):
|
||||
continue
|
||||
|
||||
selected.append(guest)
|
||||
return selected
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Vorhaltezeit
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
def managed_snapshots(prefix, group, snapshots):
|
||||
"""Nur die Snapshots, die pvesnap fuer *diese* Gruppe angelegt hat."""
|
||||
slug = effective_slug(prefix, group.slug)
|
||||
result = []
|
||||
for snap in snapshots:
|
||||
parsed = parse_name(prefix, snap.name)
|
||||
if not parsed or parsed["slug"] != slug:
|
||||
continue
|
||||
created = (datetime.fromtimestamp(snap.snaptime) if snap.snaptime
|
||||
else parsed["created"])
|
||||
result.append((snap, created))
|
||||
result.sort(key=lambda item: item[1], reverse=True) # neueste zuerst
|
||||
return result
|
||||
|
||||
|
||||
def plan_prune(prefix, group, snapshots, now):
|
||||
"""Welche Snapshots sollen weg? Gibt eine Liste von (Snapshot, Grund) zurueck."""
|
||||
doomed = []
|
||||
for index, (snap, created) in enumerate(managed_snapshots(prefix, group, snapshots)):
|
||||
if index < group.keep_min:
|
||||
continue
|
||||
age = (now - created).total_seconds()
|
||||
if group.keep_count > 0 and index >= group.keep_count:
|
||||
doomed.append((snap, "Anzahl > %d" % group.keep_count))
|
||||
elif group.keep_time > 0 and age > group.keep_time:
|
||||
doomed.append((snap, "aelter als Vorhaltezeit"))
|
||||
return doomed
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Ausfuehrung
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
@dataclass
|
||||
class GroupResult:
|
||||
group: str
|
||||
matched: int = 0
|
||||
created: list = field(default_factory=list)
|
||||
deleted: list = field(default_factory=list)
|
||||
skipped: list = field(default_factory=list)
|
||||
errors: list = field(default_factory=list)
|
||||
|
||||
@property
|
||||
def ok(self):
|
||||
return not self.errors
|
||||
|
||||
def summary(self):
|
||||
return ("Gruppe '%s': %d Gast/Gaeste, %d Snapshot(s) angelegt, "
|
||||
"%d geloescht, %d Fehler"
|
||||
% (self.group, self.matched, len(self.created),
|
||||
len(self.deleted), len(self.errors)))
|
||||
|
||||
|
||||
def run_group(proxmox, config, group, now=None, create=True, prune=True, guests=None):
|
||||
"""Legt fuer eine Gruppe Snapshots an und raeumt alte weg."""
|
||||
now = now or datetime.now()
|
||||
prefix = config.globals.prefix
|
||||
result = GroupResult(group=group.name)
|
||||
|
||||
if guests is None:
|
||||
guests = proxmox.inventory()
|
||||
selected = select_guests(group, guests)
|
||||
result.matched = len(selected)
|
||||
|
||||
if not selected:
|
||||
log.warning("Gruppe '%s': keine passenden Gaeste gefunden", group.name)
|
||||
return result
|
||||
|
||||
snapshot_name = build_name(prefix, group.slug, now)
|
||||
template = group.description or config.globals.description
|
||||
|
||||
for guest in selected:
|
||||
if group.skip_stopped and not guest.running:
|
||||
result.skipped.append("%s (gestoppt)" % guest.label)
|
||||
log.info("Gruppe '%s': %s uebersprungen (gestoppt)", group.name, guest.label)
|
||||
continue
|
||||
|
||||
if create:
|
||||
description = render_description(template, group, guest, now, prefix)
|
||||
try:
|
||||
proxmox.create_snapshot(
|
||||
guest, snapshot_name, description,
|
||||
vmstate=group.vmstate and guest.running,
|
||||
)
|
||||
result.created.append("%s:%s" % (guest.vmid, snapshot_name))
|
||||
log.info("Gruppe '%s': Snapshot '%s' fuer %s angelegt",
|
||||
group.name, snapshot_name, guest.label)
|
||||
except ProxmoxError as exc:
|
||||
message = "%s: Snapshot fehlgeschlagen: %s" % (guest.label, exc)
|
||||
result.errors.append(message)
|
||||
log.error("Gruppe '%s': %s", group.name, message)
|
||||
continue # ohne neuen Snapshot nicht aufraeumen
|
||||
|
||||
if prune:
|
||||
try:
|
||||
_prune_guest(proxmox, config, group, guest, now, result)
|
||||
except ProxmoxError as exc:
|
||||
message = "%s: Aufraeumen fehlgeschlagen: %s" % (guest.label, exc)
|
||||
result.errors.append(message)
|
||||
log.error("Gruppe '%s': %s", group.name, message)
|
||||
|
||||
log.info(result.summary())
|
||||
return result
|
||||
|
||||
|
||||
def _prune_guest(proxmox, config, group, guest, now, result):
|
||||
prefix = config.globals.prefix
|
||||
snapshots = proxmox.list_snapshots(guest)
|
||||
for snap, reason in plan_prune(prefix, group, snapshots, now):
|
||||
try:
|
||||
proxmox.delete_snapshot(guest, snap.name)
|
||||
result.deleted.append("%s:%s" % (guest.vmid, snap.name))
|
||||
log.info("Gruppe '%s': Snapshot '%s' von %s geloescht (%s)",
|
||||
group.name, snap.name, guest.label, reason)
|
||||
except ProxmoxError as exc:
|
||||
message = "%s: '%s' nicht loeschbar: %s" % (guest.label, snap.name, exc)
|
||||
result.errors.append(message)
|
||||
log.error("Gruppe '%s': %s", group.name, message)
|
||||
@@ -0,0 +1,88 @@
|
||||
"""Namensschema der von pvesnap verwalteten Snapshots.
|
||||
|
||||
Ein Name sieht so aus: auto-taeglich-20260730-023000
|
||||
^^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^
|
||||
| | Datum Uhrzeit
|
||||
| Kurzname der Gruppe
|
||||
Praefix aus [global]
|
||||
|
||||
Nur Snapshots, die exakt auf dieses Muster passen, werden von pvesnap
|
||||
angefasst. Von Hand angelegte Snapshots bleiben damit garantiert unberuehrt.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import re
|
||||
from datetime import datetime
|
||||
|
||||
# Proxmox erlaubt fuer Snapshot-Namen nur begrenzte Laenge - wir bleiben
|
||||
# bewusst deutlich darunter.
|
||||
MAX_NAME_LEN = 40
|
||||
_STAMP_LEN = len("-20260730-023000")
|
||||
|
||||
|
||||
def max_slug_len(prefix):
|
||||
return max(1, MAX_NAME_LEN - len(prefix) - _STAMP_LEN)
|
||||
|
||||
|
||||
def effective_slug(prefix, slug):
|
||||
"""Der Kurzname, wie er tatsaechlich im Snapshot-Namen landet."""
|
||||
return slug[: max_slug_len(prefix)]
|
||||
|
||||
|
||||
def build_name(prefix, slug, moment):
|
||||
return "%s-%s-%s" % (prefix, effective_slug(prefix, slug),
|
||||
moment.strftime("%Y%m%d-%H%M%S"))
|
||||
|
||||
|
||||
def name_pattern(prefix, slug=None):
|
||||
part = re.escape(effective_slug(prefix, slug)) if slug else r"[A-Za-z0-9]+"
|
||||
return re.compile(r"^%s-(%s)-(\d{8})-(\d{6})$" % (re.escape(prefix), part))
|
||||
|
||||
|
||||
def parse_name(prefix, name):
|
||||
"""Zerlegt einen Snapshot-Namen; gibt None zurueck, wenn er nicht zu uns gehoert."""
|
||||
match = name_pattern(prefix).match(str(name))
|
||||
if not match:
|
||||
return None
|
||||
slug, date_part, time_part = match.groups()
|
||||
try:
|
||||
created = datetime.strptime(date_part + time_part, "%Y%m%d%H%M%S")
|
||||
except ValueError:
|
||||
return None
|
||||
return {"slug": slug, "created": created}
|
||||
|
||||
|
||||
def render_description(template, group, guest, moment, prefix):
|
||||
"""Setzt die Platzhalter der Beschreibungs-Vorlage ein."""
|
||||
from .util import format_duration # lokal, um Zyklen zu vermeiden
|
||||
|
||||
values = {
|
||||
"prefix": prefix,
|
||||
"group": group.name,
|
||||
"group_slug": group.slug,
|
||||
"vmid": guest.vmid,
|
||||
"name": guest.name or "",
|
||||
"type": "LXC" if guest.type == "lxc" else "VM",
|
||||
"node": guest.node or "",
|
||||
"pool": guest.pool or "",
|
||||
"tags": ",".join(guest.tags),
|
||||
"date": moment.strftime("%Y-%m-%d"),
|
||||
"time": moment.strftime("%H:%M:%S"),
|
||||
"datetime": moment.strftime("%Y-%m-%d %H:%M:%S"),
|
||||
"timestamp": int(moment.timestamp()),
|
||||
"keep_time": format_duration(group.keep_time),
|
||||
"keep_count": group.keep_count if group.keep_count else "unbegrenzt",
|
||||
"schedule": _schedule_text(group),
|
||||
}
|
||||
try:
|
||||
text = str(template).format(**values)
|
||||
except (KeyError, IndexError, ValueError):
|
||||
# Unbekannter Platzhalter: lieber eine brauchbare Beschreibung als ein Abbruch.
|
||||
text = "pvesnap | Gruppe: %s | erstellt: %s" % (group.name, values["datetime"])
|
||||
return text.strip()[:1024]
|
||||
|
||||
|
||||
def _schedule_text(group):
|
||||
from .schedule import describe
|
||||
return describe(group)
|
||||
@@ -0,0 +1,202 @@
|
||||
"""Duenne Schicht um `pvesh` - Inventar lesen, Snapshots anlegen/loeschen.
|
||||
|
||||
Bewusst ueber `pvesh` statt `qm`/`pct`: damit funktioniert alles auch fuer
|
||||
Gaeste, die auf einem anderen Node des Clusters laufen.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import logging
|
||||
import shutil
|
||||
import subprocess
|
||||
import time
|
||||
from dataclasses import dataclass, field
|
||||
|
||||
log = logging.getLogger("pvesnap.proxmox")
|
||||
|
||||
PVESH = "/usr/bin/pvesh"
|
||||
|
||||
|
||||
class ProxmoxError(Exception):
|
||||
"""Ein pvesh-Aufruf ist fehlgeschlagen."""
|
||||
|
||||
|
||||
@dataclass
|
||||
class Guest:
|
||||
vmid: int
|
||||
name: str = ""
|
||||
type: str = "qemu" # qemu | lxc
|
||||
node: str = ""
|
||||
status: str = "unknown"
|
||||
tags: list = field(default_factory=list)
|
||||
pool: str = ""
|
||||
|
||||
@property
|
||||
def running(self):
|
||||
return self.status == "running"
|
||||
|
||||
@property
|
||||
def label(self):
|
||||
return "%s %d (%s)" % ("LXC" if self.type == "lxc" else "VM",
|
||||
self.vmid, self.name or "?")
|
||||
|
||||
|
||||
@dataclass
|
||||
class Snapshot:
|
||||
name: str
|
||||
description: str = ""
|
||||
snaptime: int = 0
|
||||
parent: str = ""
|
||||
|
||||
|
||||
def pvesh_available():
|
||||
return shutil.which(PVESH) is not None or shutil.which("pvesh") is not None
|
||||
|
||||
|
||||
def _pvesh_binary():
|
||||
return shutil.which(PVESH) or shutil.which("pvesh") or PVESH
|
||||
|
||||
|
||||
class Proxmox:
|
||||
"""Zugriff auf die Proxmox-API ueber das Kommando `pvesh`."""
|
||||
|
||||
def __init__(self, dry_run=False, task_timeout=900, command_timeout=60):
|
||||
self.dry_run = dry_run
|
||||
self.task_timeout = task_timeout
|
||||
self.command_timeout = command_timeout
|
||||
self._inventory_cache = None
|
||||
|
||||
# -- unterste Ebene ---------------------------------------------------
|
||||
|
||||
def _run(self, args, timeout=None):
|
||||
command = [_pvesh_binary()] + args
|
||||
log.debug("pvesh: %s", " ".join(command))
|
||||
try:
|
||||
proc = subprocess.run(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
|
||||
timeout=timeout or self.command_timeout)
|
||||
except FileNotFoundError:
|
||||
raise ProxmoxError("'pvesh' nicht gefunden - laeuft pvesnap wirklich "
|
||||
"auf einem Proxmox-VE-Host?")
|
||||
except subprocess.TimeoutExpired:
|
||||
raise ProxmoxError("Zeitueberschreitung bei: %s" % " ".join(command))
|
||||
|
||||
stdout = proc.stdout.decode("utf-8", "replace").strip()
|
||||
stderr = proc.stderr.decode("utf-8", "replace").strip()
|
||||
if proc.returncode != 0:
|
||||
raise ProxmoxError((stderr or stdout or "unbekannter Fehler").splitlines()[0])
|
||||
return stdout, stderr
|
||||
|
||||
def _json(self, args):
|
||||
stdout, _ = self._run(args + ["--output-format", "json"])
|
||||
if not stdout:
|
||||
return None
|
||||
try:
|
||||
return json.loads(stdout)
|
||||
except ValueError:
|
||||
raise ProxmoxError("unerwartete Antwort von pvesh: %s" % stdout[:200])
|
||||
|
||||
# -- Inventar ---------------------------------------------------------
|
||||
|
||||
def inventory(self, refresh=False):
|
||||
"""Alle VMs und Container des Clusters."""
|
||||
if self._inventory_cache is not None and not refresh:
|
||||
return self._inventory_cache
|
||||
|
||||
data = self._json(["get", "/cluster/resources", "--type", "vm"]) or []
|
||||
guests = []
|
||||
for entry in data:
|
||||
if entry.get("type") not in ("qemu", "lxc"):
|
||||
continue
|
||||
raw_tags = entry.get("tags") or ""
|
||||
tags = [t.strip().lower() for t in str(raw_tags).replace(",", ";").split(";")
|
||||
if t.strip()]
|
||||
guests.append(Guest(
|
||||
vmid=int(entry.get("vmid")),
|
||||
name=entry.get("name") or "",
|
||||
type=entry.get("type"),
|
||||
node=entry.get("node") or "",
|
||||
status=entry.get("status") or "unknown",
|
||||
tags=tags,
|
||||
pool=entry.get("pool") or "",
|
||||
))
|
||||
guests.sort(key=lambda g: g.vmid)
|
||||
self._inventory_cache = guests
|
||||
return guests
|
||||
|
||||
@staticmethod
|
||||
def local_node():
|
||||
import socket
|
||||
return socket.gethostname().split(".")[0]
|
||||
|
||||
# -- Snapshots --------------------------------------------------------
|
||||
|
||||
def _base_path(self, guest):
|
||||
return "/nodes/%s/%s/%d/snapshot" % (guest.node, guest.type, guest.vmid)
|
||||
|
||||
def list_snapshots(self, guest):
|
||||
data = self._json(["get", self._base_path(guest)]) or []
|
||||
result = []
|
||||
for entry in data:
|
||||
name = entry.get("name")
|
||||
if not name or name == "current":
|
||||
continue # "current" ist kein echter Snapshot
|
||||
result.append(Snapshot(
|
||||
name=name,
|
||||
description=(entry.get("description") or "").strip(),
|
||||
snaptime=int(entry.get("snaptime") or 0),
|
||||
parent=entry.get("parent") or "",
|
||||
))
|
||||
result.sort(key=lambda s: s.snaptime)
|
||||
return result
|
||||
|
||||
def create_snapshot(self, guest, name, description="", vmstate=False):
|
||||
args = ["create", self._base_path(guest), "--snapname", name]
|
||||
if description:
|
||||
args += ["--description", description]
|
||||
if vmstate and guest.type == "qemu":
|
||||
args += ["--vmstate", "1"]
|
||||
if self.dry_run:
|
||||
log.info("[TESTLAUF] wuerde Snapshot anlegen: %s -> %s", guest.label, name)
|
||||
return None
|
||||
stdout, _ = self._run(args)
|
||||
return self._wait_task(guest.node, stdout, "Snapshot %s fuer %s" % (name, guest.label))
|
||||
|
||||
def delete_snapshot(self, guest, name):
|
||||
if self.dry_run:
|
||||
log.info("[TESTLAUF] wuerde Snapshot loeschen: %s -> %s", guest.label, name)
|
||||
return None
|
||||
stdout, _ = self._run(["delete", "%s/%s" % (self._base_path(guest), name)])
|
||||
return self._wait_task(guest.node, stdout,
|
||||
"Loeschen von %s bei %s" % (name, guest.label))
|
||||
|
||||
# -- Task-Verfolgung --------------------------------------------------
|
||||
|
||||
def _wait_task(self, node, output, what):
|
||||
"""pvesh liefert bei Snapshot-Aktionen eine UPID; darauf warten wir."""
|
||||
upid = self._extract_upid(output)
|
||||
if not upid:
|
||||
return None
|
||||
|
||||
deadline = time.time() + self.task_timeout
|
||||
delay = 0.5
|
||||
while True:
|
||||
status = self._json(["get", "/nodes/%s/tasks/%s/status" % (node, upid)]) or {}
|
||||
if status.get("status") == "stopped":
|
||||
exit_status = status.get("exitstatus") or "unbekannt"
|
||||
if exit_status != "OK":
|
||||
raise ProxmoxError("%s fehlgeschlagen: %s" % (what, exit_status))
|
||||
return upid
|
||||
if time.time() > deadline:
|
||||
raise ProxmoxError("%s: Zeitueberschreitung nach %ds (Task laeuft weiter: %s)"
|
||||
% (what, self.task_timeout, upid))
|
||||
time.sleep(delay)
|
||||
delay = min(delay * 1.5, 5.0)
|
||||
|
||||
@staticmethod
|
||||
def _extract_upid(output):
|
||||
for line in (output or "").splitlines():
|
||||
candidate = line.strip().strip('"')
|
||||
if candidate.startswith("UPID:"):
|
||||
return candidate
|
||||
return None
|
||||
@@ -0,0 +1,133 @@
|
||||
"""Berechnung der naechsten Ausfuehrungszeit einer Gruppe (lokale Zeit)."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import calendar
|
||||
from datetime import datetime, timedelta
|
||||
|
||||
from .config import WEEKDAY_NAMES, parse_time_of_day
|
||||
from .util import format_duration
|
||||
|
||||
_EPOCH = datetime(1970, 1, 1)
|
||||
|
||||
|
||||
def _midnight(moment):
|
||||
return moment.replace(hour=0, minute=0, second=0, microsecond=0)
|
||||
|
||||
|
||||
def _aligned_after(moment, interval):
|
||||
"""Naechster an der Uhr ausgerichteter Zeitpunkt nach `moment`.
|
||||
|
||||
Intervalle, die glatt in einen Tag passen (5m, 15m, 1h, 6h, 12h), werden an
|
||||
Mitternacht verankert - 6h ergibt also 00:00, 06:00, 12:00, 18:00.
|
||||
Alles andere wird an der Epoche verankert.
|
||||
"""
|
||||
if interval <= 86400 and 86400 % interval == 0:
|
||||
anchor = _midnight(moment)
|
||||
else:
|
||||
anchor = _EPOCH
|
||||
elapsed = (moment - anchor).total_seconds()
|
||||
steps = int(elapsed // interval) + 1
|
||||
return anchor + timedelta(seconds=steps * interval)
|
||||
|
||||
|
||||
def _at_time(day, hour, minute):
|
||||
return day.replace(hour=hour, minute=minute, second=0, microsecond=0)
|
||||
|
||||
|
||||
def _clamp_day(year, month, day):
|
||||
return min(day, calendar.monthrange(year, month)[1])
|
||||
|
||||
|
||||
def next_due(group, last_run, now):
|
||||
"""Wann ist die Gruppe das naechste Mal faellig?
|
||||
|
||||
`last_run` ist der letzte tatsaechliche Lauf (oder None). Liegt das
|
||||
Ergebnis in der Vergangenheit, ist die Gruppe sofort faellig - so werden
|
||||
Laeufe nachgeholt, die waehrend eines Neustarts ausgefallen sind.
|
||||
"""
|
||||
if group.interval > 0:
|
||||
if last_run is None:
|
||||
base = now
|
||||
else:
|
||||
base = last_run
|
||||
if group.align:
|
||||
return _aligned_after(base, group.interval)
|
||||
return base + timedelta(seconds=group.interval)
|
||||
|
||||
base = last_run if last_run is not None else now - timedelta(seconds=1)
|
||||
kind = group.schedule
|
||||
|
||||
if kind == "hourly":
|
||||
minute = max(0, min(59, group.minute))
|
||||
candidate = base.replace(minute=minute, second=0, microsecond=0)
|
||||
while candidate <= base:
|
||||
candidate += timedelta(hours=1)
|
||||
return candidate
|
||||
|
||||
hour, minute = parse_time_of_day(group.at)
|
||||
|
||||
if kind == "daily":
|
||||
candidate = _at_time(base, hour, minute)
|
||||
while candidate <= base:
|
||||
candidate += timedelta(days=1)
|
||||
return candidate
|
||||
|
||||
if kind == "weekly":
|
||||
candidate = _at_time(base, hour, minute)
|
||||
shift = (group.day_of_week - candidate.weekday()) % 7
|
||||
candidate += timedelta(days=shift)
|
||||
while candidate <= base:
|
||||
candidate += timedelta(days=7)
|
||||
return candidate
|
||||
|
||||
if kind == "monthly":
|
||||
year, month = base.year, base.month
|
||||
for _ in range(60):
|
||||
day = _clamp_day(year, month, group.day_of_month)
|
||||
candidate = _at_time(datetime(year, month, day), hour, minute)
|
||||
if candidate > base:
|
||||
return candidate
|
||||
month += 1
|
||||
if month > 12:
|
||||
month, year = 1, year + 1
|
||||
raise ValueError("kein monatlicher Termin ermittelbar")
|
||||
|
||||
if kind == "yearly":
|
||||
year = base.year
|
||||
month = max(1, min(12, group.month))
|
||||
for _ in range(5):
|
||||
day = _clamp_day(year, month, group.day_of_month)
|
||||
candidate = _at_time(datetime(year, month, day), hour, minute)
|
||||
if candidate > base:
|
||||
return candidate
|
||||
year += 1
|
||||
raise ValueError("kein jaehrlicher Termin ermittelbar")
|
||||
|
||||
raise ValueError("unbekannter Zeitplan: %r" % kind)
|
||||
|
||||
|
||||
def is_due(group, last_run, now, run_on_start=False):
|
||||
if not group.enabled:
|
||||
return False
|
||||
if last_run is None and run_on_start:
|
||||
return True
|
||||
return next_due(group, last_run, now) <= now
|
||||
|
||||
|
||||
def describe(group):
|
||||
"""Zeitplan der Gruppe als kurzer, lesbarer Text."""
|
||||
if group.interval > 0:
|
||||
text = "alle %s" % format_duration(group.interval)
|
||||
return text + (" (an der Uhr ausgerichtet)" if group.align else "")
|
||||
if group.schedule == "hourly":
|
||||
return "stuendlich zur Minute %02d" % group.minute
|
||||
if group.schedule == "daily":
|
||||
return "taeglich um %s" % group.at
|
||||
if group.schedule == "weekly":
|
||||
return "woechentlich %s um %s" % (WEEKDAY_NAMES[group.day_of_week], group.at)
|
||||
if group.schedule == "monthly":
|
||||
return "monatlich am %d. um %s" % (group.day_of_month, group.at)
|
||||
if group.schedule == "yearly":
|
||||
return "jaehrlich am %d.%d. um %s" % (group.day_of_month, group.month, group.at)
|
||||
return "kein Zeitplan"
|
||||
@@ -0,0 +1,90 @@
|
||||
"""Persistenter Zustand: wann lief welche Gruppe zuletzt?"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import logging
|
||||
import os
|
||||
from datetime import datetime
|
||||
|
||||
log = logging.getLogger("pvesnap.state")
|
||||
|
||||
_TIME_FORMAT = "%Y-%m-%dT%H:%M:%S"
|
||||
|
||||
|
||||
class State:
|
||||
def __init__(self, path):
|
||||
self.path = path
|
||||
self.data = {"version": 1, "groups": {}}
|
||||
self._dirty = False
|
||||
|
||||
# -- Laden / Speichern ------------------------------------------------
|
||||
|
||||
def load(self):
|
||||
if not os.path.exists(self.path):
|
||||
return self
|
||||
try:
|
||||
with open(self.path, "r", encoding="utf-8") as handle:
|
||||
data = json.load(handle)
|
||||
if isinstance(data, dict) and isinstance(data.get("groups"), dict):
|
||||
self.data = data
|
||||
self.data.setdefault("version", 1)
|
||||
except (OSError, ValueError) as exc:
|
||||
log.warning("Zustandsdatei %s nicht lesbar (%s) - starte mit leerem Zustand",
|
||||
self.path, exc)
|
||||
return self
|
||||
|
||||
def save(self, force=False):
|
||||
if not self._dirty and not force:
|
||||
return
|
||||
directory = os.path.dirname(os.path.abspath(self.path))
|
||||
try:
|
||||
os.makedirs(directory, exist_ok=True)
|
||||
tmp = self.path + ".tmp"
|
||||
with open(tmp, "w", encoding="utf-8") as handle:
|
||||
json.dump(self.data, handle, indent=2, ensure_ascii=False)
|
||||
handle.write("\n")
|
||||
handle.flush()
|
||||
os.fsync(handle.fileno())
|
||||
os.replace(tmp, self.path)
|
||||
self._dirty = False
|
||||
except OSError as exc:
|
||||
log.error("Zustand konnte nicht gespeichert werden (%s): %s", self.path, exc)
|
||||
|
||||
# -- Zugriff ----------------------------------------------------------
|
||||
|
||||
def _entry(self, group_name):
|
||||
return self.data["groups"].setdefault(group_name, {})
|
||||
|
||||
def last_run(self, group_name):
|
||||
raw = self._entry(group_name).get("last_run")
|
||||
if not raw:
|
||||
return None
|
||||
try:
|
||||
return datetime.strptime(raw, _TIME_FORMAT)
|
||||
except ValueError:
|
||||
return None
|
||||
|
||||
def record_run(self, group_name, moment, created=0, deleted=0, errors=None):
|
||||
entry = self._entry(group_name)
|
||||
entry["last_run"] = moment.strftime(_TIME_FORMAT)
|
||||
entry["created"] = created
|
||||
entry["deleted"] = deleted
|
||||
entry["errors"] = list(errors or [])
|
||||
entry["status"] = "error" if errors else "ok"
|
||||
entry["total_runs"] = int(entry.get("total_runs") or 0) + 1
|
||||
self._dirty = True
|
||||
|
||||
def info(self, group_name):
|
||||
return dict(self._entry(group_name))
|
||||
|
||||
def forget(self, group_name):
|
||||
if group_name in self.data["groups"]:
|
||||
del self.data["groups"][group_name]
|
||||
self._dirty = True
|
||||
|
||||
def prune_unknown(self, known_names):
|
||||
known = set(known_names)
|
||||
for name in [n for n in self.data["groups"] if n not in known]:
|
||||
del self.data["groups"][name]
|
||||
self._dirty = True
|
||||
+889
@@ -0,0 +1,889 @@
|
||||
"""ncurses-Editor fuer die pvesnap-Konfiguration.
|
||||
|
||||
Aufruf: pvesnap config
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import curses
|
||||
import os
|
||||
|
||||
from .config import (WEEKDAY_NAMES, Config, ConfigError, Group, clone_group,
|
||||
load_config, parse_time_of_day, save_config)
|
||||
from .naming import effective_slug
|
||||
from .proxmox import Proxmox, ProxmoxError, pvesh_available
|
||||
from .schedule import describe
|
||||
from .util import (format_duration, format_vmid_list, parse_duration,
|
||||
parse_list, parse_vmid_list, truncate)
|
||||
|
||||
SCHEDULE_CHOICES = [
|
||||
("interval", "Intervall (z.B. alle 30 Minuten)"),
|
||||
("hourly", "stuendlich"),
|
||||
("daily", "taeglich"),
|
||||
("weekly", "woechentlich"),
|
||||
("monthly", "monatlich"),
|
||||
("yearly", "jaehrlich"),
|
||||
]
|
||||
|
||||
TYPE_CHOICES = [
|
||||
([], "alle (VMs und Container)"),
|
||||
(["qemu"], "nur VMs (QEMU/KVM)"),
|
||||
(["lxc"], "nur Container (LXC)"),
|
||||
]
|
||||
|
||||
C_HEADER, C_FOOTER, C_SEL, C_WARN, C_OK, C_DIM = 1, 2, 3, 4, 5, 6
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Zeichen-Helfer
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
def _put(win, y, x, text, attr=0):
|
||||
"""addstr, das bei zu kleinem Terminal nicht abstuerzt."""
|
||||
height, width = win.getmaxyx()
|
||||
if y < 0 or y >= height or x >= width:
|
||||
return
|
||||
try:
|
||||
win.addstr(y, x, str(text)[: max(0, width - x - 1)], attr)
|
||||
except curses.error:
|
||||
pass
|
||||
|
||||
|
||||
def _fill(win, y, text, attr):
|
||||
height, width = win.getmaxyx()
|
||||
if y < 0 or y >= height:
|
||||
return
|
||||
try:
|
||||
win.addstr(y, 0, str(text).ljust(width - 1)[: width - 1], attr)
|
||||
except curses.error:
|
||||
pass
|
||||
|
||||
|
||||
def _read_key(win):
|
||||
try:
|
||||
return win.get_wch()
|
||||
except curses.error:
|
||||
return None
|
||||
except KeyboardInterrupt:
|
||||
return "\x1b"
|
||||
|
||||
|
||||
def _is_enter(key):
|
||||
return key in ("\n", "\r", curses.KEY_ENTER)
|
||||
|
||||
|
||||
def _is_escape(key):
|
||||
return key == "\x1b"
|
||||
|
||||
|
||||
def _is_backspace(key):
|
||||
return key in ("\x7f", "\b", "\x08", curses.KEY_BACKSPACE)
|
||||
|
||||
|
||||
class Editor:
|
||||
def __init__(self, path):
|
||||
self.path = path
|
||||
self.config = None
|
||||
self.dirty = False
|
||||
self._guests = None
|
||||
self._inventory_error = ""
|
||||
|
||||
# -- Daten ------------------------------------------------------------
|
||||
|
||||
def load(self):
|
||||
if os.path.exists(self.path):
|
||||
self.config = load_config(self.path)
|
||||
else:
|
||||
self.config = Config(path=self.path)
|
||||
self.dirty = True
|
||||
|
||||
def guests(self, refresh=False):
|
||||
"""Inventar der VMs; wird nur bei Bedarf einmal geholt."""
|
||||
if self._guests is not None and not refresh:
|
||||
return self._guests
|
||||
self._guests = []
|
||||
self._inventory_error = ""
|
||||
if not pvesh_available():
|
||||
self._inventory_error = ("'pvesh' nicht gefunden - VM-Liste nur auf einem "
|
||||
"Proxmox-Host verfuegbar.")
|
||||
return self._guests
|
||||
try:
|
||||
self._guests = Proxmox().inventory(refresh=True)
|
||||
except ProxmoxError as exc:
|
||||
self._inventory_error = str(exc)
|
||||
return self._guests
|
||||
|
||||
# -- Rahmen -----------------------------------------------------------
|
||||
|
||||
def _frame(self, win, title, subtitle, keys):
|
||||
win.erase()
|
||||
height, width = win.getmaxyx()
|
||||
_fill(win, 0, " pvesnap - %s" % title, curses.color_pair(C_HEADER) | curses.A_BOLD)
|
||||
marker = "*" if self.dirty else " "
|
||||
_fill(win, 1, " %s%s" % (marker, subtitle), curses.color_pair(C_DIM))
|
||||
_fill(win, height - 1, " " + keys, curses.color_pair(C_FOOTER))
|
||||
return height, width
|
||||
|
||||
def _message(self, win, text, error=False):
|
||||
height, _ = win.getmaxyx()
|
||||
attr = curses.color_pair(C_WARN if error else C_OK) | curses.A_BOLD
|
||||
_fill(win, height - 2, " " + str(text) + " [Taste druecken]", attr)
|
||||
win.refresh()
|
||||
_read_key(win)
|
||||
|
||||
def _confirm(self, win, question):
|
||||
height, _ = win.getmaxyx()
|
||||
_fill(win, height - 2, " %s [j/n]" % question,
|
||||
curses.color_pair(C_WARN) | curses.A_BOLD)
|
||||
win.refresh()
|
||||
while True:
|
||||
key = _read_key(win)
|
||||
if key in ("j", "J", "y", "Y"):
|
||||
return True
|
||||
if key in ("n", "N") or _is_escape(key):
|
||||
return False
|
||||
|
||||
def _prompt(self, win, label, initial=""):
|
||||
"""Einzeilige Eingabe am unteren Rand. None = abgebrochen."""
|
||||
height, width = win.getmaxyx()
|
||||
buffer = list(str(initial))
|
||||
curses.curs_set(1)
|
||||
try:
|
||||
while True:
|
||||
text = "".join(buffer)
|
||||
prompt = " %s: " % label
|
||||
visible = width - len(prompt) - 2
|
||||
shown = text[-visible:] if visible > 0 and len(text) > visible else text
|
||||
_fill(win, height - 2, prompt + shown, curses.color_pair(C_SEL))
|
||||
try:
|
||||
win.move(height - 2, min(width - 2, len(prompt) + len(shown)))
|
||||
except curses.error:
|
||||
pass
|
||||
win.refresh()
|
||||
|
||||
key = _read_key(win)
|
||||
if key is None:
|
||||
continue
|
||||
if _is_enter(key):
|
||||
return "".join(buffer).strip()
|
||||
if _is_escape(key):
|
||||
return None
|
||||
if _is_backspace(key):
|
||||
if buffer:
|
||||
buffer.pop()
|
||||
continue
|
||||
if key == "\x15": # Strg-U
|
||||
buffer = []
|
||||
continue
|
||||
if isinstance(key, str) and key.isprintable():
|
||||
buffer.append(key)
|
||||
finally:
|
||||
curses.curs_set(0)
|
||||
|
||||
def _choose(self, win, title, entries, current=0):
|
||||
"""Kleines Auswahlfenster. entries: Liste von (wert, beschriftung)."""
|
||||
height, width = win.getmaxyx()
|
||||
box_h = min(len(entries) + 4, height - 2)
|
||||
box_w = min(max([len(title)] + [len(e[1]) for e in entries]) + 8, width - 2)
|
||||
top = max(0, (height - box_h) // 2)
|
||||
left = max(0, (width - box_w) // 2)
|
||||
box = curses.newwin(box_h, box_w, top, left)
|
||||
box.keypad(True)
|
||||
index = max(0, min(current, len(entries) - 1))
|
||||
|
||||
while True:
|
||||
box.erase()
|
||||
box.box()
|
||||
_put(box, 0, 2, " %s " % title, curses.A_BOLD)
|
||||
for row, (_value, label) in enumerate(entries[: box_h - 4]):
|
||||
attr = curses.color_pair(C_SEL) if row == index else 0
|
||||
_put(box, row + 2, 2, " " + label.ljust(box_w - 5), attr)
|
||||
box.refresh()
|
||||
|
||||
key = _read_key(box)
|
||||
if key in (curses.KEY_UP, "k"):
|
||||
index = (index - 1) % len(entries)
|
||||
elif key in (curses.KEY_DOWN, "j"):
|
||||
index = (index + 1) % len(entries)
|
||||
elif _is_enter(key):
|
||||
return entries[index][0]
|
||||
elif _is_escape(key) or key == "q":
|
||||
return None
|
||||
|
||||
# -- Hauptschleife ----------------------------------------------------
|
||||
|
||||
def run(self, stdscr):
|
||||
curses.curs_set(0)
|
||||
if hasattr(curses, "set_escdelay"):
|
||||
curses.set_escdelay(25)
|
||||
try:
|
||||
curses.start_color()
|
||||
curses.use_default_colors()
|
||||
curses.init_pair(C_HEADER, curses.COLOR_WHITE, curses.COLOR_BLUE)
|
||||
curses.init_pair(C_FOOTER, curses.COLOR_BLACK, curses.COLOR_WHITE)
|
||||
curses.init_pair(C_SEL, curses.COLOR_BLACK, curses.COLOR_CYAN)
|
||||
curses.init_pair(C_WARN, curses.COLOR_WHITE, curses.COLOR_RED)
|
||||
curses.init_pair(C_OK, curses.COLOR_BLACK, curses.COLOR_GREEN)
|
||||
curses.init_pair(C_DIM, -1, -1)
|
||||
except curses.error:
|
||||
pass
|
||||
stdscr.keypad(True)
|
||||
self.screen_groups(stdscr)
|
||||
|
||||
# -- Bildschirm: Gruppenliste ----------------------------------------
|
||||
|
||||
def screen_groups(self, win):
|
||||
index = 0
|
||||
while True:
|
||||
groups = self.config.groups
|
||||
index = max(0, min(index, max(0, len(groups) - 1)))
|
||||
height, width = self._frame(
|
||||
win, "Gruppen",
|
||||
"Datei: %s" % self.path,
|
||||
"Enter Bearbeiten | n Neu | c Kopieren | d Loeschen | Leer An/Aus | "
|
||||
"g Global | v VMs | s Speichern | q Ende")
|
||||
|
||||
_put(win, 3, 2, "Gruppe".ljust(18) + "Aktiv " + "Zeitplan".ljust(30)
|
||||
+ "Behalte".ljust(20) + "Auswahl", curses.A_BOLD)
|
||||
_put(win, 4, 2, "-" * max(0, width - 4), curses.color_pair(C_DIM))
|
||||
|
||||
if not groups:
|
||||
_put(win, 6, 4, "Noch keine Gruppe angelegt - mit 'n' eine erste anlegen.")
|
||||
_put(win, 8, 4, "Beispiel: 'stuendlich' alle 1h, 24 Snapshots behalten;")
|
||||
_put(win, 9, 4, " 'taeglich' um 02:30, 14 Tage Vorhaltezeit.")
|
||||
visible = max(1, height - 8)
|
||||
start = max(0, min(index - visible // 2, max(0, len(groups) - visible)))
|
||||
|
||||
for row, group in enumerate(groups[start:start + visible]):
|
||||
position = start + row
|
||||
attr = curses.color_pair(C_SEL) if position == index else 0
|
||||
keep = "%s / %s" % (group.keep_count or "unbegr.",
|
||||
format_duration(group.keep_time))
|
||||
line = ("%s%s%s%s%s"
|
||||
% (truncate(group.name, 17).ljust(18),
|
||||
("ja" if group.enabled else "nein").ljust(7),
|
||||
truncate(describe(group), 29).ljust(30),
|
||||
truncate(keep, 19).ljust(20),
|
||||
truncate(self._selection_text(group), max(4, width - 80))))
|
||||
_fill_row(win, 5 + row, 2, line, width, attr)
|
||||
|
||||
problems = self.config.validate()
|
||||
if problems:
|
||||
_fill(win, height - 2, " %d Hinweis(e) - 'p' zeigt Details"
|
||||
% len(problems), curses.color_pair(C_WARN))
|
||||
|
||||
win.refresh()
|
||||
key = _read_key(win)
|
||||
|
||||
if key in (curses.KEY_UP, "k"):
|
||||
index -= 1
|
||||
elif key in (curses.KEY_DOWN, "j"):
|
||||
index += 1
|
||||
elif key == curses.KEY_HOME:
|
||||
index = 0
|
||||
elif key == curses.KEY_END:
|
||||
index = len(groups) - 1
|
||||
elif _is_enter(key) and groups:
|
||||
self.screen_group(win, groups[index])
|
||||
elif key == "n":
|
||||
self._new_group(win)
|
||||
index = len(self.config.groups) - 1
|
||||
elif key == "c" and groups:
|
||||
name = self._prompt(win, "Name der Kopie", groups[index].name + "-kopie")
|
||||
if name:
|
||||
self.config.groups.append(clone_group(groups[index], name))
|
||||
self.dirty = True
|
||||
elif key == "d" and groups:
|
||||
if self._confirm(win, "Gruppe '%s' wirklich loeschen?" % groups[index].name):
|
||||
del self.config.groups[index]
|
||||
self.dirty = True
|
||||
elif key == " " and groups:
|
||||
groups[index].enabled = not groups[index].enabled
|
||||
self.dirty = True
|
||||
elif key == "g":
|
||||
self.screen_globals(win)
|
||||
elif key == "v":
|
||||
self.screen_overview(win)
|
||||
elif key == "p":
|
||||
self._show_problems(win)
|
||||
elif key == "s":
|
||||
self._save(win)
|
||||
elif key in ("q", "Q") or _is_escape(key):
|
||||
if self.dirty and not self._confirm(win, "Ungespeicherte Aenderungen verwerfen?"):
|
||||
continue
|
||||
return
|
||||
|
||||
def _selection_text(self, group):
|
||||
parts = []
|
||||
if group.all:
|
||||
parts.append("alle VMs")
|
||||
if group.vmids:
|
||||
parts.append("IDs: " + format_vmid_list(group.vmids))
|
||||
if group.names:
|
||||
parts.append("Namen: " + ", ".join(group.names))
|
||||
if group.tags:
|
||||
parts.append("Tags: " + ", ".join(group.tags))
|
||||
if group.pools:
|
||||
parts.append("Pools: " + ", ".join(group.pools))
|
||||
return "; ".join(parts) or "(nichts ausgewaehlt)"
|
||||
|
||||
def _new_group(self, win):
|
||||
name = self._prompt(win, "Name der neuen Gruppe", "")
|
||||
if not name:
|
||||
return
|
||||
if self.config.group(name):
|
||||
self._message(win, "Eine Gruppe mit diesem Namen gibt es bereits.", error=True)
|
||||
return
|
||||
group = Group(name=name, interval=3600, keep_count=24, keep_time=2 * 86400)
|
||||
self.config.groups.append(group)
|
||||
self.dirty = True
|
||||
self.screen_group(win, group)
|
||||
|
||||
def _show_problems(self, win):
|
||||
problems = self.config.validate()
|
||||
height, width = self._frame(win, "Hinweise zur Konfiguration", self.path,
|
||||
"beliebige Taste = zurueck")
|
||||
if not problems:
|
||||
_put(win, 4, 4, "Alles in Ordnung.", curses.color_pair(C_OK))
|
||||
for row, problem in enumerate(problems[: height - 6]):
|
||||
_put(win, 4 + row, 4, truncate("- " + problem, width - 6))
|
||||
win.refresh()
|
||||
_read_key(win)
|
||||
|
||||
def _save(self, win):
|
||||
problems = self.config.validate()
|
||||
if problems:
|
||||
if not self._confirm(win, "%d Hinweis(e) - trotzdem speichern?" % len(problems)):
|
||||
return
|
||||
try:
|
||||
target = save_config(self.config, self.path)
|
||||
self.dirty = False
|
||||
self._message(win, "Gespeichert: %s (systemctl reload pvesnap nicht vergessen)"
|
||||
% target)
|
||||
except OSError as exc:
|
||||
self._message(win, "Speichern fehlgeschlagen: %s" % exc, error=True)
|
||||
|
||||
# -- Bildschirm: eine Gruppe -----------------------------------------
|
||||
|
||||
def screen_group(self, win, group):
|
||||
index = 0
|
||||
top = 0
|
||||
while True:
|
||||
fields = self._group_fields(group)
|
||||
index = max(0, min(index, len(fields) - 1))
|
||||
while fields[index][0] == "-" and index < len(fields) - 1:
|
||||
index += 1
|
||||
|
||||
height, width = self._frame(
|
||||
win, "Gruppe: %s" % group.name,
|
||||
"Kurzname im Snapshot: %s-%s-JJJJMMTT-HHMMSS"
|
||||
% (self.config.globals.prefix,
|
||||
effective_slug(self.config.globals.prefix, group.slug)),
|
||||
"Enter Aendern | Leer Umschalten | v VM-Auswahl | q zurueck")
|
||||
|
||||
visible = height - 5
|
||||
if index < top:
|
||||
top = index
|
||||
if index >= top + visible:
|
||||
top = index - visible + 1
|
||||
|
||||
for row in range(visible):
|
||||
position = top + row
|
||||
if position >= len(fields):
|
||||
break
|
||||
kind, label, value, _handler = fields[position]
|
||||
if kind == "-":
|
||||
_put(win, 3 + row, 2, "-- %s " % label + "-" * max(0, width - len(label) - 8),
|
||||
curses.color_pair(C_DIM) | curses.A_BOLD)
|
||||
continue
|
||||
attr = curses.color_pair(C_SEL) if position == index else 0
|
||||
_fill_row(win, 3 + row, 2,
|
||||
truncate(label, 30).ljust(32) + truncate(value, max(4, width - 40)),
|
||||
width, attr)
|
||||
|
||||
win.refresh()
|
||||
key = _read_key(win)
|
||||
|
||||
if key in (curses.KEY_UP, "k"):
|
||||
index = self._step(fields, index, -1)
|
||||
elif key in (curses.KEY_DOWN, "j"):
|
||||
index = self._step(fields, index, +1)
|
||||
elif key == curses.KEY_NPAGE:
|
||||
index = self._step(fields, min(index + 10, len(fields) - 1), +1, land=True)
|
||||
elif key == curses.KEY_PPAGE:
|
||||
index = self._step(fields, max(index - 10, 0), -1, land=True)
|
||||
elif _is_enter(key) or key == " ":
|
||||
handler = fields[index][3]
|
||||
if handler:
|
||||
handler(win)
|
||||
self.dirty = True
|
||||
elif key == "v":
|
||||
self._pick_vms(win, group)
|
||||
elif key in ("q", "Q") or _is_escape(key):
|
||||
return
|
||||
|
||||
@staticmethod
|
||||
def _step(fields, index, direction, land=False):
|
||||
position = index if land else index + direction
|
||||
while 0 <= position < len(fields) and fields[position][0] == "-":
|
||||
position += direction
|
||||
if position < 0 or position >= len(fields):
|
||||
return index
|
||||
return position
|
||||
|
||||
def _group_fields(self, group):
|
||||
"""Liste von (art, beschriftung, angezeigter_wert, handler)."""
|
||||
fields = []
|
||||
|
||||
def text_field(label, getter, setter, hint=""):
|
||||
def handler(win):
|
||||
value = self._prompt(win, hint or label, getter())
|
||||
if value is not None:
|
||||
setter(value)
|
||||
fields.append(("f", label, getter(), handler))
|
||||
|
||||
def bool_field(label, getter, setter):
|
||||
def handler(_win):
|
||||
setter(not getter())
|
||||
fields.append(("f", label, "ja" if getter() else "nein", handler))
|
||||
|
||||
def int_field(label, getter, setter, zero_text=""):
|
||||
def handler(win):
|
||||
raw = self._prompt(win, label, str(getter()))
|
||||
if raw is None:
|
||||
return
|
||||
try:
|
||||
setter(max(0, int(raw.strip() or 0)))
|
||||
except ValueError:
|
||||
self._message(win, "Bitte eine ganze Zahl eingeben.", error=True)
|
||||
value = getter()
|
||||
fields.append(("f", label, zero_text if (value == 0 and zero_text) else str(value),
|
||||
handler))
|
||||
|
||||
def duration_field(label, getter, setter):
|
||||
def handler(win):
|
||||
raw = self._prompt(win, label + " (z.B. 30m, 6h, 7d, 0=unbegrenzt)",
|
||||
format_duration(getter(), zero="0"))
|
||||
if raw is None:
|
||||
return
|
||||
try:
|
||||
setter(parse_duration(raw, default_unit="m"))
|
||||
except ValueError as exc:
|
||||
self._message(win, str(exc), error=True)
|
||||
fields.append(("f", label, format_duration(getter()), handler))
|
||||
|
||||
def list_field(label, getter, setter, hint=""):
|
||||
def handler(win):
|
||||
raw = self._prompt(win, hint or label, ", ".join(getter()))
|
||||
if raw is not None:
|
||||
setter(parse_list(raw))
|
||||
fields.append(("f", label, ", ".join(getter()) or "-", handler))
|
||||
|
||||
# --- Allgemein ---
|
||||
fields.append(("-", "Allgemein", "", None))
|
||||
|
||||
def set_name(value):
|
||||
if value:
|
||||
group.name = value
|
||||
text_field("Name", lambda: group.name, set_name)
|
||||
bool_field("Aktiv", lambda: group.enabled,
|
||||
lambda v: setattr(group, "enabled", v))
|
||||
|
||||
# --- Zeitplan ---
|
||||
fields.append(("-", "Zeitplan", "", None))
|
||||
|
||||
current_kind = group.schedule or "interval"
|
||||
|
||||
def change_kind(win):
|
||||
values = [c[0] for c in SCHEDULE_CHOICES]
|
||||
chosen = self._choose(win, "Zeitplan", SCHEDULE_CHOICES,
|
||||
values.index(current_kind))
|
||||
if chosen is None:
|
||||
return
|
||||
if chosen == "interval":
|
||||
group.schedule = ""
|
||||
group.interval = group.interval or 3600
|
||||
else:
|
||||
group.schedule = chosen
|
||||
group.interval = 0
|
||||
|
||||
fields.append(("f", "Art des Zeitplans",
|
||||
dict(SCHEDULE_CHOICES)[current_kind], change_kind))
|
||||
|
||||
if current_kind == "interval":
|
||||
duration_field("Intervall", lambda: group.interval,
|
||||
lambda v: setattr(group, "interval", max(60, v)))
|
||||
bool_field("An der Uhr ausrichten", lambda: group.align,
|
||||
lambda v: setattr(group, "align", v))
|
||||
elif current_kind == "hourly":
|
||||
int_field("Minute (0-59)", lambda: group.minute,
|
||||
lambda v: setattr(group, "minute", min(59, v)))
|
||||
else:
|
||||
def set_time(value):
|
||||
try:
|
||||
group.at = "%02d:%02d" % parse_time_of_day(value)
|
||||
except ValueError:
|
||||
pass
|
||||
text_field("Uhrzeit (HH:MM)", lambda: group.at, set_time)
|
||||
if current_kind == "weekly":
|
||||
def change_day(win):
|
||||
entries = [(i, name) for i, name in enumerate(
|
||||
["Montag", "Dienstag", "Mittwoch", "Donnerstag",
|
||||
"Freitag", "Samstag", "Sonntag"])]
|
||||
chosen = self._choose(win, "Wochentag", entries, group.day_of_week)
|
||||
if chosen is not None:
|
||||
group.day_of_week = chosen
|
||||
fields.append(("f", "Wochentag",
|
||||
WEEKDAY_NAMES[group.day_of_week], change_day))
|
||||
if current_kind in ("monthly", "yearly"):
|
||||
int_field("Tag im Monat (1-31)", lambda: group.day_of_month,
|
||||
lambda v: setattr(group, "day_of_month", max(1, min(31, v))))
|
||||
if current_kind == "yearly":
|
||||
int_field("Monat (1-12)", lambda: group.month,
|
||||
lambda v: setattr(group, "month", max(1, min(12, v))))
|
||||
|
||||
fields.append(("f", "Naechster Termin (Vorschau)", _preview_next(group), None))
|
||||
|
||||
# --- Vorhaltezeit ---
|
||||
fields.append(("-", "Vorhaltezeit", "", None))
|
||||
int_field("Anzahl behalten (je VM)", lambda: group.keep_count,
|
||||
lambda v: setattr(group, "keep_count", v), zero_text="unbegrenzt")
|
||||
duration_field("Maximales Alter", lambda: group.keep_time,
|
||||
lambda v: setattr(group, "keep_time", v))
|
||||
int_field("Mindestens behalten", lambda: group.keep_min,
|
||||
lambda v: setattr(group, "keep_min", v), zero_text="0 (keine Untergrenze)")
|
||||
|
||||
# --- Auswahl ---
|
||||
fields.append(("-", "Welche VMs?", "", None))
|
||||
bool_field("Alle VMs/Container", lambda: group.all,
|
||||
lambda v: setattr(group, "all", v))
|
||||
|
||||
fields.append(("f", "VMs aus Liste waehlen ...",
|
||||
format_vmid_list(group.vmids) or "-",
|
||||
lambda win: self._pick_vms(win, group)))
|
||||
list_field("Namensmuster (z.B. web-*)", lambda: group.names,
|
||||
lambda v: setattr(group, "names", v))
|
||||
list_field("Tags", lambda: group.tags,
|
||||
lambda v: setattr(group, "tags", [t.lower() for t in v]))
|
||||
list_field("Pools", lambda: group.pools,
|
||||
lambda v: setattr(group, "pools", v))
|
||||
|
||||
def change_types(win):
|
||||
labels = [(index, text) for index, (_v, text) in enumerate(TYPE_CHOICES)]
|
||||
current = 0
|
||||
for index, (value, _text) in enumerate(TYPE_CHOICES):
|
||||
if sorted(value) == sorted(group.types):
|
||||
current = index
|
||||
chosen = self._choose(win, "Welche Gasttypen?", labels, current)
|
||||
if chosen is not None:
|
||||
group.types = list(TYPE_CHOICES[chosen][0])
|
||||
current_type_text = "alle (VMs und Container)"
|
||||
for value, text in TYPE_CHOICES:
|
||||
if sorted(value) == sorted(group.types):
|
||||
current_type_text = text
|
||||
fields.append(("f", "Gasttypen", current_type_text, change_types))
|
||||
|
||||
def set_exclude_vmids(win):
|
||||
raw = self._prompt(win, "Ausgeschlossene VMIDs (z.B. 900,905-910)",
|
||||
format_vmid_list(group.exclude_vmids))
|
||||
if raw is None:
|
||||
return
|
||||
try:
|
||||
group.exclude_vmids = parse_vmid_list(raw)
|
||||
except ValueError as exc:
|
||||
self._message(win, str(exc), error=True)
|
||||
fields.append(("f", "Ausgeschlossene VMIDs",
|
||||
format_vmid_list(group.exclude_vmids) or "-", set_exclude_vmids))
|
||||
list_field("Ausgeschlossene Namensmuster", lambda: group.exclude_names,
|
||||
lambda v: setattr(group, "exclude_names", v))
|
||||
list_field("Ausgeschlossene Tags", lambda: group.exclude_tags,
|
||||
lambda v: setattr(group, "exclude_tags", [t.lower() for t in v]))
|
||||
|
||||
matched = self._match_count(group)
|
||||
fields.append(("f", "Trifft aktuell zu auf", matched, None))
|
||||
|
||||
# --- Optionen ---
|
||||
fields.append(("-", "Snapshot-Optionen", "", None))
|
||||
bool_field("RAM mitsichern (nur laufende VMs)", lambda: group.vmstate,
|
||||
lambda v: setattr(group, "vmstate", v))
|
||||
bool_field("Gestoppte ueberspringen", lambda: group.skip_stopped,
|
||||
lambda v: setattr(group, "skip_stopped", v))
|
||||
text_field("Beschreibung (Vorlage)",
|
||||
lambda: group.description or self.config.globals.description,
|
||||
lambda v: setattr(group, "description", v),
|
||||
hint="Beschreibung, Platzhalter: {group} {vmid} {name} {datetime} "
|
||||
"{keep_time} {keep_count}")
|
||||
return fields
|
||||
|
||||
def _match_count(self, group):
|
||||
guests = self.guests()
|
||||
if not guests:
|
||||
return self._inventory_error or "unbekannt"
|
||||
from .engine import select_guests
|
||||
selected = select_guests(group, guests)
|
||||
if not selected:
|
||||
return "0 Gaeste"
|
||||
preview = ", ".join("%d" % g.vmid for g in selected[:8])
|
||||
return "%d Gast/Gaeste (%s%s)" % (len(selected), preview,
|
||||
" ..." if len(selected) > 8 else "")
|
||||
|
||||
# -- Bildschirm: VM-Auswahl ------------------------------------------
|
||||
|
||||
def _pick_vms(self, win, group):
|
||||
guests = self.guests()
|
||||
if not guests:
|
||||
self._message(win, self._inventory_error or "Keine VMs gefunden.", error=True)
|
||||
return
|
||||
|
||||
chosen = set(group.vmids)
|
||||
index, top, filter_text = 0, 0, ""
|
||||
|
||||
while True:
|
||||
shown = [g for g in guests if self._matches_filter(g, filter_text)]
|
||||
index = max(0, min(index, max(0, len(shown) - 1)))
|
||||
height, width = self._frame(
|
||||
win, "VMs fuer Gruppe '%s'" % group.name,
|
||||
"%d ausgewaehlt%s" % (len(chosen),
|
||||
(" Filter: " + filter_text) if filter_text else ""),
|
||||
"Leer Auswaehlen | a Alle | n Keine | i Umkehren | / Filter | "
|
||||
"Enter Uebernehmen | q Abbruch")
|
||||
|
||||
_put(win, 3, 2, " VMID Typ Name".ljust(46) + "Node".ljust(14)
|
||||
+ "Status".ljust(10) + "Tags", curses.A_BOLD)
|
||||
visible = max(1, height - 6)
|
||||
if index < top:
|
||||
top = index
|
||||
if index >= top + visible:
|
||||
top = index - visible + 1
|
||||
|
||||
for row in range(visible):
|
||||
position = top + row
|
||||
if position >= len(shown):
|
||||
break
|
||||
guest = shown[position]
|
||||
attr = curses.color_pair(C_SEL) if position == index else 0
|
||||
mark = "[x]" if guest.vmid in chosen else "[ ]"
|
||||
line = ("%s %s %s %s%s%s%s"
|
||||
% (mark,
|
||||
str(guest.vmid).rjust(6),
|
||||
("LXC" if guest.type == "lxc" else "VM ").ljust(4),
|
||||
truncate(guest.name or "-", 26).ljust(28),
|
||||
truncate(guest.node, 12).ljust(14),
|
||||
truncate(guest.status, 9).ljust(10),
|
||||
truncate(",".join(guest.tags) or "-", 20)))
|
||||
_fill_row(win, 4 + row, 2, line, width, attr)
|
||||
|
||||
win.refresh()
|
||||
key = _read_key(win)
|
||||
|
||||
if key in (curses.KEY_UP, "k"):
|
||||
index -= 1
|
||||
elif key in (curses.KEY_DOWN, "j"):
|
||||
index += 1
|
||||
elif key == curses.KEY_NPAGE:
|
||||
index += visible
|
||||
elif key == curses.KEY_PPAGE:
|
||||
index -= visible
|
||||
elif key == curses.KEY_HOME:
|
||||
index = 0
|
||||
elif key == curses.KEY_END:
|
||||
index = len(shown) - 1
|
||||
elif key == " " and shown:
|
||||
vmid = shown[index].vmid
|
||||
if vmid in chosen:
|
||||
chosen.discard(vmid)
|
||||
else:
|
||||
chosen.add(vmid)
|
||||
index += 1
|
||||
elif key == "a":
|
||||
chosen.update(g.vmid for g in shown)
|
||||
elif key == "n":
|
||||
chosen.difference_update(g.vmid for g in shown)
|
||||
elif key == "i":
|
||||
for guest in shown:
|
||||
if guest.vmid in chosen:
|
||||
chosen.discard(guest.vmid)
|
||||
else:
|
||||
chosen.add(guest.vmid)
|
||||
elif key == "/":
|
||||
entered = self._prompt(win, "Filter (Name, VMID oder Tag)", filter_text)
|
||||
filter_text = entered or ""
|
||||
index = top = 0
|
||||
elif key == "r":
|
||||
self.guests(refresh=True)
|
||||
guests = self._guests
|
||||
elif _is_enter(key):
|
||||
group.vmids = sorted(chosen)
|
||||
self.dirty = True
|
||||
return
|
||||
elif key in ("q", "Q") or _is_escape(key):
|
||||
return
|
||||
index = max(0, min(index, max(0, len(shown) - 1)))
|
||||
|
||||
@staticmethod
|
||||
def _matches_filter(guest, text):
|
||||
if not text:
|
||||
return True
|
||||
needle = text.lower()
|
||||
return (needle in (guest.name or "").lower()
|
||||
or needle in str(guest.vmid)
|
||||
or needle in " ".join(guest.tags)
|
||||
or needle in (guest.pool or "").lower()
|
||||
or needle in (guest.node or "").lower())
|
||||
|
||||
# -- Bildschirm: globale Einstellungen -------------------------------
|
||||
|
||||
def screen_globals(self, win):
|
||||
globals_ = self.config.globals
|
||||
index = 0
|
||||
while True:
|
||||
fields = [
|
||||
("Praefix im Snapshot-Namen", globals_.prefix, "text", "prefix"),
|
||||
("Pruefintervall des Dienstes", format_duration(globals_.check_interval),
|
||||
"duration", "check_interval"),
|
||||
("Zustandsdatei", globals_.state_file, "text", "state_file"),
|
||||
("Protokollstufe", globals_.log_level, "level", "log_level"),
|
||||
("Zusaetzliche Logdatei", globals_.log_file or "-", "text", "log_file"),
|
||||
("Zeitlimit je Snapshot-Task", format_duration(globals_.task_timeout),
|
||||
"duration", "task_timeout"),
|
||||
("Beim Start sofort ausfuehren", "ja" if globals_.run_on_start else "nein",
|
||||
"bool", "run_on_start"),
|
||||
("Testlauf (nichts wirklich tun)", "ja" if globals_.dry_run else "nein",
|
||||
"bool", "dry_run"),
|
||||
("Standard-Beschreibung", globals_.description, "text", "description"),
|
||||
]
|
||||
index = max(0, min(index, len(fields) - 1))
|
||||
height, width = self._frame(win, "Globale Einstellungen", self.path,
|
||||
"Enter Aendern | q zurueck")
|
||||
for row, (label, value, _kind, _key) in enumerate(fields):
|
||||
attr = curses.color_pair(C_SEL) if row == index else 0
|
||||
_fill_row(win, 4 + row, 2,
|
||||
truncate(label, 32).ljust(34) + truncate(str(value), max(4, width - 42)),
|
||||
width, attr)
|
||||
_put(win, 6 + len(fields), 2,
|
||||
"Platzhalter der Beschreibung: {group} {vmid} {name} {node} {type} "
|
||||
"{datetime} {date} {time} {keep_time} {keep_count} {schedule}",
|
||||
curses.color_pair(C_DIM))
|
||||
win.refresh()
|
||||
|
||||
key = _read_key(win)
|
||||
if key in (curses.KEY_UP, "k"):
|
||||
index -= 1
|
||||
elif key in (curses.KEY_DOWN, "j"):
|
||||
index += 1
|
||||
elif _is_enter(key) or key == " ":
|
||||
label, _value, kind, attribute = fields[index]
|
||||
self._edit_global(win, label, kind, attribute)
|
||||
elif key in ("q", "Q") or _is_escape(key):
|
||||
return
|
||||
|
||||
def _edit_global(self, win, label, kind, attribute):
|
||||
globals_ = self.config.globals
|
||||
if kind == "bool":
|
||||
setattr(globals_, attribute, not getattr(globals_, attribute))
|
||||
self.dirty = True
|
||||
return
|
||||
if kind == "level":
|
||||
entries = [(lvl, lvl) for lvl in ("DEBUG", "INFO", "WARNING", "ERROR")]
|
||||
chosen = self._choose(win, "Protokollstufe", entries)
|
||||
if chosen:
|
||||
globals_.log_level = chosen
|
||||
self.dirty = True
|
||||
return
|
||||
if kind == "duration":
|
||||
raw = self._prompt(win, label, format_duration(getattr(globals_, attribute),
|
||||
zero="0"))
|
||||
if raw is None:
|
||||
return
|
||||
try:
|
||||
setattr(globals_, attribute, parse_duration(raw, default_unit="s"))
|
||||
self.dirty = True
|
||||
except ValueError as exc:
|
||||
self._message(win, str(exc), error=True)
|
||||
return
|
||||
|
||||
raw = self._prompt(win, label, getattr(globals_, attribute))
|
||||
if raw is None:
|
||||
return
|
||||
setattr(globals_, attribute, raw)
|
||||
self.dirty = True
|
||||
|
||||
# -- Bildschirm: Uebersicht ------------------------------------------
|
||||
|
||||
def screen_overview(self, win):
|
||||
from .engine import select_guests
|
||||
guests = self.guests()
|
||||
top = 0
|
||||
while True:
|
||||
height, width = self._frame(win, "Uebersicht: welche VM in welcher Gruppe?",
|
||||
self._inventory_error or "%d Gaeste" % len(guests),
|
||||
"Pfeiltasten Blaettern | r Neu laden | q zurueck")
|
||||
_put(win, 3, 2, "VMID".ljust(8) + "Name".ljust(26) + "Status".ljust(10) + "Gruppen",
|
||||
curses.A_BOLD)
|
||||
rows = []
|
||||
for guest in guests:
|
||||
names = [g.name for g in self.config.groups if guest in select_guests(g, [guest])]
|
||||
rows.append((guest, names))
|
||||
|
||||
visible = max(1, height - 6)
|
||||
top = max(0, min(top, max(0, len(rows) - visible)))
|
||||
for row in range(visible):
|
||||
position = top + row
|
||||
if position >= len(rows):
|
||||
break
|
||||
guest, names = rows[position]
|
||||
attr = 0 if names else curses.color_pair(C_DIM) | curses.A_DIM
|
||||
_put(win, 4 + row, 2,
|
||||
truncate(str(guest.vmid), 7).ljust(8)
|
||||
+ truncate(guest.name or "-", 24).ljust(26)
|
||||
+ truncate(guest.status, 9).ljust(10)
|
||||
+ truncate(", ".join(names) or "(keine Gruppe)", max(4, width - 48)),
|
||||
attr)
|
||||
win.refresh()
|
||||
|
||||
key = _read_key(win)
|
||||
if key == curses.KEY_DOWN:
|
||||
top += 1
|
||||
elif key == curses.KEY_UP:
|
||||
top -= 1
|
||||
elif key == curses.KEY_NPAGE:
|
||||
top += visible
|
||||
elif key == curses.KEY_PPAGE:
|
||||
top -= visible
|
||||
elif key == "r":
|
||||
guests = self.guests(refresh=True)
|
||||
elif key in ("q", "Q") or _is_escape(key):
|
||||
return
|
||||
top = max(0, top)
|
||||
|
||||
|
||||
def _preview_next(group):
|
||||
"""Zeigt den naechsten Termin, damit man die Einstellung sofort pruefen kann."""
|
||||
from datetime import datetime
|
||||
|
||||
from .schedule import next_due
|
||||
try:
|
||||
moment = next_due(group, None, datetime.now())
|
||||
except ValueError:
|
||||
return "-"
|
||||
tage = ["Mo", "Di", "Mi", "Do", "Fr", "Sa", "So"]
|
||||
return "%s %s (%s)" % (tage[moment.weekday()],
|
||||
moment.strftime("%d.%m.%Y %H:%M"), describe(group))
|
||||
|
||||
|
||||
def _fill_row(win, y, x, text, width, attr):
|
||||
_put(win, y, x, str(text).ljust(max(0, width - x - 1))[: max(0, width - x - 1)], attr)
|
||||
|
||||
|
||||
def run_editor(path):
|
||||
editor = Editor(path)
|
||||
try:
|
||||
editor.load()
|
||||
except ConfigError as exc:
|
||||
print(str(exc))
|
||||
return 2
|
||||
curses.wrapper(editor.run)
|
||||
if editor.dirty:
|
||||
print("Achtung: Aenderungen wurden NICHT gespeichert.")
|
||||
return 1
|
||||
return 0
|
||||
+162
@@ -0,0 +1,162 @@
|
||||
"""Kleine Hilfsfunktionen fuer pvesnap (Dauer-Parsing, Slugs, Listen)."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import re
|
||||
import unicodedata
|
||||
|
||||
_DURATION_UNITS = {
|
||||
"s": 1, "sec": 1, "secs": 1, "second": 1, "seconds": 1,
|
||||
"sek": 1, "sekunde": 1, "sekunden": 1,
|
||||
"m": 60, "min": 60, "mins": 60, "minute": 60, "minutes": 60, "minuten": 60,
|
||||
"h": 3600, "hour": 3600, "hours": 3600, "std": 3600, "stunde": 3600, "stunden": 3600,
|
||||
"d": 86400, "day": 86400, "days": 86400, "t": 86400, "tag": 86400, "tage": 86400,
|
||||
"w": 604800, "week": 604800, "weeks": 604800, "woche": 604800, "wochen": 604800,
|
||||
"mo": 2592000, "month": 2592000, "months": 2592000, "monat": 2592000, "monate": 2592000,
|
||||
"y": 31536000, "year": 31536000, "years": 31536000,
|
||||
"j": 31536000, "jahr": 31536000, "jahre": 31536000,
|
||||
}
|
||||
|
||||
_DURATION_TOKEN = re.compile(r"(\d+(?:[.,]\d+)?)\s*([a-zäöü]*)")
|
||||
|
||||
_NEVER = {"0", "never", "nie", "unbegrenzt", "unlimited", "off", "aus", "keine", "-"}
|
||||
|
||||
|
||||
def parse_duration(text, default_unit="s"):
|
||||
"""'2d12h' -> 216000. 0 / 'nie' / 'unbegrenzt' -> 0 (= keine Begrenzung)."""
|
||||
if text is None:
|
||||
raise ValueError("leere Zeitangabe")
|
||||
s = str(text).strip().lower()
|
||||
if not s:
|
||||
raise ValueError("leere Zeitangabe")
|
||||
if s in _NEVER:
|
||||
return 0
|
||||
|
||||
total = 0.0
|
||||
pos = 0
|
||||
found = False
|
||||
for match in _DURATION_TOKEN.finditer(s):
|
||||
if match.start() != pos:
|
||||
raise ValueError("ungueltige Zeitangabe: %r" % text)
|
||||
pos = match.end()
|
||||
value = float(match.group(1).replace(",", "."))
|
||||
unit = match.group(2) or default_unit
|
||||
if unit not in _DURATION_UNITS:
|
||||
raise ValueError("unbekannte Zeiteinheit %r in %r" % (unit, text))
|
||||
total += value * _DURATION_UNITS[unit]
|
||||
found = True
|
||||
|
||||
if not found or pos != len(s):
|
||||
raise ValueError("ungueltige Zeitangabe: %r" % text)
|
||||
return int(round(total))
|
||||
|
||||
|
||||
def format_duration(seconds, zero="unbegrenzt"):
|
||||
"""216000 -> '2d12h'. Ergebnis ist wieder von parse_duration lesbar."""
|
||||
seconds = int(seconds or 0)
|
||||
if seconds <= 0:
|
||||
return zero
|
||||
parts = []
|
||||
for unit, size in (("w", 604800), ("d", 86400), ("h", 3600), ("m", 60), ("s", 1)):
|
||||
if seconds >= size:
|
||||
count, seconds = divmod(seconds, size)
|
||||
parts.append("%d%s" % (count, unit))
|
||||
return "".join(parts)
|
||||
|
||||
|
||||
def slugify(text, maxlen=20):
|
||||
"""Gruppenname -> kurzer, PVE-tauglicher Bezeichner (nur a-z0-9, beginnt mit Buchstabe)."""
|
||||
# Umlaute vor der Normalisierung ersetzen - NFKD wuerde sie sonst zerlegen.
|
||||
lowered = str(text).lower()
|
||||
for umlaut, replacement in (("ä", "ae"), ("ö", "oe"), ("ü", "ue"), ("ß", "ss")):
|
||||
lowered = lowered.replace(umlaut, replacement)
|
||||
ascii_only = unicodedata.normalize("NFKD", lowered).encode("ascii", "ignore").decode("ascii")
|
||||
slug = re.sub(r"[^a-z0-9]+", "", ascii_only)
|
||||
if not slug:
|
||||
slug = "grp"
|
||||
if not slug[0].isalpha():
|
||||
slug = "g" + slug
|
||||
return slug[:maxlen]
|
||||
|
||||
|
||||
_TRUE = {"1", "yes", "y", "true", "on", "ja", "j", "an", "ein", "enabled", "aktiv"}
|
||||
_FALSE = {"0", "no", "n", "false", "off", "nein", "aus", "disabled", "inaktiv", ""}
|
||||
|
||||
|
||||
def parse_bool(text, default=None):
|
||||
if isinstance(text, bool):
|
||||
return text
|
||||
value = str(text).strip().lower()
|
||||
if value in _TRUE:
|
||||
return True
|
||||
if value in _FALSE:
|
||||
return default if (value == "" and default is not None) else False
|
||||
raise ValueError("ungueltiger Ja/Nein-Wert: %r" % text)
|
||||
|
||||
|
||||
def format_bool(value):
|
||||
return "yes" if value else "no"
|
||||
|
||||
|
||||
def parse_list(text):
|
||||
"""Kommagetrennte (oder per Semikolon/Whitespace getrennte) Liste -> Liste von Strings."""
|
||||
if not text:
|
||||
return []
|
||||
if isinstance(text, (list, tuple)):
|
||||
items = list(text)
|
||||
else:
|
||||
items = re.split(r"[,;\s]+", str(text))
|
||||
return [item.strip() for item in items if item and item.strip()]
|
||||
|
||||
|
||||
def parse_vmid_list(text):
|
||||
"""'100,101,105-108' -> [100, 101, 105, 106, 107, 108]."""
|
||||
result = []
|
||||
for token in parse_list(text):
|
||||
match = re.match(r"^(\d+)\s*-\s*(\d+)$", token)
|
||||
if match:
|
||||
start, end = int(match.group(1)), int(match.group(2))
|
||||
if end < start:
|
||||
start, end = end, start
|
||||
if end - start > 100000:
|
||||
raise ValueError("VMID-Bereich zu gross: %r" % token)
|
||||
result.extend(range(start, end + 1))
|
||||
elif token.isdigit():
|
||||
result.append(int(token))
|
||||
else:
|
||||
raise ValueError("ungueltige VMID: %r" % token)
|
||||
return sorted(set(result))
|
||||
|
||||
|
||||
def format_vmid_list(vmids):
|
||||
"""[100,101,102,105] -> '100-102,105' (Umkehrung von parse_vmid_list)."""
|
||||
ids = sorted(set(int(v) for v in vmids))
|
||||
if not ids:
|
||||
return ""
|
||||
chunks = []
|
||||
start = previous = ids[0]
|
||||
for vmid in ids[1:]:
|
||||
if vmid == previous + 1:
|
||||
previous = vmid
|
||||
continue
|
||||
chunks.append((start, previous))
|
||||
start = previous = vmid
|
||||
chunks.append((start, previous))
|
||||
out = []
|
||||
for begin, end in chunks:
|
||||
if end - begin >= 2:
|
||||
out.append("%d-%d" % (begin, end))
|
||||
else:
|
||||
out.extend(str(v) for v in range(begin, end + 1))
|
||||
return ",".join(out)
|
||||
|
||||
|
||||
def truncate(text, width):
|
||||
text = str(text)
|
||||
if width <= 0:
|
||||
return ""
|
||||
if len(text) <= width:
|
||||
return text
|
||||
if width <= 1:
|
||||
return text[:width]
|
||||
return text[: width - 1] + "…"
|
||||
@@ -0,0 +1,32 @@
|
||||
[Unit]
|
||||
Description=pvesnap - automatische Proxmox-Snapshots
|
||||
Documentation=file:/usr/share/doc/pvesnap/README.md
|
||||
After=network-online.target pve-cluster.service pvedaemon.service
|
||||
Wants=pve-cluster.service pvedaemon.service
|
||||
|
||||
[Service]
|
||||
Type=simple
|
||||
ExecStart=/usr/bin/python3 -m pvesnap --config /etc/pvesnap/pvesnap.conf daemon
|
||||
ExecReload=/bin/kill -HUP $MAINPID
|
||||
Environment=PYTHONPATH=/usr/lib/pvesnap
|
||||
Environment=PYTHONUNBUFFERED=1
|
||||
Restart=on-failure
|
||||
RestartSec=30
|
||||
TimeoutStopSec=300
|
||||
|
||||
# pvesh benoetigt root-Rechte.
|
||||
User=root
|
||||
StateDirectory=pvesnap
|
||||
RuntimeDirectory=pvesnap
|
||||
|
||||
# Moderate Absicherung - der Dienst muss auf pvesh und /etc/pve zugreifen.
|
||||
NoNewPrivileges=yes
|
||||
PrivateTmp=yes
|
||||
ProtectHome=yes
|
||||
ProtectSystem=full
|
||||
ProtectKernelTunables=yes
|
||||
ProtectControlGroups=yes
|
||||
RestrictRealtime=yes
|
||||
|
||||
[Install]
|
||||
WantedBy=multi-user.target
|
||||
Executable
+91
@@ -0,0 +1,91 @@
|
||||
#!/bin/bash
|
||||
# ---------------------------------------------------------------------
|
||||
# pvesnap - Deinstallation
|
||||
#
|
||||
# ./uninstall.sh Programm und Dienst entfernen,
|
||||
# Konfiguration und Zustand bleiben erhalten
|
||||
# ./uninstall.sh --purge zusaetzlich /etc/pvesnap und /var/lib/pvesnap
|
||||
# entfernen
|
||||
#
|
||||
# Bereits angelegte Snapshots werden NIE angeruehrt.
|
||||
# ---------------------------------------------------------------------
|
||||
set -euo pipefail
|
||||
|
||||
LIB_DIR="/usr/lib/pvesnap"
|
||||
BIN="/usr/local/bin/pvesnap"
|
||||
CONF_DIR="/etc/pvesnap"
|
||||
STATE_DIR="/var/lib/pvesnap"
|
||||
DOC_DIR="/usr/share/doc/pvesnap"
|
||||
UNIT="/etc/systemd/system/pvesnap.service"
|
||||
|
||||
PURGE=0
|
||||
YES=0
|
||||
for arg in "$@"; do
|
||||
case "$arg" in
|
||||
--purge) PURGE=1 ;;
|
||||
-y|--yes) YES=1 ;;
|
||||
-h|--help) sed -n '2,11p' "$0" | sed 's/^#[[:space:]]\{0,1\}//'; exit 0 ;;
|
||||
*) echo "Unbekannte Option: $arg" >&2; exit 1 ;;
|
||||
esac
|
||||
done
|
||||
|
||||
info() { printf '\033[1;32m==>\033[0m %s\n' "$*"; }
|
||||
warn() { printf '\033[1;33m==>\033[0m %s\n' "$*" >&2; }
|
||||
fail() { printf '\033[1;31m==>\033[0m %s\n' "$*" >&2; exit 1; }
|
||||
|
||||
[ "$(id -u)" -eq 0 ] || fail "Bitte als root ausfuehren (sudo ./uninstall.sh)."
|
||||
|
||||
if [ "$YES" -eq 0 ]; then
|
||||
if [ "$PURGE" -eq 1 ]; then
|
||||
printf 'pvesnap inklusive Konfiguration und Zustand entfernen? [j/N] '
|
||||
else
|
||||
printf 'pvesnap entfernen (Konfiguration bleibt erhalten)? [j/N] '
|
||||
fi
|
||||
read -r answer
|
||||
case "$answer" in
|
||||
j|J|y|Y) ;;
|
||||
*) echo "Abgebrochen."; exit 0 ;;
|
||||
esac
|
||||
fi
|
||||
|
||||
if systemctl list-unit-files 2>/dev/null | grep -q '^pvesnap\.service'; then
|
||||
info "Stoppe und deaktiviere Dienst"
|
||||
systemctl stop pvesnap.service 2>/dev/null || true
|
||||
systemctl disable pvesnap.service 2>/dev/null || true
|
||||
fi
|
||||
|
||||
if [ -f "$UNIT" ]; then
|
||||
info "Entferne $UNIT"
|
||||
rm -f "$UNIT"
|
||||
fi
|
||||
systemctl daemon-reload 2>/dev/null || true
|
||||
systemctl reset-failed pvesnap.service 2>/dev/null || true
|
||||
|
||||
if [ -e "$BIN" ]; then
|
||||
info "Entferne $BIN"
|
||||
rm -f "$BIN"
|
||||
fi
|
||||
if [ -d "$LIB_DIR" ]; then
|
||||
info "Entferne $LIB_DIR"
|
||||
rm -rf "$LIB_DIR"
|
||||
fi
|
||||
rm -rf "$DOC_DIR"
|
||||
rm -f /run/pvesnap.lock /run/pvesnap.lock.daemon
|
||||
|
||||
if [ "$PURGE" -eq 1 ]; then
|
||||
info "Entferne Konfiguration und Zustand"
|
||||
rm -rf "$CONF_DIR" "$STATE_DIR"
|
||||
else
|
||||
warn "Behalten: $CONF_DIR und $STATE_DIR (mit --purge ebenfalls entfernen)"
|
||||
fi
|
||||
|
||||
cat <<EOF
|
||||
|
||||
pvesnap wurde entfernt.
|
||||
|
||||
Bereits vorhandene Snapshots bleiben bestehen. Auflisten und loeschen lassen
|
||||
sie sich weiterhin in der Proxmox-Oberflaeche oder mit:
|
||||
|
||||
qm listsnapshot <VMID> / qm delsnapshot <VMID> <NAME>
|
||||
pct listsnapshot <VMID> / pct delsnapshot <VMID> <NAME>
|
||||
EOF
|
||||
Reference in New Issue
Block a user