diff --git a/README.md b/README.md index 187f0a9..b869de9 100644 --- a/README.md +++ b/README.md @@ -424,9 +424,17 @@ Links der Snapshot, rechts der lokale Rechner: | `F3` / `v` | Datei ansehen (Text oder Hex) | | `F7` / `n` | neues Verzeichnis (nur lokal) | | `F6` / `g` | Verzeichnis direkt eingeben | -| `F2` / `m` | anderes Dateisystem des Snapshots wählen | +| `F2` / `m` | Laufwerk wählen: anderes Dateisystem des Snapshots — oder ein Transfer-Laufwerk ins rechte Fenster | | `F10` / `q` | eine Ebene zurück (Snapshot wird ausgehängt) | +**`F2` holt auch Transfer-Laufwerke herein.** In derselben Liste stehen unter +den Dateisystemen des Snapshots die +[Transfer-Laufwerke](#daten-hinein-und-wieder-heraus--transfer-laufwerke); das +gewählte wird am Host eingehängt und im **rechten** Fenster geöffnet. Damit +lässt sich direkt aus einem Snapshot auf das Austauschmedium kopieren, das +anschließend in die wiederhergestellte Maschine wandert. Beim Verlassen wird es +wieder ausgehängt — sonst gälte es später als belegt. + Der Explorer hat drei Ebenen: **Gastauswahl → Snapshot-Auswahl → Dateien**. Mit `q` geht es jeweils eine Ebene zurück; beim Verlassen des Dateibrowsers wird der Snapshot wieder ausgehängt, sodass man gleich den nächsten öffnen kann. Das @@ -720,14 +728,31 @@ pvesnap-recovery cleanup # zeigt Gefundenes, fragt, räumt auf pvesnap-recovery cleanup --all # auch Datenträger ohne Elternteil ``` -Gesucht wird nach Datenträgern der Form `vm--disk-N`, zu deren VMID es -**keine Konfigurationsdatei** unter `/etc/pve/nodes/*/` mehr gibt. Bewusst +In der Oberfläche liegt das auf Taste `c`. Aufgeräumt wird in **zwei +Durchgängen**, weil zwei verschiedene Dinge liegenbleiben können. + +**1. Datenträger ohne Gast.** Gesucht wird nach Datenträgern der Form +`vm--disk-N`, zu deren VMID es **keine Konfigurationsdatei** unter +`/etc/pve/nodes/*/` mehr gibt. Bewusst nicht über `/cluster/resources`: Ein Gast auf einem abgemeldeten Node taucht dort unter Umständen nicht auf — und dann würden die Platten einer lebenden Maschine als verwaist gelten. Ohne Elternteil wird nichts von selbst entfernt, und der Schutz eines Snapshots wird nur gelöst, wenn wirklich kein Klon mehr daran hängt. +**2. Geschützte Snapshots ohne Klon.** Den Fall findet der erste Durchgang +prinzipiell nicht: Proxmox räumt beim Löschen in der Weboberfläche den Klon +durchaus mit ab — nur den Schutz des Quell-Snapshots nicht. Zurück bleibt ein +geschützter Snapshot ohne Klon, an dem die Vorhaltezeit jede Nacht scheitert, +während es keinen liegengebliebenen Datenträger gibt, nach dem man suchen +könnte. Dasselbe entsteht nach einem von Hand ausgeführten `rbd flatten`. + +Gesucht wird deshalb direkt nach der Ursache: jeder geschützte Snapshot, an dem +kein Klon hängt. Ein solcher Schutz hat keinen Zweck — er existiert einzig +dafür, dass ein Klon seine Grundlage behält. **Gelöst wird nur der Schutz, +gelöscht wird nichts**; vor jedem Lösen wird ein zweites Mal nachgesehen, ob +inzwischen doch ein Klon daran hängt. + ### Und wenn die Maschine nicht auf Ceph liegt? Das ganze Thema „Abhängigkeit vom Quell-Snapshot" ist eine **Ceph-Eigenheit**. diff --git a/handbuch/docs/bilder/config-gruppe.svg b/handbuch/docs/bilder/config-gruppe.svg index 8f9f463..acbd47b 100644 --- a/handbuch/docs/bilder/config-gruppe.svg +++ b/handbuch/docs/bilder/config-gruppe.svg @@ -15,7 +15,7 @@ -- Zeitplan ------------------------------------------------------------------------------------------------------ Art des Zeitplans taeglich Uhrzeit (HH:MM) 02:30 - Naechster Termin (Vorschau) Mo 10.08.2026 02:30 (taeglich um 02:30) + Naechster Termin (Vorschau) Mi 12.08.2026 02:30 (taeglich um 02:30) -- Vorhaltezeit -------------------------------------------------------------------------------------------------- Anzahl behalten (je VM) 14 Maximales Alter 3w diff --git a/handbuch/docs/bilder/explorer-hilfe.svg b/handbuch/docs/bilder/explorer-hilfe.svg index 20165c5..9a64093 100644 --- a/handbuch/docs/bilder/explorer-hilfe.svg +++ b/handbuch/docs/bilder/explorer-hilfe.svg @@ -15,17 +15,21 @@ F3 / v Datei ansehen (Text oder Hex) F7 / n neues Verzeichnis (nur im lokalen Fenster) F6 / g Verzeichnis direkt eingeben - F2 / m anderes Dateisystem des Snapshots waehlen - r neu einlesen - F10 / q zurueck zur Snapshot-Auswahl - Der Snapshot ist schreibgeschuetzt eingebunden - es kann nichts - kaputtgehen. Kopiert wird immer vom aktiven ins andere Fenster. - Geraetedateien und Sockets werden uebersprungen, symbolische - Verweise bleiben Verweise. - Es gibt drei Ebenen: Gastauswahl -> Snapshot-Auswahl -> Dateien. - F10 oder q geht jeweils eine Ebene zurueck; der Snapshot wird - dabei wieder ausgehaengt. Das rechte Fenster behaelt sein - Verzeichnis, auch wenn man den naechsten Snapshot oeffnet. + F2 / m Laufwerk waehlen: anderes Dateisystem des Snapshots + oder ein Transfer-Laufwerk ins rechte Fenster + r neu einlesen + F10 / q zurueck zur Snapshot-Auswahl + Der Snapshot ist schreibgeschuetzt eingebunden - es kann nichts + kaputtgehen. Kopiert wird immer vom aktiven ins andere Fenster. + Geraetedateien und Sockets werden uebersprungen, symbolische + Verweise bleiben Verweise. + Transfer-Laufwerke (F2) sind Austauschmedien fuer Maschinen ohne + Netz: hier befuellen, spaeter in die Wiederherstellung haengen. + Beim Verlassen werden sie wieder ausgehaengt. + Es gibt drei Ebenen: Gastauswahl -> Snapshot-Auswahl -> Dateien. + F10 oder q geht jeweils eine Ebene zurueck; der Snapshot wird + dabei wieder ausgehaengt. Das rechte Fenster behaelt sein + Verzeichnis, auch wenn man den naechsten Snapshot oeffnet. beliebige Taste = zurueck \ No newline at end of file diff --git a/handbuch/docs/bilder/explorer-laufwerke.svg b/handbuch/docs/bilder/explorer-laufwerke.svg new file mode 100644 index 0000000..9eed642 --- /dev/null +++ b/handbuch/docs/bilder/explorer-laufwerke.svg @@ -0,0 +1,59 @@ + + + + + + +root@pve1 — pvesnap-explorer 101 + + pvesnap-explorer - VM 101 (db01) - Snapshot auto-taeglich-20260809-023000 + + VM 101 (db01) @ auto-taeglich-20260809-023000 +│ Lokaler Rechner +/run/pvesnap/mnt/101-auto-taeglich-20260809-023000 +│/root + + etc <DIR> 06.12.24 11:42 +│ + .. <hoch> + home <DIR> 06.12.24 11:42 +│ + holen <DIR> 06.08.26 11:42 + root <DIR> 06.12.24 11:42 +│ + werkzeuge <DIR> 06.08.26 11:42 + srv <DIR> 06.12.24 11:42 +│ notizen.md 3.1K 06.08.26 11:42 + var <DIR> 06.12.24 11:42 +│ + │ + │ + │ + ┌─ + Welches Laufwerk? +───────────────────────────────────────────────────────────────────────────┐ + │ │ + │ + + Snapshot: / (ext4, 400G) - wahrscheinlich das System + │ + │ Snapshot: /boot (ext4, 1G) │ + │ Transfer: dumps 20.0G Datenbank-Dumps und Expor… [in Benutzung von 9101] │ + │ Transfer: werkzeuge 4.0G Skripte, Treiber, Install… │ + │ Transfer: austausch 8.0G Alles andere │ + │ │ + └───────────────────────────────────────────────────────────────────────────────────────────────┘ + │ + │ + │ + │ + │ + │ + │ + 5 Eintraege │ 4 Eintraege + /run/pvesnap/mnt/101-auto-taeglich-20260809-023000/etc + + Tab Fenster | Enter Oeffnen | Leer Markieren | F5 Kopieren + + F3 Ansehen | F7 Neuer Ordner | F2 Laufwerk | F10 Zurueck + \ No newline at end of file diff --git a/handbuch/docs/bilder/recovery-aufraeumen.svg b/handbuch/docs/bilder/recovery-aufraeumen.svg new file mode 100644 index 0000000..51e8c93 --- /dev/null +++ b/handbuch/docs/bilder/recovery-aufraeumen.svg @@ -0,0 +1,16 @@ + + + + + + +root@pve1 — pvesnap-recovery + + Aufraeumen +Geschuetzte Snapshots, an denen kein Klon mehr haengt: + ceph-vm:vm-105-disk-0@auto-taeglich-20260809-023000 + An diesen scheitert die Vorhaltezeit dauerhaft mit "snapshot is + protected". Der Schutz wird geloest - geloescht wird dabei nichts. + + j = aufraeumen | andere Taste = nichts tun + \ No newline at end of file diff --git a/handbuch/docs/bilder/recovery-uebersicht.svg b/handbuch/docs/bilder/recovery-uebersicht.svg index f6f455f..04dc72f 100644 --- a/handbuch/docs/bilder/recovery-uebersicht.svg +++ b/handbuch/docs/bilder/recovery-uebersicht.svg @@ -12,5 +12,7 @@ VM 9101 running pve1 VM 101 @ auto-stuendlich-20… live VM 9102 stopped pve2 VM 105 @ auto-taeglich-2026… recover - Enter Details | n Neu | s Starten | h Herunterfahren | x Verwerfen | v Laufwerke | r Aktualisieren | q Beenden + Enter Details | n Neu | s Starten | h Herunterfahren | x Verwerfen + + v Laufwerke | c Aufraeumen | r Aktualisieren | q Beenden \ No newline at end of file diff --git a/handbuch/docs/bilder/recovery-verwerfen.svg b/handbuch/docs/bilder/recovery-verwerfen.svg index 48c9172..656d3f0 100644 --- a/handbuch/docs/bilder/recovery-verwerfen.svg +++ b/handbuch/docs/bilder/recovery-verwerfen.svg @@ -13,4 +13,6 @@ VM 9102 stopped pve2 VM 105 @ auto-taeglich-2026… recover VM 9101 wirklich verwerfen? Alle Aenderungen darin sind weg. [j/n] + + v Laufwerke | c Aufraeumen | r Aktualisieren | q Beenden \ No newline at end of file diff --git a/handbuch/docs/holen/explorer.md b/handbuch/docs/holen/explorer.md index 9acd3eb..255b728 100644 --- a/handbuch/docs/holen/explorer.md +++ b/handbuch/docs/holen/explorer.md @@ -65,7 +65,7 @@ welcher Snapshot offen ist, unten der volle Pfad des markierten Eintrags. | ++f3++ oder ++v++ | Datei ansehen (Text oder Hex) | | ++f7++ oder ++n++ | neues Verzeichnis (nur im lokalen Fenster) | | ++f6++ oder ++g++ | Verzeichnis direkt eingeben | -| ++f2++ oder ++m++ | anderes Dateisystem des Snapshots wählen | +| ++f2++ oder ++m++ | [Laufwerk wählen](#laufwerk-wahlen) | | ++r++ | neu einlesen | | ++f10++ oder ++q++ | eine Ebene zurück | | ++question++ oder ++f1++ | Hilfe | @@ -126,13 +126,18 @@ Datei erst auf den Host zu holen. --- -## Mehrere Dateisysteme +## Laufwerk wählen + +++f2++ öffnet eine Liste mit zwei Arten von Einträgen: + +![Die Laufwerkswahl](../bilder/explorer-laufwerke.svg) + +### Dateisysteme des Snapshots Eine VM hat oft mehr als eine Partition: `/` und `/boot`, dazu vielleicht ein eigenes Datenlaufwerk. Hat der Snapshot mehrere brauchbare Dateisysteme, fragt -der Explorer beim Öffnen, welches er zeigen soll. - -Wechseln geht später mit ++f2++, ohne den Snapshot zu schließen. +der Explorer schon beim Öffnen, welches er zeigen soll — hier lässt sich +später ohne Schließen wechseln. !!! note "Was nicht auftaucht" @@ -140,6 +145,42 @@ Wechseln geht später mit ++f2++, ohne den Snapshot zu schließen. Kernel nicht kennt. LVM innerhalb der VM wird erkannt und aktiviert; verschlüsselte Volumes bleiben verschlüsselt. +### Austauschlaufwerke + +Darunter stehen die +[Austauschlaufwerke](../wiederherstellen/transfer.md). Wählt man eines aus, +wird es am Host eingehängt und **im rechten Fenster** geöffnet. + +Damit lässt sich aus einem Snapshot direkt auf das Austauschmedium kopieren, +das anschließend in eine [wiederhergestellte +Maschine](../wiederherstellen/index.md) wandert — ohne Umweg über +`pvesnap-recovery` und ohne Zwischenlager auf dem Host. + +
+ +**Der typische Fall:** Vor dem Notfall die Werkzeuge zusammenstellen. Snapshot +öffnen, ++f2++, Austauschlaufwerk wählen, die gebrauchten Binärdateien und +Konfigurationen hinüberkopieren. Beim nächsten `pvesnap-recovery` steht alles +bereit. + +
+ +| in der Liste | | +|---|---| +| ohne Zusatz | frei oder bereits am Host eingehängt — kann geöffnet werden | +| `[in Benutzung von 9101]` | steckt in einer Maschine. Öffnen wird abgelehnt; siehe [Host oder Gast, nie beides](../wiederherstellen/transfer.md#host-oder-gast-nie-beides) | + +Beim Verlassen des Explorers wird ein so eingehängtes Laufwerk **automatisch +wieder ausgehängt** — sonst gälte es später als belegt und ließe sich nicht in +eine Maschine hängen. Ein Laufwerk, das schon vorher am Host hing, bleibt +unangetastet. + +!!! note "Ohne Snapshot" + + Wird der Explorer aus der [Laufwerksverwaltung](../wiederherstellen/transfer.md) + heraus geöffnet, gibt es kein Snapshot-Fenster. Dann landet das gewählte + Laufwerk im **gerade aktiven** Fenster. + --- ## Aufrufparameter diff --git a/handbuch/docs/nachschlagen/befehle.md b/handbuch/docs/nachschlagen/befehle.md index 3bd50b7..6374e13 100644 --- a/handbuch/docs/nachschlagen/befehle.md +++ b/handbuch/docs/nachschlagen/befehle.md @@ -136,7 +136,7 @@ pvesnap-recovery [optionen] | `console ` | noVNC-Adresse ausgeben | | `spice ` | Verbindungsdatei für `remote-viewer` | | `flatten ` | [vom Quell-Snapshot lösen](../wiederherstellen/loesen.md) | -| `cleanup` | [Klone entfernen, zu denen es keinen Gast mehr gibt](../wiederherstellen/verwerfen.md#cleanup) | +| `cleanup` | [aufräumen: Klone ohne Gast und geschützte Snapshots ohne Klon](../wiederherstellen/verwerfen.md#cleanup) | | `destroy ` | [restlos verwerfen](../wiederherstellen/verwerfen.md) | ### Optionen von `live` und `recover` diff --git a/handbuch/docs/nachschlagen/fehlersuche.md b/handbuch/docs/nachschlagen/fehlersuche.md index 0d57daf..94931ac 100644 --- a/handbuch/docs/nachschlagen/fehlersuche.md +++ b/handbuch/docs/nachschlagen/fehlersuche.md @@ -107,6 +107,7 @@ Ceph verlangt den Schutz, solange ein Klon existiert. | Sie wird nicht mehr gebraucht | `pvesnap-recovery destroy ` | | Sie soll bleiben | `pvesnap-recovery flatten ` | | Sie wurde in der **Weboberfläche** gelöscht | `pvesnap-recovery cleanup` | +| Es gibt gar keinen Klon mehr dazu | `pvesnap-recovery cleanup` — [Durchgang 2](../wiederherstellen/verwerfen.md#durchgang-2-geschutzte-snapshots-ohne-klon) findet genau das | Der letzte Fall ist der, den man sonst nicht findet: Der Klon ist weg, der Schutz steht noch, und die Vorhaltezeit scheitert für immer. diff --git a/handbuch/docs/nachschlagen/tasten.md b/handbuch/docs/nachschlagen/tasten.md index 00a541c..a65c438 100644 --- a/handbuch/docs/nachschlagen/tasten.md +++ b/handbuch/docs/nachschlagen/tasten.md @@ -61,7 +61,7 @@ Alle Oberflächen auf einer Seite. Zum Ausdrucken und Danebenlegen. | ++f3++ ++v++ | Datei ansehen (Text oder Hex) | | ++f7++ ++n++ | neues Verzeichnis (nur lokal) | | ++f6++ ++g++ | Verzeichnis direkt eingeben | -| ++f2++ ++m++ | anderes Dateisystem des Snapshots wählen | +| ++f2++ ++m++ | Laufwerk wählen: Dateisystem des Snapshots oder Austauschlaufwerk | | ++r++ | neu einlesen | | ++f1++ ++question++ | Hilfe | | ++f10++ ++q++ | eine Ebene zurück | @@ -80,6 +80,7 @@ Während des Kopierens bricht ++esc++ ab. | ++h++ | herunterfahren | | ++x++ | verwerfen | | ++v++ | Austauschlaufwerke | +| ++c++ | aufräumen (Reste und verwaiste Snapshot-Sperren) | | ++r++ | neu einlesen | | ++q++ | Ende | diff --git a/handbuch/docs/wiederherstellen/index.md b/handbuch/docs/wiederherstellen/index.md index 232c73e..a3b5825 100644 --- a/handbuch/docs/wiederherstellen/index.md +++ b/handbuch/docs/wiederherstellen/index.md @@ -164,6 +164,7 @@ Vollständig unter [Alle Befehle](../nachschlagen/befehle.md#pvesnap-recovery). | ++s++ / ++h++ | starten / herunterfahren | | ++x++ | [verwerfen](verwerfen.md) | | ++v++ | [Austauschlaufwerke](transfer.md) | +| ++c++ | [aufräumen](verwerfen.md#cleanup) — Reste und verwaiste Snapshot-Sperren | | ++r++ | Liste neu einlesen | | ++q++ | Ende | diff --git a/handbuch/docs/wiederherstellen/transfer.md b/handbuch/docs/wiederherstellen/transfer.md index f34fa85..55fa67e 100644 --- a/handbuch/docs/wiederherstellen/transfer.md +++ b/handbuch/docs/wiederherstellen/transfer.md @@ -90,6 +90,13 @@ als beim Snapshot-Explorer, wo links Schreibschutz herrscht. Kopiert wird mit Beim Verlassen mit ++q++ wird das Laufwerk automatisch wieder ausgehängt. +!!! tip "Auch direkt aus dem Explorer erreichbar" + + Im [`pvesnap-explorer`](../holen/explorer.md#laufwerk-wahlen) öffnet ++f2++ + dieselbe Auswahl. Das Laufwerk landet dann im rechten Fenster, links steht + weiter der Snapshot — damit lässt sich **direkt aus einem Snapshot auf das + Austauschmedium kopieren**, ohne Umweg über den Host. + !!! tip "Was hineingehört" Alles, was man im Gast bräuchte und dort nicht herunterladen kann: @@ -212,6 +219,15 @@ Angelegt und verwaltet werden sie nur über die Oberfläche — dafür gibt es bewusst keine Parameter. Das ist eine Vorbereitungsaufgabe, keine, die man unter Zeitdruck tippt. +Erreichbar ist die Verwaltung von vier Stellen aus: + +| | | +|---|---| +| `pvesnap-recovery`, Übersicht | ++v++ | +| … Optionsmaske beim Anlegen | ++v++ | +| … Detailansicht einer Maschine | ++v++ | +| `pvesnap-explorer` | ++f2++ — [Laufwerk wählen](../holen/explorer.md#laufwerk-wahlen) | + --- ## Wo sie liegen diff --git a/handbuch/docs/wiederherstellen/verwerfen.md b/handbuch/docs/wiederherstellen/verwerfen.md index a42c3c1..82c7102 100644 --- a/handbuch/docs/wiederherstellen/verwerfen.md +++ b/handbuch/docs/wiederherstellen/verwerfen.md @@ -71,11 +71,14 @@ Wiederherstellung an. ## `cleanup` Wird eine Wiederherstellung in der **Proxmox-Oberfläche** entfernt statt mit -`destroy`, bleibt etwas liegen: +`destroy`, bleibt etwas liegen. Je nachdem, wie gründlich Proxmox dabei war, +zwei verschiedene Dinge — deshalb sucht `cleanup` in **zwei Durchgängen**. -* der Klon selbst kann übrigbleiben -* der Quell-Snapshot bleibt **geschützt** — die Vorhaltezeit scheitert dann - dauerhaft +Taste ++c++ in der Übersicht: + +![Der Aufräum-Bildschirm](../bilder/recovery-aufraeumen.svg) + +Oder auf der Kommandozeile: ```bash pvesnap-recovery cleanup # zeigt Gefundenes, fragt, räumt auf @@ -83,10 +86,12 @@ pvesnap-recovery cleanup --all # auch Datenträger ohne Elternteil pvesnap-recovery cleanup -y # ohne Rückfrage ``` -### Wonach gesucht wird +--- -Nach Datenträgern der Form `vm--disk-N`, zu deren VMID es **keine -Konfigurationsdatei** unter `/etc/pve/nodes/*/` mehr gibt. +### Durchgang 1: Datenträger ohne Gast + +Gesucht wird nach Datenträgern der Form `vm--disk-N`, zu deren VMID es +**keine Konfigurationsdatei** unter `/etc/pve/nodes/*/` mehr gibt. !!! info "Bewusst nicht über `/cluster/resources`" @@ -104,10 +109,52 @@ Zwei weitere Vorsichtsmaßnahmen: | **Ohne Elternteil** wird nichts von selbst entfernt | dafür braucht es `--all` | | **Der Schutz eines Snapshots wird nur gelöst**, wenn wirklich kein Klon mehr daran hängt | sonst würde ein noch lebender Klon seine Grundlage verlieren | +--- + +### Durchgang 2: Geschützte Snapshots ohne Klon + +Der Fall, den der erste Durchgang **prinzipiell nicht finden kann**. + +Löscht jemand die Wiederherstellung in der Proxmox-Oberfläche, räumt Proxmox +den Klon durchaus mit ab — aber nicht den Schutz seines Quell-Snapshots. Den +setzt es beim Klonen selbst (`rbd snap protect`, RBD verlangt ihn), und niemand +nimmt ihn wieder weg. + +Zurück bleibt ein geschützter Snapshot ohne Klon: + +!!! danger "Und danach scheitert die Vorhaltezeit für immer" + + ``` + TASK ERROR: rbd snapshot 'auto-taeglich-20260809-023000' is protected from removal + ``` + + Jede Nacht aufs Neue, an derselben Stelle. Nach einem liegengebliebenen + Datenträger sucht man dabei vergeblich — der ist ja tatsächlich weg. + +Derselbe Zustand entsteht nach einem von Hand ausgeführten `rbd flatten`: Der +Klon hängt danach an nichts mehr, der Schutz steht aber weiter. + +Gesucht wird deshalb direkt nach der Ursache: **jeder geschützte Snapshot, an +dem kein Klon hängt.** Ein solcher Schutz hat keinen Zweck — er existiert +einzig dafür, dass ein Klon seine Grundlage behält. + +!!! success "Gelöst wird nur der Schutz, gelöscht wird nichts" + + Die Snapshots bleiben stehen. Danach darf die Vorhaltezeit sie wieder + wegräumen, wenn sie alt genug sind — mehr passiert nicht. + + Vor jedem Lösen wird ein zweites Mal nachgesehen, ob inzwischen doch ein + Klon daran hängt. Zwischen Suchen und Aufräumen kann jemand eine neue + Wiederherstellung angelegt haben; der bekommt man nicht die Grundlage unter + den Füßen weg. + +--- + ### Wann man es braucht * Jemand hat eine Wiederherstellung in der Weboberfläche gelöscht * Ein `destroy` ist mittendrin abgebrochen (Host neu gestartet, Netz weg) +* Es wurde von Hand geflattet * Im Protokoll des Dienstes taucht wiederholt `snapshot is protected` auf Der letzte Fall ist der häufigste — und der, den man sonst lange sucht. diff --git a/handbuch/werkstatt/bin/pvesh b/handbuch/werkstatt/bin/pvesh index b7be346..de963e4 100755 --- a/handbuch/werkstatt/bin/pvesh +++ b/handbuch/werkstatt/bin/pvesh @@ -82,9 +82,15 @@ def handle_get(parts, args, data): "content": "iso,vztmpl,backup"}, }.get(parts[1], _MISS) if parts == ["storage"]: - return [{"storage": "ceph-vm", "type": "rbd", "shared": 1}, - {"storage": "ceph-ct", "type": "rbd", "shared": 1}, - {"storage": "local", "type": "dir", "shared": 0}] + # Die Liste traegt dieselben Felder wie der Einzelabruf - besonders + # "pool". Ohne das wuerde jeder rbd-Aufruf im Standard-Pool landen. + return [{"storage": "ceph-vm", "type": "rbd", "shared": 1, + "pool": "vmdaten", "content": "images", + "monhost": "10.20.0.11 10.20.0.12"}, + {"storage": "ceph-ct", "type": "rbd", "shared": 1, + "pool": "ctdaten", "content": "rootdir"}, + {"storage": "local", "type": "dir", "shared": 0, + "content": "iso,vztmpl,backup"}] if parts == ["cluster", "nextid"]: wanted = args.get("vmid") if wanted: diff --git a/handbuch/werkstatt/bin/rbd b/handbuch/werkstatt/bin/rbd index f67187d..9628139 100755 --- a/handbuch/werkstatt/bin/rbd +++ b/handbuch/werkstatt/bin/rbd @@ -1,67 +1,149 @@ #!/usr/bin/env python3 -"""Attrappe von `rbd` - nur lesende Auskuenfte fuer die Bildschirmfotos. +"""Attrappe von `rbd` - lesende Auskuenfte fuer Bildschirmfotos und Tests. -VM 9101 ist ein Linked Clone (haengt am Quell-Snapshot), VM 9102 ist bereits -geloest. Genau diese beiden Zustaende soll das Handbuch zeigen. +Die Kulisse enthaelt bewusst beide Zustaende, um die es beim Aufraeumen geht: + + vm-101-disk-0@auto-stuendlich-20260809-100000 geschuetzt, MIT Klon + -> muss in Ruhe gelassen werden + vm-105-disk-0@auto-taeglich-20260809-023000 geschuetzt, OHNE Klon + -> genau der Fall, den + find_stale_protections sucht + vm-100-disk-0@auto-taeglich-20260809-023000 ungeschuetzt + -> geht niemanden etwas an """ +import json import sys -VERBUNDEN = "vm-9101-disk-0" # haengt noch am Snapshot -QUELLE = "vmdaten/vm-101-disk-0@auto-stuendlich-20260809-100000" +# Abbild -> Elternteil (nur Klone haben einen) +ELTERN = { + "vm-9101-disk-0": "vmdaten/vm-101-disk-0@auto-stuendlich-20260809-100000", +} +# Abbild -> [(Snapshot, geschuetzt?)] +SNAPSHOTS = { + "vm-100-disk-0": [("auto-taeglich-20260809-023000", False)], + "vm-101-disk-0": [("auto-taeglich-20260809-023000", False), + ("auto-stuendlich-20260809-100000", True)], + "vm-105-disk-0": [("auto-taeglich-20260809-023000", True), + ("golden", False)], +} + +POOLS = { + "vmdaten": ["vm-100-disk-0", "vm-101-disk-0", "vm-102-disk-0", + "vm-105-disk-0", "vm-130-disk-0", + "vm-9101-disk-0", "vm-9102-disk-0"], + "ctdaten": ["subvol-110-disk-0", "subvol-111-disk-0"], +} + +GROESSEN = {"vm-101-disk-0": 400, "vm-105-disk-0": 250, "vm-9101-disk-0": 400} # Optionen, hinter denen noch ein Wert steht - sonst haelt man "-m " # fuer den Befehl. MIT_WERT = {"-m", "--id", "--keyring", "-c", "--conf", "-p", "--pool", - "--namespace", "-n", "--name"} + "--namespace", "-n", "--name", "--snap", "--format"} def zerlege(argv): - """(Befehl, Abbild) aus der Kommandozeile.""" - rest = [] + """(Woerter ohne Optionen, {Option: Wert}) aus der Kommandozeile.""" + rest, optionen = [], {} index = 0 while index < len(argv): wort = argv[index] if wort in MIT_WERT: + optionen[wort] = argv[index + 1] if index + 1 < len(argv) else "" index += 2 continue if wort.startswith("-"): + optionen[wort] = True index += 1 continue rest.append(wort) index += 1 - return (rest[0] if rest else ""), (rest[1] if len(rest) > 1 else "") + return rest, optionen + + +def teile(ziel): + """pool/abbild@snap -> (abbild, snap)""" + ohne_pool = ziel.split("/")[-1] + abbild, _, snap = ohne_pool.partition("@") + return abbild, snap + + +def kinder(abbild, snap): + return [k for k, eltern in ELTERN.items() + if eltern.endswith("/%s@%s" % (abbild, snap))] def main(argv): - if not argv: + rest, optionen = zerlege(argv) + if not rest: return 1 - befehl, ziel = zerlege(argv) - name = ziel.split("/")[-1].split("@")[0] + befehl = rest[0] + ziel = rest[1] if len(rest) > 1 else "" + abbild, snap = teile(ziel) + + if befehl == "ls": + for name in POOLS.get(ziel or "vmdaten", []): + print(name) + return 0 if befehl == "info": - print("rbd image '%s':" % name) - print("\tsize 400 GiB in 102400 objects") - print("\torder 22 (4 MiB objects)") - print("\tsnapshot_count: 0") - print("\tid: 1f5c3d9a7b2e") - print("\tblock_name_prefix: rbd_data.1f5c3d9a7b2e") + eltern = ELTERN.get(abbild) + gigabyte = GROESSEN.get(abbild, 32) + if optionen.get("--format") == "json": + daten = {"name": abbild, "size": gigabyte * 1024 ** 3, "format": 2, + "snapshot_count": len(SNAPSHOTS.get(abbild, []))} + if eltern: + pool, _, rest_ = eltern.partition("/") + bild, _, s = rest_.partition("@") + daten["parent"] = {"pool": pool, "image": bild, "snapshot": s} + print(json.dumps(daten)) + return 0 + print("rbd image '%s':" % abbild) + print("\tsize %d GiB in %d objects" % (gigabyte, gigabyte * 256)) print("\tformat: 2") print("\tfeatures: layering, exclusive-lock") - print("\top_features:") - print("\tflags:") - if name == VERBUNDEN: - print("\tparent: %s" % QUELLE) - print("\toverlap: 400 GiB") + if eltern: + print("\tparent: %s" % eltern) + print("\toverlap: %d GiB" % gigabyte) return 0 - if befehl == "du": + if befehl == "snap" and len(rest) > 1 and rest[1] == "ls": + abbild, _ = teile(rest[2] if len(rest) > 2 else "") + eintraege = [{"id": nummer + 1, "name": name, + "size": GROESSEN.get(abbild, 32) * 1024 ** 3, + "protected": "true" if geschuetzt else "false"} + for nummer, (name, geschuetzt) + in enumerate(SNAPSHOTS.get(abbild, []))] + if optionen.get("--format") == "json": + print(json.dumps(eintraege)) + else: + for e in eintraege: + print("%4d %-40s %10d" % (e["id"], e["name"], e["size"])) + return 0 + + if befehl == "snap" and len(rest) > 1 and rest[1] in ("unprotect", "protect"): + abbild, _ = teile(rest[2] if len(rest) > 2 else "") + name = optionen.get("--snap") or "" + vorhanden = [s for s, _ in SNAPSHOTS.get(abbild, [])] + if name not in vorhanden: + print("rbd: snapshot '%s' does not exist" % name, file=sys.stderr) + return 2 + if rest[1] == "unprotect" and kinder(abbild, name): + print("rbd: snapshot '%s' is protected from unprotection" % name, + file=sys.stderr) + return 16 + return 0 + + if befehl == "children": + for kind in kinder(abbild, snap): + print("vmdaten/%s" % kind) + return 0 + + if befehl in ("du", "flatten"): print("NAME PROVISIONED USED") - print("%-19s 400 GiB 2.4 GiB" % name) - return 0 - - if befehl in ("flatten", "snap"): + print("%-19s 400 GiB 2.4 GiB" % abbild) return 0 return 0 diff --git a/handbuch/werkstatt/run.py b/handbuch/werkstatt/run.py index 84c5feb..3b9b1a4 100755 --- a/handbuch/werkstatt/run.py +++ b/handbuch/werkstatt/run.py @@ -61,13 +61,29 @@ def _patch(): tui.service_text = lambda: "Dienst: laeuft" -def _explorer_panes(links_pfad, links_titel, untertitel, links_schreibbar=False): +class Kulissensession: + """Genau so viel Sitzung, wie der Explorer fuer die Laufwerkswahl braucht. + + Eine echte Session wuerde einen Snapshot einbinden - dafuer braucht es + Ceph. Der Explorer fasst sie nur an zwei Stellen an: um die Dateisysteme + aufzuzaehlen und um zu wissen, welches Fenster der Snapshot ist. + """ + mounts = {"root": 1, "boot": 1} + + @staticmethod + def mount_entries(): + return [(SNAP_MNT, "/ (ext4, 400G) - wahrscheinlich das System"), + (SNAP_MNT + "-boot", "/boot (ext4, 1G)")] + + +def _explorer_panes(links_pfad, links_titel, untertitel, links_schreibbar=False, + session=None): from pvesnap.explorer import Explorer, Pane links = Pane(path=links_pfad, root=links_pfad, readonly=not links_schreibbar, title=links_titel) rechts = Pane(path=_oder(LOKAL, os.path.join(DEMO, "lokal")), root="/", readonly=False, title="Lokaler Rechner") - return Explorer(links, rechts, subtitle=untertitel) + return Explorer(links, rechts, session=session, subtitle=untertitel) # --------------------------------------------------------------------------- @@ -98,8 +114,8 @@ def szene_transfer(stdscr): def szene_explorer(stdscr): _explorer_panes(_oder(SNAP_MNT, os.path.join(DEMO, "snapshot")), "VM 101 (db01) @ auto-taeglich-20260809-023000", - "VM 101 (db01) - Snapshot auto-taeglich-20260809-023000" - ).run(stdscr) + "VM 101 (db01) - Snapshot auto-taeglich-20260809-023000", + session=Kulissensession()).run(stdscr) def szene_explorer_transfer(stdscr): diff --git a/handbuch/werkstatt/scenes.py b/handbuch/werkstatt/scenes.py index 0d23007..b7b2133 100755 --- a/handbuch/werkstatt/scenes.py +++ b/handbuch/werkstatt/scenes.py @@ -51,6 +51,8 @@ AUFNAHMEN = [ ("explorer-ansehen", "explorer", ["enter", "ab", "ab", "ab", "ab", "f3"], "root@pve1 — pvesnap-explorer 101"), + ("explorer-laufwerke", "explorer", ["f2"], + "root@pve1 — pvesnap-explorer 101"), ("explorer-hilfe", "explorer", ["?"], "root@pve1 — pvesnap-explorer 101"), @@ -79,6 +81,8 @@ AUFNAHMEN = [ "root@pve1 — pvesnap-recovery", 4.0), ("recovery-verwerfen", "recovery", ["x"], "root@pve1 — pvesnap-recovery"), + ("recovery-aufraeumen", "recovery", ["c"], + "root@pve1 — pvesnap-recovery", 3.0), # -- Austauschlaufwerke ------------------------------------------------- ("transfer-uebersicht", "transfer", [], diff --git a/pvesnap/explorer.py b/pvesnap/explorer.py index e2835ac..183bdc0 100644 --- a/pvesnap/explorer.py +++ b/pvesnap/explorer.py @@ -29,6 +29,7 @@ from dataclasses import dataclass, field from datetime import datetime from . import __version__ +from . import transfer from .curses_util import (C_DIM, C_DIR, C_FOOTER, C_HEADER, C_MARK, C_OK, C_SEL, C_WARN, ask, choose, confirm, fill, init_colors, is_enter, is_escape, keybar, message, prompt, put, read_key) @@ -378,6 +379,10 @@ class Explorer: self.session = session self.subtitle = subtitle self.status = "" + # Transfer-Laufwerke, die *wir* eingehaengt haben. Nur die haengen wir + # beim Verlassen wieder aus - ein Laufwerk, das schon vorher am Host + # hing, gehoert jemand anderem. + self.mounted_transfers = set() @property def source(self): @@ -494,7 +499,15 @@ class Explorer: def run(self, win): for pane in self.panes: pane.reload() + try: + self._loop(win) + finally: + # Auch bei Absturz oder Strg-C: ein Transfer-Laufwerk, das am Host + # eingehaengt bleibt, gilt spaeter als belegt und laesst sich dann + # nicht in eine Maschine haengen. + self._release_transfers() + def _loop(self, win): while True: self.draw(win) win.refresh() @@ -661,14 +674,85 @@ class Explorer: message(win, "Kein Verzeichnis: %s" % path, error=True) def _switch_mount(self, win): - if not self.session or len(self.session.mounts) < 2: - message(win, "Es ist nur ein Dateisystem eingebunden.") + """Laufwerk waehlen - Dateisystem des Snapshots oder Transfer-Laufwerk. + + Beides steht in derselben Liste, weil es aus Sicht des Bedieners + dieselbe Frage ist: "wo soll ich hinschauen?". Ein Transfer-Laufwerk + hier zu erreichen spart den Umweg ueber pvesnap-recovery - man kann + aus dem Snapshot direkt auf das Austauschmedium kopieren, das + anschliessend in die wiederhergestellte Maschine wandert. + """ + entries = [] + + filesystems = self.session.mount_entries() if self.session else [] + if len(filesystems) > 1: + for path, text in filesystems: + entries.append((("fs", path), "Snapshot: %s" % text)) + + for volume in self._transfer_volumes(): + state = "" if volume.free or volume.mountpoint \ + else " [%s]" % volume.state_text + entries.append((("transfer", volume.name), + "Transfer: %-14s %8s %s%s" + % (volume.name, human_bytes(volume.size), + truncate(volume.note, 26), state))) + + if not entries: + message(win, "Es ist nur ein Dateisystem eingebunden, und " + "Transfer-Laufwerke gibt es noch keine.") return - entries = self.session.mount_entries() - chosen = choose(win, "Welches Dateisystem?", entries) - if chosen: - self.panes[0].root = chosen - self.panes[0].go(chosen) + + chosen = choose(win, "Welches Laufwerk?", entries) + if not chosen: + return + kind, value = chosen + if kind == "fs": + self.panes[0].root = value + self.panes[0].go(value) + else: + self._open_transfer(win, value) + + def _transfer_volumes(self): + try: + return transfer.load() + except transfer.TransferError as exc: + self.status = str(exc) + return [] + + def _open_transfer(self, win, name): + """Ein Transfer-Laufwerk einhaengen und ins Arbeitsfenster holen. + + Ins Arbeitsfenster, nicht ins Snapshot-Fenster: links steht der + Snapshot, aus dem geholt wird, rechts das Ziel. Genau dorthin gehoert + ein Austauschmedium. Gibt es keinen Snapshot (Aufruf aus der + Laufwerksverwaltung heraus), landet es im gerade aktiven Fenster. + """ + target = self.panes[1] if self.session else self.source + try: + already = bool(transfer.get(name).mountpoint) + path = transfer.host_mount(name) + except transfer.TransferError as exc: + message(win, str(exc), error=True) + return + if not already: + self.mounted_transfers.add(name) + + target.root = "/" + target.marks.clear() + if not target.go(path): + message(win, "Eingehaengt unter %s, aber nicht lesbar." % path, error=True) + return + target.title = "Transfer: %s" % name + self.status = "%s eingehaengt unter %s" % (name, path) + + def _release_transfers(self): + """Was wir eingehaengt haben, geben wir auch wieder frei.""" + for name in sorted(self.mounted_transfers): + try: + transfer.host_umount(name) + except transfer.TransferError as exc: + log.warning("Transfer-Laufwerk %s blieb eingehaengt: %s", name, exc) + self.mounted_transfers.clear() def _view(self, win, entry): if not entry.name or entry.is_dir or entry.is_special: @@ -732,7 +816,8 @@ class Explorer: "F3 / v Datei ansehen (Text oder Hex)", "F7 / n neues Verzeichnis (nur im lokalen Fenster)", "F6 / g Verzeichnis direkt eingeben", - "F2 / m anderes Dateisystem des Snapshots waehlen", + "F2 / m Laufwerk waehlen: anderes Dateisystem des Snapshots", + " oder ein Transfer-Laufwerk ins rechte Fenster", "r neu einlesen", "F10 / q zurueck zur Snapshot-Auswahl", "", @@ -741,6 +826,10 @@ class Explorer: "Geraetedateien und Sockets werden uebersprungen, symbolische", "Verweise bleiben Verweise.", "", + "Transfer-Laufwerke (F2) sind Austauschmedien fuer Maschinen ohne", + "Netz: hier befuellen, spaeter in die Wiederherstellung haengen.", + "Beim Verlassen werden sie wieder ausgehaengt.", + "", "Es gibt drei Ebenen: Gastauswahl -> Snapshot-Auswahl -> Dateien.", "F10 oder q geht jeweils eine Ebene zurueck; der Snapshot wird", "dabei wieder ausgehaengt. Das rechte Fenster behaelt sein", diff --git a/pvesnap/recovery.py b/pvesnap/recovery.py index 8fafc00..3d6aa2b 100644 --- a/pvesnap/recovery.py +++ b/pvesnap/recovery.py @@ -1535,18 +1535,7 @@ def find_orphans(proxmox): "stimmen. Zur Sicherheit wird nichts angefasst." % CONF_ROOT) found = [] - for storage in proxmox._json(["get", "/storage"]) or []: - if storage.get("type") != "rbd": - continue - name = storage.get("storage") - context = _rbd_context(proxmox, "%s:dummy" % name) - if context is None: - continue - args, _ = context - pool = storage.get("pool") or "rbd" - namespace = storage.get("namespace") - prefix = "%s/%s" % (pool, (namespace + "/") if namespace else "") - + for name, args, pool, prefix in _rbd_storages(proxmox): for image in run(args + ["ls", pool.rstrip("/")], check=False, timeout=120).splitlines(): image = image.strip() @@ -1605,6 +1594,118 @@ def remove_orphans(proxmox, orphans, progress=None): return removed, failed +def _is_protected(entry): + """rbd meldet das je nach Version als true oder als "true".""" + value = entry.get("protected") + return value is True or str(value).strip().lower() == "true" + + +def _rbd_storages(proxmox): + """[(Name, rbd-Basisbefehl, Praefix pool/[namespace/])] aller Ceph-Storages.""" + result = [] + for storage in proxmox._json(["get", "/storage"]) or []: + if storage.get("type") != "rbd": + continue + name = storage.get("storage") + context = _rbd_context(proxmox, "%s:dummy" % name) + if context is None: + continue + args, _ = context + pool = storage.get("pool") or "rbd" + namespace = storage.get("namespace") + result.append((name, args, pool, + "%s/%s" % (pool, (namespace + "/") if namespace else ""))) + return result + + +def find_stale_protections(proxmox, progress=None): + """Geschuetzte Snapshots, an denen kein Klon mehr haengt. + + Der Fall, den find_orphans() nicht findet: Wird eine Wiederherstellung in + der Proxmox-Oberflaeche geloescht, raeumt Proxmox den Klon durchaus mit ab - + aber nicht den Schutz seines Quell-Snapshots. Den setzt es beim Klonen + selbst (`rbd snap protect`, RBD verlangt ihn), und niemand nimmt ihn wieder + weg. Zurueck bleibt ein geschuetzter Snapshot ohne Klon: Die Vorhaltezeit + scheitert an ihm fuer immer mit "snapshot is protected", und nach einem + liegengebliebenen Datentraeger sucht man vergeblich - der ist ja wirklich + weg. + + Dasselbe entsteht nach einem von Hand ausgefuehrten `rbd flatten`: der Klon + haengt danach an nichts mehr, der Schutz steht aber weiter. + + Ein geschuetzter Snapshot ohne Kinder hat keinen Zweck - der Schutz + existiert einzig, damit ein Klon seine Grundlage behaelt. + """ + def step(text): + if progress: + progress(text) + + found = [] + for name, args, pool, prefix in _rbd_storages(proxmox): + images = [line.strip() for line + in run(args + ["ls", pool.rstrip("/")], check=False, + timeout=120).splitlines() if line.strip()] + step("%s: %d Datentraeger" % (name, len(images))) + for image in images: + try: + snapshots = json.loads( + run(args + ["snap", "ls", prefix + image, "--format", "json"], + check=False, timeout=60, quiet=True) or "[]") + except ValueError: + continue + if not isinstance(snapshots, list): + continue + for snapshot in snapshots: + if not _is_protected(snapshot): + continue + snapname = str(snapshot.get("name") or "") + if not snapname: + continue + target = "%s%s@%s" % (prefix, image, snapname) + if run(args + ["children", target], check=False, + timeout=120, quiet=True).strip(): + continue # da haengt noch etwas dran - gut so + found.append({ + "volid": "%s:%s" % (name, image), + "snapshot": snapname, + "image": prefix + image, + "bytes": int(snapshot.get("size") or 0), + "args": args, + }) + return found + + +def release_protections(proxmox, entries, progress=None): + """Den Schutz der gefundenen Snapshots loesen. + + Loescht nichts - danach darf die Vorhaltezeit den Snapshot wieder + wegraeumen, mehr passiert nicht. + """ + def step(text): + log.info("%s", text) + if progress: + progress(text) + + released, failed = [], [] + for entry in entries: + target = "%s@%s" % (entry["image"], entry["snapshot"]) + # Zwischen Suchen und Freigeben kann jemand einen Klon angelegt haben. + # Ein zweiter Blick kostet nichts und verhindert, dass wir einem + # frischen Klon die Grundlage unter den Fuessen wegziehen. + if run(entry["args"] + ["children", target], check=False, + timeout=120, quiet=True).strip(): + failed.append("%s: haengt inzwischen wieder ein Klon daran" % target) + continue + step("Hebe Schutz von %s auf" % target) + try: + run(entry["args"] + ["snap", "unprotect", entry["image"], + "--snap", entry["snapshot"]], timeout=120) + released.append(target) + except RecoveryError as exc: + failed.append("%s: %s" % (target, exc)) + return released, failed + + def destroy(proxmox, instance, progress=None, keep_snapshot_protection=False): """Eine Wiederherstellung restlos entfernen.""" def step(text): diff --git a/pvesnap/recovery_ui.py b/pvesnap/recovery_ui.py index e77f869..c06fda5 100644 --- a/pvesnap/recovery_ui.py +++ b/pvesnap/recovery_ui.py @@ -29,10 +29,11 @@ from .curses_util import (C_DIM, C_FOOTER, C_HEADER, C_MARK, C_OK, C_SEL, C_WARN from .proxmox import Proxmox, ProxmoxError, pvesh_available from . import transfer, transfer_ui from .recovery import (RecoveryError, Spec, create, destroy, eject_transfer, - find_orphans, flatten, flatten_cost, flatten_hint, + find_orphans, find_stale_protections, flatten, + flatten_cost, flatten_hint, human_bytes, insert_transfer, linked_volumes, display_state, list_instances, node_address, plan, - remove_orphans, set_display, + release_protections, remove_orphans, set_display, spice_file, start, transfer_state) from .snapfs import list_snapshots from .util import truncate @@ -46,6 +47,7 @@ KEYS = [ ("h", "Herunterfahren", "Stop"), ("x", "Verwerfen", "Verwerf."), ("v", "Laufwerke", "Laufw."), + ("c", "Aufraeumen", "Aufr."), ("r", "Aktualisieren", "Aktual."), ("q", "Beenden", "Ende"), ] @@ -878,6 +880,9 @@ def _overview(stdscr, proxmox): elif key in ("v", "V"): transfer_ui.screen(stdscr, browse=_browse_transfer) reload_ = True + elif key in ("c", "C"): + _cleanup(stdscr, proxmox) + reload_ = True elif key in ("r", "R"): reload_ = True elif key == curses.KEY_UP and instances: @@ -901,6 +906,80 @@ def _overview(stdscr, proxmox): reload_ = True +def _cleanup(stdscr, proxmox): + """Reste aufraeumen, die entstehen, wenn jemand an pvesnap vorbei loescht. + + Zwei verschiedene Dinge, deshalb zwei Durchgaenge: liegengebliebene + Datentraeger - und geschuetzte Snapshots, deren Klon es nicht mehr gibt. + Den zweiten Fall findet die Suche nach Datentraegern prinzipiell nicht. + """ + _wait_screen(stdscr, "Suche liegengebliebene Datentraeger ...") + try: + orphans = find_orphans(proxmox) + except (RecoveryError, ProxmoxError) as exc: + message(stdscr, str(exc), error=True) + return + + fortschritt = _Progress(stdscr, "Suche geschuetzte Snapshots ohne Klon") + try: + stale = find_stale_protections(proxmox, progress=fortschritt) + except (RecoveryError, ProxmoxError) as exc: + message(stdscr, str(exc), error=True) + return + + klone = [e for e in orphans if e["parent"]] + if not klone and not stale: + message(stdscr, "Nichts liegengeblieben - alles sauber.") + return + + zeilen = [] + if klone: + zeilen.append(("Datentraeger, zu denen es keinen Gast mehr gibt:", curses.A_BOLD)) + for entry in klone: + zeilen.append((" %-26s %8s Klon von %s" + % (entry["volid"], human_bytes(entry["bytes"]), + entry["parent"]), curses.color_pair(C_MARK))) + zeilen.append(("", 0)) + if stale: + zeilen.append(("Geschuetzte Snapshots, an denen kein Klon mehr haengt:", + curses.A_BOLD)) + for entry in stale: + zeilen.append((" %s@%s" % (entry["volid"], entry["snapshot"]), + curses.color_pair(C_MARK))) + zeilen.append(("", 0)) + for text in _wrap("An diesen scheitert die Vorhaltezeit dauerhaft mit " + "\"snapshot is protected\". Der Schutz wird geloest - " + "geloescht wird dabei nichts.", 74): + zeilen.append((text, curses.color_pair(C_DIM))) + zeilen.append(("", 0)) + + ohne_eltern = [e for e in orphans if not e["parent"]] + if ohne_eltern: + for text in _wrap("Ausserdem liegen %d Datentraeger ohne Elternteil herum. " + "Die werden hier nicht angefasst - dafuer gibt es " + "'pvesnap-recovery cleanup --all'." % len(ohne_eltern), 74): + zeilen.append((text, curses.color_pair(C_DIM))) + + taste = _pages(stdscr, zeilen, "Aufraeumen", + "j = aufraeumen | andere Taste = nichts tun") + if taste not in ("j", "J", "y", "Y"): + return + + fortschritt = _Progress(stdscr, "Raeume auf") + bericht = [] + if klone: + entfernt, gescheitert = remove_orphans(proxmox, klone, progress=fortschritt) + bericht.append("%d Datentraeger entfernt." % len(entfernt)) + bericht += [" fehlgeschlagen: %s" % p for p in gescheitert] + if stale: + geloest, gescheitert = release_protections(proxmox, stale, + progress=fortschritt) + bericht.append("%s geloest." % _anzahl(len(geloest), "Schutzmarke", + "Schutzmarken")) + bericht += [" fehlgeschlagen: %s" % p for p in gescheitert] + _pages(stdscr, _plain(bericht), "Fertig") + + def _browse_transfer(win, path, volume): """Den Zwei-Fenster-Commander auf ein Transfer-Laufwerk loslassen. @@ -1119,9 +1198,23 @@ def cmd_flatten(proxmox, args): def cmd_cleanup(proxmox, args): + """Zwei Durchgaenge - sie finden verschiedene Dinge. + + Der erste sucht Datentraeger ohne Gast. Der zweite geschuetzte Snapshots + ohne Klon: die findet der erste prinzipiell nicht, weil es dazu keinen + Datentraeger mehr gibt, nach dem er suchen koennte. + """ + schlecht = _cleanup_volumes(proxmox, args) + print() + schlecht += _cleanup_protections(proxmox, args) + return 1 if schlecht else 0 + + +def _cleanup_volumes(proxmox, args): + """Liegengebliebene Datentraeger. Liefert die Zahl der Fehlschlaege.""" orphans = find_orphans(proxmox) if not orphans: - print("Nichts liegengeblieben.") + print("Keine liegengebliebenen Datentraeger.") return 0 clones = [e for e in orphans if e["parent"]] @@ -1158,6 +1251,39 @@ def cmd_cleanup(proxmox, args): return 1 if failed else 0 +def _anzahl(zahl, einzahl, mehrzahl): + return "%d %s" % (zahl, einzahl if zahl == 1 else mehrzahl) + + +def _cleanup_protections(proxmox, args): + """Geschuetzte Snapshots ohne Klon. Liefert die Zahl der Fehlschlaege.""" + print("Suche geschuetzte Snapshots ohne Klon ...") + stale = find_stale_protections(proxmox, + progress=lambda text: print(" " + text)) + if not stale: + print("Keine gefunden.") + return 0 + + print("\nGeschuetzte Snapshots, an denen kein Klon mehr haengt:\n") + for entry in stale: + print(" %s@%s" % (entry["volid"], entry["snapshot"])) + + print("\nAn diesen scheitert die Vorhaltezeit dauerhaft mit\n" + "\"snapshot is protected\". Der Schutz wird geloest - geloescht wird\n" + "dabei nichts, die Snapshots bleiben stehen.") + if not args.yes: + if _ask("\nSchutz loesen? [j/N] ") not in ("j", "y", "ja", "yes"): + print("Abgebrochen.") + return 0 + + released, failed = release_protections( + proxmox, stale, progress=lambda text: print(" " + text)) + print("\n%s geloest." % _anzahl(len(released), "Schutzmarke", "Schutzmarken")) + for problem in failed: + print(" fehlgeschlagen: %s" % problem, file=sys.stderr) + return 1 if failed else 0 + + def cmd_spice(proxmox, args): instance = _find_instance(proxmox, args.vmid) text = spice_file(proxmox, instance)