restore.sh aktualisiert
parent
5a7e603320
commit
4abe094358
407
restore.sh
407
restore.sh
|
|
@ -2,53 +2,34 @@
|
|||
# =============================================================================
|
||||
# /opt/windmill-restore/restore.sh
|
||||
# Windmill Backup Restore Worker
|
||||
# Version: 1.0.10
|
||||
# Version: 1.0.11
|
||||
#
|
||||
# WAS DIESES SCRIPT MACHT:
|
||||
# ─────────────────────────────────────────────────────────────────────────────
|
||||
# Läuft direkt auf dem Proxmox Restore-Server, gestartet von Windmill per SSH
|
||||
# non-blocking (nohup ... &). Komplett eigenständig, keine offene Verbindung.
|
||||
#
|
||||
# Alle Pfade kommen aus der Datenbank via Windmill:
|
||||
# --restore-mount Mountpoint des Restore-Volumes z.B. /mnt/HDD_5TB.1
|
||||
# --restore-path PVE-Storage-Name für qmrestore z.B. 5TB.1
|
||||
# --rsync-target Rsync-Ziel auf Backup-Server z.B. /backup/incoming/TNP
|
||||
# --pbs-storage PVE-Storage-ID des PBS-Datastores z.B. pbs-tnp-invest-gmbh
|
||||
#
|
||||
# 7z-Passwort wird per Rsync vom PBS-Server geholt (PBS_HOST aus pbs.conf):
|
||||
# 7z-Passwort: /root/Scripte/password_7z.txt → für 7z-Archiv
|
||||
# Format: "tnp-Invest-GmbH: Passwort123"
|
||||
# PBS Encrypt-Key entfällt – Entschlüsselung läuft über pvesm (Fingerprint in DB)
|
||||
#
|
||||
# VM_IMAGE_DIR wird dynamisch aus dem PVE-Storage-Pfad ermittelt:
|
||||
# pvesh get /storage/${RESTORE_PATH} → path → /mnt/HDD_5TB.1/images/${VM_ID}
|
||||
# Unterstützt sowohl VM (qm) als auch CT (pct) Backups.
|
||||
# Backup-Typ wird automatisch aus dem Backup-Pfad erkannt (vm/ oder ct/).
|
||||
#
|
||||
# ABLAUF:
|
||||
# [0] 7z-Passwort holen – password_7z.txt per Rsync vom PBS-Server
|
||||
# [1] Space-Check – Freier Platz auf restore-mount prüfen
|
||||
# [2] VM-ID ermitteln – Original aus Backup-Pfad, Restore-ID ab 1000
|
||||
# [3] qmrestore – Direkt vom PBS-Storage (kein --keyfile nötig)
|
||||
# [4] VM_IMAGE_DIR – Dynamisch aus PVE-Storage-Pfad ermitteln
|
||||
# [2] ID ermitteln – Original aus Backup-Pfad, Restore-ID ab 1000
|
||||
# [3] Restore – qmrestore (VM) oder pct restore (CT)
|
||||
# [4] IMAGE_DIR – Dynamisch aus PVE-Storage-Pfad ermitteln
|
||||
# [5] Images prüfen – Abbruch wenn leer/nicht vorhanden
|
||||
# [6] VM vorbereiten – unlock, cdrom/ide0 entfernen, alle Netzwerkkarten
|
||||
# löschen, Agent aktivieren
|
||||
# [7] VM starten & – 120s auf qm-Agent warten (10s Schritte)
|
||||
# Agent prüfen Kein Agent = qm_agent_ok=false, KEIN Abbruch
|
||||
# [8] VM stoppen – Sauberes Shutdown, nach 30s force-stop
|
||||
# [9] 7z-Archiv – VM-Images verschlüsselt zippen (7z-Passwort)
|
||||
# [10] Rsync – ZIP zum Backup-Server (Firmen-Zielverzeichnis)
|
||||
# 3 Versuche + Größenvergleich
|
||||
# [11] Aufräumen – VM destroy, ZIP löschen
|
||||
# [12] Webhook – JSON → Windmill schreibt DB & startet nächsten
|
||||
# [6] Vorbereiten – VM: unlock/cdrom/net entfernen/Agent
|
||||
# CT: unlock/net entfernen
|
||||
# [7] Starten & prüfen – VM: qm-Agent 120s | CT: pct exec ping
|
||||
# [8] Stoppen – VM: qm shutdown | CT: pct stop
|
||||
# [9] Config sichern – Originale Config ins ZIP-Verzeichnis
|
||||
# [10] 7z-Archiv – Images verschlüsselt zippen
|
||||
# [11] Rsync – ZIP zum Backup-Server
|
||||
# [12] Aufräumen – destroy, ZIP löschen
|
||||
# [13] Webhook – JSON → Windmill
|
||||
# =============================================================================
|
||||
set -euo pipefail
|
||||
|
||||
# ── Konfigdatei laden (PBS-Credentials) ──────────────────────────────────────
|
||||
# ── Konfigdatei laden ─────────────────────────────────────────────────────────
|
||||
CONF_FILE="/opt/windmill-restore/pbs.conf"
|
||||
[[ ! -f "$CONF_FILE" ]] && { echo "FEHLER: $CONF_FILE fehlt!" >&2; exit 1; }
|
||||
# shellcheck source=/dev/null
|
||||
source "$CONF_FILE"
|
||||
# Enthält: PBS_HOST, PBS_PORT, PBS_USER, PBS_PASSWORD, PBS_FINGERPRINT
|
||||
|
||||
# ── Argument-Parser ───────────────────────────────────────────────────────────
|
||||
JOB_UUID=""
|
||||
|
|
@ -76,31 +57,31 @@ while [[ $# -gt 0 ]]; do
|
|||
esac
|
||||
done
|
||||
|
||||
# Pflichtparameter prüfen
|
||||
for var in JOB_UUID BACKUP_PATH CLIENT_NAME \
|
||||
RESTORE_MOUNT RESTORE_PATH RSYNC_TARGET PBS_STORAGE WEBHOOK_URL; do
|
||||
[[ -z "${!var}" ]] && { echo "FEHLER: --${var//_/-} fehlt" >&2; exit 1; }
|
||||
done
|
||||
|
||||
[[ ! -d "$RESTORE_MOUNT" ]] && {
|
||||
echo "FEHLER: Restore-Mount '$RESTORE_MOUNT' existiert nicht!" >&2
|
||||
exit 1
|
||||
echo "FEHLER: Restore-Mount '$RESTORE_MOUNT' existiert nicht!" >&2; exit 1
|
||||
}
|
||||
|
||||
# ── Logging ───────────────────────────────────────────────────────────────────
|
||||
LOG_DIR="/opt/windmill-restore/logs"
|
||||
mkdir -p "$LOG_DIR"
|
||||
SAFE_CLIENT="${CLIENT_NAME//\//_}" # "vm/100" → "vm_100"
|
||||
SAFE_CLIENT="${CLIENT_NAME//\//_}"
|
||||
LOG_FILE="$LOG_DIR/${SAFE_CLIENT}_$(date +%Y%m%d_%H%M%S).log"
|
||||
exec > >(tee -a "$LOG_FILE") 2>&1
|
||||
|
||||
# ── Backup-Pfad zerlegen ──────────────────────────────────────────────────────
|
||||
# BACKUP_PATH Format: "tnp-Invest-GmbH:vm/100/2024-01-15T02:00:00Z"
|
||||
# Format: "tnp-Invest-GmbH:vm/100/2024-01-15T02:00:00Z"
|
||||
# oder "Jaehler-GmbH:ct/105/2024-01-15T06:00:00Z"
|
||||
DATASTORE=$(echo "$BACKUP_PATH" | cut -d: -f1)
|
||||
SNAPSHOT_PATH=$(echo "$BACKUP_PATH" | cut -d: -f2-)
|
||||
BACKUP_TYPE=$(echo "$SNAPSHOT_PATH" | cut -d/ -f1) # "vm" oder "ct"
|
||||
PVE_BACKUP_REF="${PBS_STORAGE}:backup/${SNAPSHOT_PATH}"
|
||||
|
||||
# ── Pfade & Messvariablen ─────────────────────────────────────────────────────
|
||||
# ── Messvariablen ─────────────────────────────────────────────────────────────
|
||||
LAST_DATE=$(date +"%Y-%m-%d" -d "1 day ago")
|
||||
ZIP_DIR="${RESTORE_MOUNT}/zips/${LAST_DATE}"
|
||||
BACKUP_SERVER_HOST=$(cat /opt/windmill-restore/backup_server_host 2>/dev/null \
|
||||
|
|
@ -112,7 +93,7 @@ ERROR_MSG=""
|
|||
VM_ID_ORIGINAL=0
|
||||
VM_ID_RESTORED=0
|
||||
VM_NAME=""
|
||||
VM_IMAGE_DIR=""
|
||||
IMAGE_DIR=""
|
||||
ACTUAL_DISK_BYTES=0
|
||||
ZIP_SIZE_BYTES=0
|
||||
ZIP_DURATION=0
|
||||
|
|
@ -120,12 +101,13 @@ RSYNC_SIZE_BYTES=0
|
|||
RSYNC_OK="true"
|
||||
RSYNC_RETRIES=0
|
||||
QM_AGENT_OK="false"
|
||||
RESTORE_DURATION=0
|
||||
ZIP_FILE=""
|
||||
ZIP_PASSWORD=""
|
||||
|
||||
echo "============================================================"
|
||||
echo " Windmill Restore Worker v1.0.9"
|
||||
echo " Windmill Restore Worker v1.0.11"
|
||||
echo " Client: $CLIENT_NAME"
|
||||
echo " Typ: $BACKUP_TYPE"
|
||||
echo " Datastore: $DATASTORE"
|
||||
echo " Backup: $BACKUP_PATH"
|
||||
echo " PBS-Storage: $PBS_STORAGE"
|
||||
|
|
@ -179,31 +161,40 @@ send_webhook() {
|
|||
|| echo " WARNUNG: HTTP $http_code"
|
||||
}
|
||||
|
||||
# ── ERR-Trap: aufräumen und Webhook senden ────────────────────────────────────
|
||||
trap 'STATUS="failed"
|
||||
send_webhook "failed" "Abgebrochen in Zeile $LINENO – $LOG_FILE"' ERR
|
||||
ERROR_LINE=$LINENO
|
||||
echo ""
|
||||
echo "FEHLER in Zeile ${ERROR_LINE} – räume auf..."
|
||||
if [[ ${VM_ID_RESTORED:-0} -gt 0 ]]; then
|
||||
if [[ "$BACKUP_TYPE" == "ct" ]]; then
|
||||
pct stop "$VM_ID_RESTORED" 2>/dev/null || true
|
||||
sleep 3
|
||||
pct destroy "$VM_ID_RESTORED" --purge 1 2>/dev/null || true
|
||||
else
|
||||
qm stop "$VM_ID_RESTORED" --skiplock 1 2>/dev/null || true
|
||||
sleep 5
|
||||
qm destroy "$VM_ID_RESTORED" \
|
||||
--destroy-unreferenced-disks 1 --purge 1 2>/dev/null || true
|
||||
fi
|
||||
echo " ${BACKUP_TYPE^^} ${VM_ID_RESTORED} entfernt."
|
||||
fi
|
||||
[[ -n "${ZIP_FILE:-}" && -f "$ZIP_FILE" ]] && rm -f "$ZIP_FILE"
|
||||
[[ -n "${IMAGE_DIR:-}" && -d "$IMAGE_DIR" ]] && rm -rf "$IMAGE_DIR"
|
||||
send_webhook "failed" "Abgebrochen in Zeile ${ERROR_LINE} – $LOG_FILE"' ERR
|
||||
|
||||
# ═════════════════════════════════════════════════════════════════════════════
|
||||
# [0/12] 7Z-PASSWORT VOM PBS-SERVER HOLEN
|
||||
# PBS_HOST kommt aus pbs.conf. Datei wird lokal gecacht.
|
||||
# Bei mehreren VMs desselben Datastores nur einmal geholt.
|
||||
#
|
||||
# 7z-Passwort: /root/Scripte/password_7z.txt → 7z -p
|
||||
# Format: "tnp-Invest-GmbH: Passwort123"
|
||||
#
|
||||
# PBS Encrypt-Key entfällt – Entschlüsselung läuft über den registrierten
|
||||
# pvesm PBS-Storage (Fingerprint ist in bronze.backup.datastore.config hinterlegt
|
||||
# und wurde von Windmill Step C beim pvesm add pbs eingetragen).
|
||||
# [0/13] 7Z-PASSWORT VOM PBS-SERVER HOLEN
|
||||
# ═════════════════════════════════════════════════════════════════════════════
|
||||
echo ""
|
||||
echo "==> [0/12] 7z-Passwort vom PBS-Server holen ($PBS_HOST)..."
|
||||
echo "==> [0/13] 7z-Passwort vom PBS-Server holen ($PBS_HOST)..."
|
||||
KEY_DIR="/opt/windmill-restore/keys"
|
||||
mkdir -p "$KEY_DIR"
|
||||
chmod 700 "$KEY_DIR"
|
||||
|
||||
# ── 7z-Passwort aus password_7z.txt ──────────────────────────────────────────
|
||||
PW_FILE_LOCAL="${KEY_DIR}/password_7z.txt"
|
||||
if [[ ! -f "$PW_FILE_LOCAL" || ! -s "$PW_FILE_LOCAL" ]]; then
|
||||
echo " Hole password_7z.txt: root@${PBS_HOST}:/root/Scripte/password_7z.txt"
|
||||
echo " Hole password_7z.txt..."
|
||||
rsync -az \
|
||||
-e "ssh -o StrictHostKeyChecking=no" \
|
||||
"root@${PBS_HOST}:/root/Scripte/password_7z.txt" \
|
||||
|
|
@ -219,17 +210,15 @@ ZIP_PASSWORD=$(grep -m1 "^${DATASTORE}:" "$PW_FILE_LOCAL" \
|
|||
| awk -F': ' '{print $2}' | tr -d '[:space:]')
|
||||
|
||||
[[ -z "$ZIP_PASSWORD" ]] && {
|
||||
echo "FEHLER: Kein 7z-Passwort für '$DATASTORE' in password_7z.txt" >&2
|
||||
exit 1
|
||||
echo "FEHLER: Kein 7z-Passwort für '$DATASTORE' in password_7z.txt" >&2; exit 1
|
||||
}
|
||||
echo " 7z-Passwort geladen ✓"
|
||||
|
||||
# ═════════════════════════════════════════════════════════════════════════════
|
||||
# [1/12] SPACE-CHECK
|
||||
# Nur Warnung – kein Abbruch.
|
||||
# [1/13] SPACE-CHECK
|
||||
# ═════════════════════════════════════════════════════════════════════════════
|
||||
echo ""
|
||||
echo "==> [1/12] Prüfe freien Speicherplatz auf $RESTORE_MOUNT..."
|
||||
echo "==> [1/13] Prüfe freien Speicherplatz auf $RESTORE_MOUNT..."
|
||||
mkdir -p "$ZIP_DIR"
|
||||
FREE_KB=$(df "$RESTORE_MOUNT" 2>/dev/null | awk 'NR==2{print $4}' || echo "0")
|
||||
FREE_GB=$(( FREE_KB / 1024 / 1024 ))
|
||||
|
|
@ -237,14 +226,12 @@ echo " Frei: ${FREE_GB} GB"
|
|||
[[ $FREE_GB -lt 50 ]] && echo " WARNUNG: Weniger als 50 GB frei!"
|
||||
|
||||
# ═════════════════════════════════════════════════════════════════════════════
|
||||
# [2/12] VM-ID ERMITTELN
|
||||
# Original aus Snapshot-Pfad (vm/100/... → 100)
|
||||
# Restore-ID: erste freie ab 1000, prüft QEMU + LXC
|
||||
# [2/13] ID ERMITTELN
|
||||
# ═════════════════════════════════════════════════════════════════════════════
|
||||
echo ""
|
||||
echo "==> [2/12] Ermittle VM-IDs..."
|
||||
echo "==> [2/13] Ermittle IDs..."
|
||||
VM_ID_ORIGINAL=$(echo "$SNAPSHOT_PATH" | grep -oP '\d+' | head -1 || echo "0")
|
||||
echo " Original VM-ID: $VM_ID_ORIGINAL"
|
||||
echo " Original-ID: $VM_ID_ORIGINAL (Typ: $BACKUP_TYPE)"
|
||||
|
||||
VM_ID_RESTORED=$(
|
||||
{
|
||||
|
|
@ -264,38 +251,44 @@ for i in range(1000, 2000):
|
|||
print(i); break
|
||||
" 2>/dev/null || echo "1000"
|
||||
)
|
||||
echo " Restore VM-ID: $VM_ID_RESTORED"
|
||||
echo " Restore-ID: $VM_ID_RESTORED"
|
||||
|
||||
# ═════════════════════════════════════════════════════════════════════════════
|
||||
# [3/12] QMRESTORE VOM PBS-STORAGE
|
||||
# --storage aus DB (restore_path), z.B. "5TB.1"
|
||||
# --unique 1 verhindert Konflikte mit bestehenden VM-Configs
|
||||
# Kein --keyfile nötig – Entschlüsselung über registrierten pvesm PBS-Storage
|
||||
# [3/13] RESTORE
|
||||
# VM → qmrestore
|
||||
# CT → pct restore
|
||||
# ═════════════════════════════════════════════════════════════════════════════
|
||||
echo ""
|
||||
echo "==> [3/12] qmrestore vom PBS-Storage..."
|
||||
echo "==> [3/13] Restore vom PBS-Storage ($BACKUP_TYPE)..."
|
||||
echo " Backup-Ref: $PVE_BACKUP_REF"
|
||||
echo " Storage: $RESTORE_PATH"
|
||||
echo " VM-ID: $VM_ID_RESTORED"
|
||||
echo " ID: $VM_ID_RESTORED"
|
||||
|
||||
RESTORE_START_INNER=$(date +%s)
|
||||
|
||||
qmrestore "$PVE_BACKUP_REF" "$VM_ID_RESTORED" \
|
||||
if [[ "$BACKUP_TYPE" == "ct" ]]; then
|
||||
pct restore "$VM_ID_RESTORED" "$PVE_BACKUP_REF" \
|
||||
--storage "$RESTORE_PATH" \
|
||||
--unique 1 \
|
||||
2>&1
|
||||
else
|
||||
qmrestore "$PVE_BACKUP_REF" "$VM_ID_RESTORED" \
|
||||
--storage "$RESTORE_PATH" \
|
||||
--unique 1 \
|
||||
2>&1
|
||||
fi
|
||||
|
||||
RESTORE_DURATION=$(( $(date +%s) - RESTORE_START_INNER ))
|
||||
echo " Restore abgeschlossen in ${RESTORE_DURATION}s"
|
||||
|
||||
# ═════════════════════════════════════════════════════════════════════════════
|
||||
# [4/12] VM_IMAGE_DIR DYNAMISCH ERMITTELN
|
||||
# PVE kennt den Basispfad des Storages.
|
||||
# pvesh get /storage/5TB.1 → "path": "/mnt/HDD_5TB.1"
|
||||
# VM_IMAGE_DIR = /mnt/HDD_5TB.1/images/${VM_ID_RESTORED}
|
||||
# [4/13] IMAGE_DIR DYNAMISCH ERMITTELN
|
||||
# VM → /mnt/HDD_5TB.1/images/${VM_ID_RESTORED}
|
||||
# CT → /mnt/HDD_5TB.1/private/${VM_ID_RESTORED}
|
||||
# oder /mnt/HDD_5TB.1/rootdir/${VM_ID_RESTORED}
|
||||
# ═════════════════════════════════════════════════════════════════════════════
|
||||
echo ""
|
||||
echo "==> [4/12] Ermittle VM-Image-Verzeichnis..."
|
||||
echo "==> [4/13] Ermittle Image-Verzeichnis..."
|
||||
STORAGE_BASE=$(pvesh get "/storage/${RESTORE_PATH}" --output-format json \
|
||||
2>/dev/null | python3 -c "
|
||||
import json, sys
|
||||
|
|
@ -304,89 +297,108 @@ print(cfg.get('path', ''))
|
|||
" 2>/dev/null || echo "")
|
||||
|
||||
if [[ -n "$STORAGE_BASE" ]]; then
|
||||
VM_IMAGE_DIR="${STORAGE_BASE}/images/${VM_ID_RESTORED}"
|
||||
if [[ "$BACKUP_TYPE" == "ct" ]]; then
|
||||
# CT-Images liegen unter private/ oder rootdir/
|
||||
if [[ -d "${STORAGE_BASE}/private/${VM_ID_RESTORED}" ]]; then
|
||||
IMAGE_DIR="${STORAGE_BASE}/private/${VM_ID_RESTORED}"
|
||||
else
|
||||
IMAGE_DIR="${STORAGE_BASE}/rootdir/${VM_ID_RESTORED}"
|
||||
fi
|
||||
else
|
||||
IMAGE_DIR="${STORAGE_BASE}/images/${VM_ID_RESTORED}"
|
||||
fi
|
||||
else
|
||||
# Fallback: direkt aus pvesm path
|
||||
VM_IMAGE_DIR=$(pvesm path "${RESTORE_PATH}:vm-${VM_ID_RESTORED}-disk-0" \
|
||||
2>/dev/null | xargs dirname 2>/dev/null || echo "")
|
||||
# Fallback
|
||||
if [[ "$BACKUP_TYPE" == "ct" ]]; then
|
||||
IMAGE_DIR="/var/lib/vz/private/${VM_ID_RESTORED}"
|
||||
else
|
||||
IMAGE_DIR="/var/lib/vz/images/${VM_ID_RESTORED}"
|
||||
fi
|
||||
echo " WARNUNG: Storage-Pfad nicht ermittelt, nutze Fallback: $IMAGE_DIR"
|
||||
fi
|
||||
echo " Image-Dir: $IMAGE_DIR"
|
||||
|
||||
if [[ -z "$VM_IMAGE_DIR" ]]; then
|
||||
# Letzter Fallback: Standard-Pfad
|
||||
VM_IMAGE_DIR="/var/lib/vz/images/${VM_ID_RESTORED}"
|
||||
echo " WARNUNG: Storage-Pfad nicht ermittelt, nutze Fallback: $VM_IMAGE_DIR"
|
||||
else
|
||||
echo " VM-Image-Dir: $VM_IMAGE_DIR"
|
||||
fi
|
||||
|
||||
ACTUAL_DISK_BYTES=$(du -sb "$VM_IMAGE_DIR" 2>/dev/null | awk '{print $1}' || echo "0")
|
||||
ACTUAL_DISK_BYTES=$(du -sb "$IMAGE_DIR" 2>/dev/null | awk '{print $1}' || echo "0")
|
||||
echo " Image-Größe: $(( ACTUAL_DISK_BYTES / 1024 / 1024 / 1024 )) GB"
|
||||
|
||||
# ═════════════════════════════════════════════════════════════════════════════
|
||||
# [5/12] VM-IMAGES PRÜFEN
|
||||
# Wenn leer oder nicht vorhanden → failed, Webhook senden, nächstes Backup.
|
||||
# [5/13] IMAGES PRÜFEN
|
||||
# ═════════════════════════════════════════════════════════════════════════════
|
||||
echo ""
|
||||
echo "==> [5/12] Prüfe VM-Images..."
|
||||
if [[ ! -d "$VM_IMAGE_DIR" ]] || [[ -z "$(ls -A "$VM_IMAGE_DIR" 2>/dev/null)" ]]; then
|
||||
ERROR_MSG="VM_IMAGE_DIR leer oder nicht vorhanden: $VM_IMAGE_DIR"
|
||||
echo "==> [5/13] Prüfe Images..."
|
||||
if [[ ! -d "$IMAGE_DIR" ]] || [[ -z "$(ls -A "$IMAGE_DIR" 2>/dev/null)" ]]; then
|
||||
ERROR_MSG="IMAGE_DIR leer oder nicht vorhanden: $IMAGE_DIR"
|
||||
echo " FEHLER: $ERROR_MSG"
|
||||
if [[ "$BACKUP_TYPE" == "ct" ]]; then
|
||||
pct destroy "$VM_ID_RESTORED" --purge 1 2>/dev/null || true
|
||||
else
|
||||
qm destroy "$VM_ID_RESTORED" \
|
||||
--destroy-unreferenced-disks 1 --purge 1 2>/dev/null || true
|
||||
fi
|
||||
trap - ERR
|
||||
send_webhook "failed" "$ERROR_MSG"
|
||||
exit 0
|
||||
fi
|
||||
echo " Images vorhanden ✓"
|
||||
|
||||
# ── Originale Config sichern BEVOR wir Netzwerkkarten etc. entfernen ─────────
|
||||
# Die originale Config (mit Netzwerkkarten, original settings) wird gesichert
|
||||
# und später ins ZIP gepackt damit die VM vollständig wiederhergestellt werden kann.
|
||||
PVE_CONF="/etc/pve/qemu-server/${VM_ID_RESTORED}.conf"
|
||||
ORIG_CONF_BACKUP="${VM_IMAGE_DIR}/qemu-server.original.conf"
|
||||
if [[ -f "$PVE_CONF" ]]; then
|
||||
cp "$PVE_CONF" "$ORIG_CONF_BACKUP"
|
||||
echo " Originale Config gesichert: $ORIG_CONF_BACKUP"
|
||||
# ═════════════════════════════════════════════════════════════════════════════
|
||||
# [6/13] VORBEREITEN
|
||||
# VM: unlock → stop → cdrom/ide0/net entfernen → Agent aktivieren
|
||||
# CT: unlock → stop → net entfernen
|
||||
# ═════════════════════════════════════════════════════════════════════════════
|
||||
echo ""
|
||||
echo "==> [6/13] Vorbereiten ($BACKUP_TYPE)..."
|
||||
|
||||
if [[ "$BACKUP_TYPE" == "ct" ]]; then
|
||||
pct unlock "$VM_ID_RESTORED" 2>/dev/null || true
|
||||
pct stop "$VM_ID_RESTORED" 2>/dev/null || true
|
||||
sleep 3
|
||||
# Alle Netzwerkinterfaces entfernen
|
||||
for ((net=0; net<=10; net++)); do
|
||||
pct set "$VM_ID_RESTORED" --delete "net${net}" 2>/dev/null || true
|
||||
done
|
||||
echo " CT vorbereitet (Netzwerkkarten entfernt)."
|
||||
else
|
||||
echo " WARNUNG: PVE-Config nicht gefunden: $PVE_CONF"
|
||||
qm unlock "$VM_ID_RESTORED" 2>/dev/null || true
|
||||
qm stop "$VM_ID_RESTORED" 2>/dev/null || true
|
||||
sleep 3
|
||||
qm set "$VM_ID_RESTORED" -delete cdrom 2>/dev/null || true
|
||||
qm set "$VM_ID_RESTORED" -delete ide0 2>/dev/null || true
|
||||
for ((net=0; net<=10; net++)); do
|
||||
qm set "$VM_ID_RESTORED" -delete "net${net}" 2>/dev/null || true
|
||||
done
|
||||
qm set "$VM_ID_RESTORED" --agent "enabled=1,type=virtio" 2>/dev/null || true
|
||||
echo " VM vorbereitet (Netzwerkkarten entfernt, Agent aktiviert)."
|
||||
fi
|
||||
|
||||
# ═════════════════════════════════════════════════════════════════════════════
|
||||
# [6/12] VM VORBEREITEN
|
||||
# unlock → stop → cdrom/ide0 entfernen → alle Netzwerkkarten (net0-net10)
|
||||
# löschen → Agent aktivieren.
|
||||
# [7/13] STARTEN & PRÜFEN
|
||||
# VM: qm-Agent 120s warten
|
||||
# CT: pct exec ping (vereinfacht)
|
||||
# ═════════════════════════════════════════════════════════════════════════════
|
||||
echo ""
|
||||
echo "==> [6/12] VM vorbereiten..."
|
||||
qm unlock "$VM_ID_RESTORED" 2>/dev/null || true
|
||||
qm stop "$VM_ID_RESTORED" 2>/dev/null || true
|
||||
sleep 3
|
||||
echo "==> [7/13] Starte & prüfe ($BACKUP_TYPE)..."
|
||||
|
||||
qm set "$VM_ID_RESTORED" -delete cdrom 2>/dev/null || true
|
||||
qm set "$VM_ID_RESTORED" -delete ide0 2>/dev/null || true
|
||||
|
||||
for ((net=0; net<=10; net++)); do
|
||||
qm set "$VM_ID_RESTORED" -delete "net${net}" 2>/dev/null || true
|
||||
done
|
||||
|
||||
qm set "$VM_ID_RESTORED" --agent "enabled=1,type=virtio" 2>/dev/null || true
|
||||
echo " VM vorbereitet (Netzwerkkarten entfernt, Agent aktiviert)."
|
||||
|
||||
# ═════════════════════════════════════════════════════════════════════════════
|
||||
# [7/12] VM STARTEN & QM-AGENT PRÜFEN
|
||||
# 120s in 10s-Schritten. Agent über QEMU Guest Agent Channel, kein Netzwerk.
|
||||
# Kein Agent = KEIN Abbruch, qm_agent_ok=false in DB.
|
||||
# ═════════════════════════════════════════════════════════════════════════════
|
||||
echo ""
|
||||
echo "==> [7/12] Starte VM & warte auf qm-Agent (max. 120s)..."
|
||||
qm start "$VM_ID_RESTORED" 2>/dev/null || true
|
||||
|
||||
AGENT_WAIT=0
|
||||
AGENT_MAX=120
|
||||
AGENT_INTERVAL=10
|
||||
QM_AGENT_OK="false"
|
||||
|
||||
while [[ $AGENT_WAIT -lt $AGENT_MAX ]]; do
|
||||
if [[ "$BACKUP_TYPE" == "ct" ]]; then
|
||||
pct start "$VM_ID_RESTORED" 2>/dev/null || true
|
||||
sleep 10
|
||||
# CT: prüfen ob gestartet
|
||||
if pct status "$VM_ID_RESTORED" 2>/dev/null | grep -q "running"; then
|
||||
QM_AGENT_OK="true"
|
||||
echo " CT läuft ✓"
|
||||
# Hostname aus CT holen
|
||||
CT_HOSTNAME=$(pct exec "$VM_ID_RESTORED" -- hostname 2>/dev/null || echo "unbekannt")
|
||||
echo " Hostname: $CT_HOSTNAME"
|
||||
else
|
||||
QM_AGENT_OK="false"
|
||||
echo " CT nicht gestartet – läuft weiter."
|
||||
fi
|
||||
else
|
||||
qm start "$VM_ID_RESTORED" 2>/dev/null || true
|
||||
AGENT_WAIT=0
|
||||
AGENT_MAX=120
|
||||
AGENT_INTERVAL=10
|
||||
while [[ $AGENT_WAIT -lt $AGENT_MAX ]]; do
|
||||
sleep $AGENT_INTERVAL
|
||||
AGENT_WAIT=$(( AGENT_WAIT + AGENT_INTERVAL ))
|
||||
echo -n " [${AGENT_WAIT}s/${AGENT_MAX}s] qm-Agent... "
|
||||
|
|
@ -395,55 +407,69 @@ while [[ $AGENT_WAIT -lt $AGENT_MAX ]]; do
|
|||
echo "ONLINE ✓"
|
||||
hostname_info=$(qm agent "$VM_ID_RESTORED" get-host-name 2>/dev/null \
|
||||
| grep host-name | tr -d '"' || true)
|
||||
fs_info=$(qm agent "$VM_ID_RESTORED" get-fsinfo 2>/dev/null \
|
||||
| grep mountpoint | tr -d '"' || true)
|
||||
echo " Hostname: ${hostname_info:-unbekannt}"
|
||||
echo " Mountpoints: ${fs_info:-unbekannt}"
|
||||
break
|
||||
else
|
||||
echo "nicht erreichbar."
|
||||
fi
|
||||
done
|
||||
|
||||
if [[ "$QM_AGENT_OK" == "false" ]]; then
|
||||
echo " qm-Agent nach ${AGENT_MAX}s nicht erreichbar."
|
||||
echo " → qm_agent_ok=false in DB, Restore läuft weiter."
|
||||
done
|
||||
[[ "$QM_AGENT_OK" == "false" ]] && \
|
||||
echo " qm-Agent nicht erreichbar – qm_agent_ok=false in DB."
|
||||
fi
|
||||
|
||||
# ═════════════════════════════════════════════════════════════════════════════
|
||||
# [8/12] VM STOPPEN
|
||||
# Sauberes Shutdown, nach 30s force-stop.
|
||||
# [8/13] STOPPEN
|
||||
# ═════════════════════════════════════════════════════════════════════════════
|
||||
echo ""
|
||||
echo "==> [8/12] Stoppe VM..."
|
||||
qm shutdown "$VM_ID_RESTORED" 2>/dev/null || true
|
||||
sleep 30
|
||||
qm stop "$VM_ID_RESTORED" --skiplock 1 2>/dev/null || true
|
||||
echo " VM gestoppt."
|
||||
sleep 5
|
||||
|
||||
# ═════════════════════════════════════════════════════════════════════════════
|
||||
# [9/12] 7Z-ARCHIV ERSTELLEN
|
||||
# VM-Images aus VM_IMAGE_DIR/* zippen.
|
||||
# VM-Name aus qemu-server.conf lesen → ZIP bekommt echten Namen.
|
||||
# ═════════════════════════════════════════════════════════════════════════════
|
||||
echo ""
|
||||
echo "==> [9/12] Erstelle verschlüsseltes 7z-Archiv..."
|
||||
|
||||
# Originale Config (mit Netzwerkkarten) als qemu-server.conf ins ZIP-Verzeichnis
|
||||
# legen – nicht die angepasste Config (ohne Netzwerkkarten) vom Restore-Test.
|
||||
if [[ -f "$ORIG_CONF_BACKUP" ]]; then
|
||||
cp "$ORIG_CONF_BACKUP" "${VM_IMAGE_DIR}/qemu-server.conf"
|
||||
echo " Originale Config für ZIP wiederhergestellt ✓"
|
||||
echo "==> [8/13] Stoppe $BACKUP_TYPE..."
|
||||
if [[ "$BACKUP_TYPE" == "ct" ]]; then
|
||||
pct stop "$VM_ID_RESTORED" 2>/dev/null || true
|
||||
sleep 10
|
||||
else
|
||||
echo " WARNUNG: Keine originale Config vorhanden – angepasste Config wird gezippt."
|
||||
qm shutdown "$VM_ID_RESTORED" 2>/dev/null || true
|
||||
sleep 30
|
||||
qm stop "$VM_ID_RESTORED" --skiplock 1 2>/dev/null || true
|
||||
sleep 5
|
||||
fi
|
||||
echo " Gestoppt."
|
||||
|
||||
VM_CONF="${VM_IMAGE_DIR}/qemu-server.conf"
|
||||
VM_NAME=$(grep -m1 "^name:" "$VM_CONF" 2>/dev/null \
|
||||
# ═════════════════════════════════════════════════════════════════════════════
|
||||
# [9/13] CONFIG SICHERN
|
||||
# VM: qemu-server.conf aus /etc/pve/qemu-server/
|
||||
# CT: lxc.conf aus /etc/pve/lxc/
|
||||
# Originale Config (mit Netzwerk) ins ZIP-Verzeichnis legen.
|
||||
# ═════════════════════════════════════════════════════════════════════════════
|
||||
echo ""
|
||||
echo "==> [9/13] Config sichern..."
|
||||
|
||||
if [[ "$BACKUP_TYPE" == "ct" ]]; then
|
||||
PVE_CONF="/etc/pve/lxc/${VM_ID_RESTORED}.conf"
|
||||
CONF_FILENAME="lxc.conf"
|
||||
# CT-Name aus Config lesen
|
||||
VM_NAME=$(grep -m1 "^hostname:" "$PVE_CONF" 2>/dev/null \
|
||||
| awk -F': ' '{print $2}' | tr -d '[:space:]' \
|
||||
|| echo "$SAFE_CLIENT")
|
||||
echo " VM-Name: $VM_NAME"
|
||||
else
|
||||
PVE_CONF="/etc/pve/qemu-server/${VM_ID_RESTORED}.conf"
|
||||
CONF_FILENAME="qemu-server.conf"
|
||||
VM_NAME=$(grep -m1 "^name:" "$PVE_CONF" 2>/dev/null \
|
||||
| awk -F': ' '{print $2}' | tr -d '[:space:]' \
|
||||
|| echo "$SAFE_CLIENT")
|
||||
fi
|
||||
|
||||
if [[ -f "$PVE_CONF" ]]; then
|
||||
cp "$PVE_CONF" "${IMAGE_DIR}/${CONF_FILENAME}"
|
||||
echo " Config gesichert: ${IMAGE_DIR}/${CONF_FILENAME}"
|
||||
else
|
||||
echo " WARNUNG: Config nicht gefunden: $PVE_CONF"
|
||||
fi
|
||||
echo " Name: $VM_NAME"
|
||||
|
||||
# ═════════════════════════════════════════════════════════════════════════════
|
||||
# [10/13] 7Z-ARCHIV
|
||||
# ═════════════════════════════════════════════════════════════════════════════
|
||||
echo ""
|
||||
echo "==> [10/13] Erstelle verschlüsseltes 7z-Archiv..."
|
||||
|
||||
ZIP_FILE="${ZIP_DIR}/${VM_NAME}-${VM_ID_ORIGINAL}.7z"
|
||||
ZIP_START=$(date +%s)
|
||||
|
|
@ -455,7 +481,7 @@ ZIP_START=$(date +%s)
|
|||
-p"${ZIP_PASSWORD}" \
|
||||
-mhe=on \
|
||||
"$ZIP_FILE" \
|
||||
"${VM_IMAGE_DIR}/"* \
|
||||
"${IMAGE_DIR}/"* \
|
||||
2>&1 | tail -5
|
||||
|
||||
ZIP_DURATION=$(( $(date +%s) - ZIP_START ))
|
||||
|
|
@ -463,14 +489,11 @@ ZIP_SIZE_BYTES=$(stat -c%s "$ZIP_FILE" 2>/dev/null || echo "0")
|
|||
echo " ZIP: $(( ZIP_SIZE_BYTES / 1024 / 1024 )) MB in ${ZIP_DURATION}s"
|
||||
|
||||
# ═════════════════════════════════════════════════════════════════════════════
|
||||
# [10/12] RSYNC ZUM BACKUP-SERVER
|
||||
# Zielverzeichnis aus DB (rsync_target) = Firmen-spezifischer Pfad.
|
||||
# 3 Versuche mit 60s Pause + Größenvergleich lokal vs. remote.
|
||||
# [11/13] RSYNC ZUM BACKUP-SERVER
|
||||
# ═════════════════════════════════════════════════════════════════════════════
|
||||
echo ""
|
||||
# Rsync-Ziel mit Datumsordner
|
||||
RSYNC_TARGET_DATE="${RSYNC_TARGET}/${LAST_DATE}"
|
||||
echo "==> [10/12] Rsync → ${BACKUP_SERVER_HOST}:${RSYNC_TARGET_DATE}..."
|
||||
echo "==> [11/13] Rsync → ${BACKUP_SERVER_HOST}:${RSYNC_TARGET_DATE}..."
|
||||
MAX_RETRIES=3
|
||||
|
||||
rsync_transfer() {
|
||||
|
|
@ -517,30 +540,32 @@ if [[ "$RSYNC_OK" == "true" ]]; then
|
|||
fi
|
||||
|
||||
# ═════════════════════════════════════════════════════════════════════════════
|
||||
# [11/12] AUFRÄUMEN
|
||||
# VM destroy inkl. Disks, lokale ZIP löschen.
|
||||
# Keys bleiben gecacht für nächste VM desselben Datastores.
|
||||
# [12/13] AUFRÄUMEN
|
||||
# ═════════════════════════════════════════════════════════════════════════════
|
||||
echo ""
|
||||
echo "==> [11/12] Aufräumen..."
|
||||
qm destroy "$VM_ID_RESTORED" \
|
||||
echo "==> [12/13] Aufräumen..."
|
||||
if [[ "$BACKUP_TYPE" == "ct" ]]; then
|
||||
pct destroy "$VM_ID_RESTORED" --purge 1 \
|
||||
2>/dev/null || echo " CT $VM_ID_RESTORED nicht mehr vorhanden."
|
||||
else
|
||||
qm destroy "$VM_ID_RESTORED" \
|
||||
--destroy-unreferenced-disks 1 \
|
||||
--purge 1 \
|
||||
2>/dev/null || echo " VM $VM_ID_RESTORED nicht mehr vorhanden."
|
||||
fi
|
||||
rm -f "$ZIP_FILE"
|
||||
echo " VM ${VM_ID_RESTORED} entfernt, ZIP gelöscht."
|
||||
echo " Keys gecacht in $KEY_DIR"
|
||||
echo " ${BACKUP_TYPE^^} ${VM_ID_RESTORED} entfernt, ZIP gelöscht."
|
||||
|
||||
# ── Zusammenfassung & Webhook ─────────────────────────────────────────────────
|
||||
TOTAL=$(( $(date +%s) - RESTORE_START ))
|
||||
echo ""
|
||||
echo "============================================================"
|
||||
echo " Status: $STATUS"
|
||||
echo " Typ: $BACKUP_TYPE"
|
||||
echo " Gesamtdauer: ${TOTAL}s"
|
||||
echo " VM-Name: ${VM_NAME:-$SAFE_CLIENT}"
|
||||
echo " VM_IMAGE_DIR: $VM_IMAGE_DIR"
|
||||
echo " Datastore: $DATASTORE"
|
||||
echo " qm-Agent: $QM_AGENT_OK"
|
||||
echo " Name: ${VM_NAME:-$SAFE_CLIENT}"
|
||||
echo " Image-Dir: $IMAGE_DIR"
|
||||
echo " qm-Agent/CT: $QM_AGENT_OK"
|
||||
echo " Rsync: $RSYNC_OK (Versuche: $RSYNC_RETRIES)"
|
||||
echo " ZIP: $(( ZIP_SIZE_BYTES / 1024 / 1024 )) MB"
|
||||
[[ -n "$ERROR_MSG" ]] && echo " Fehler: $ERROR_MSG"
|
||||
|
|
|
|||
Loading…
Reference in New Issue