# Snapper Anleitung für CachyOS - Detaillierte Version

## Was ist Snapper?

Snapper ist ein Tool für BTRFS-Dateisysteme, das automatisch Snapshots (Momentaufnahmen) erstellt. Diese Snapshots sind wie "Wiederherstellungspunkte" - sie speichern den Zustand deines Systems zu einem bestimmten Zeitpunkt, ohne zusätzlichen Speicherplatz für unveränderte Dateien zu verbrauchen.

## Installation mit pacman

```bash
# Hauptpakete installieren
sudo pacman -S snapper          # Das eigentliche Snapper-Tool
sudo pacman -S snap-pac         # Automatische Snapshots bei pacman-Operationen
sudo pacman -S snapper-gui-git  # Grafische Benutzeroberfläche (optional)

# Optional: Für GRUB-Integration (Boot-Menü mit Snapshots)
sudo pacman -S grub-btrfs       # Zeigt Snapshots im GRUB-Boot-Menü an
```

## Grundkonfiguration verstehen

### 1. Snapper-Konfiguration für Root erstellen

```bash
# Falls bereits eine Konfiguration existiert, diese entfernen
sudo umount /.snapshots 2>/dev/null || true
sudo rm -rf /.snapshots

# Neue Snapper-Konfiguration für das Root-Dateisystem erstellen
# Dies erstellt automatisch eine Konfigurationsdatei unter /etc/snapper/configs/root
sudo snapper -c root create-config /

# Das automatisch erstellte .snapshots Verzeichnis ist ein normaler Ordner
# Wir brauchen aber ein BTRFS-Subvolume für bessere Performance
sudo btrfs subvolume delete /.snapshots
sudo mkdir /.snapshots

# Subvolume in /etc/fstab eintragen (wird automatisch gemacht)
sudo mount -a
```

**Was passiert hier?**
- `-c root` = Konfigurationsname "root" 
- `create-config /` = Erstelle Konfiguration für das Verzeichnis `/`
- Ein BTRFS-Subvolume ist effizienter als ein normaler Ordner für Snapshots

### 2. Konfigurationsdatei im Detail

```bash
sudo nano /etc/snapper/configs/root
```

**Wichtige Parameter erklärt:**

```ini
# SUBVOLUME: Das zu überwachende Verzeichnis
SUBVOLUME="/"

# FSTYPE: Dateisystemtyp (muss btrfs sein)
FSTYPE="btrfs"

# ALLOW_USERS/ALLOW_GROUPS: Welche Benutzer dürfen Snapshots verwalten?
ALLOW_USERS="dein-benutzername"
ALLOW_GROUPS="wheel"

# SYNC_ACL: Access Control Lists synchronisieren
SYNC_ACL="no"

# === TIMELINE SNAPSHOTS (zeitbasierte automatische Snapshots) ===

# TIMELINE_CREATE: Sollen automatische zeitbasierte Snapshots erstellt werden?
TIMELINE_CREATE="yes"

# TIMELINE_CLEANUP: Sollen alte Timeline-Snapshots automatisch gelöscht werden?
TIMELINE_CLEANUP="yes"

# Wie viele Timeline-Snapshots sollen behalten werden?
TIMELINE_MIN_AGE="1800"      # Mindestens 30 Minuten alt bevor Löschung möglich
TIMELINE_LIMIT_HOURLY="10"   # Maximal 10 stündliche Snapshots
TIMELINE_LIMIT_DAILY="10"    # Maximal 10 tägliche Snapshots  
TIMELINE_LIMIT_WEEKLY="0"    # Keine wöchentlichen Snapshots
TIMELINE_LIMIT_MONTHLY="10"  # Maximal 10 monatliche Snapshots
TIMELINE_LIMIT_YEARLY="10"   # Maximal 10 jährliche Snapshots

# === NUMBER CLEANUP (Bereinigung nach Anzahl) ===

# NUMBER_CLEANUP: Snapshots nach Anzahl begrenzen?
NUMBER_CLEANUP="yes"

# NUMBER_MIN_AGE: Snapshots müssen mindestens so alt sein (Sekunden)
NUMBER_MIN_AGE="1800"        # 30 Minuten

# NUMBER_LIMIT: Maximale Gesamtanzahl an Snapshots
NUMBER_LIMIT="50"

# NUMBER_LIMIT_IMPORTANT: Wichtige Snapshots (pre/post) getrennt begrenzen
NUMBER_LIMIT_IMPORTANT="10"

# === EMPTY CLEANUP (leere Snapshots löschen) ===
EMPTY_PRE_POST_CLEANUP="yes" # Leere Pre/Post-Snapshot-Paare löschen
EMPTY_PRE_POST_MIN_AGE="1800"
```

**Was bedeuten die verschiedenen Snapshot-Typen?**
- **Timeline**: Automatisch nach Zeit erstellt (stündlich, täglich, etc.)
- **Pre/Post**: Vor und nach Systemänderungen (z.B. Package-Updates)
- **Single**: Einzelne manuelle Snapshots

## Ein- und Ausgeschlossene Verzeichnisse verstehen

### Automatisch eingeschlossene Verzeichnisse

Standardmäßig wird **alles unter `/` gesnappt**, außer:

```bash
# Diese Verzeichnisse werden NIEMALS gesnappt (hardcoded in Snapper):
/dev/*      # Device-Dateien (virtuelle Dateien)
/proc/*     # Process-Informationen (virtuelle Dateien)  
/sys/*      # System-Informationen (virtuelle Dateien)
/tmp/*      # Temporäre Dateien
/run/*      # Runtime-Daten
/mnt/*      # Mount-Punkte
/media/*    # Wechseldatenträger
```

### Zusätzliche Ausschlüsse konfigurieren

**Option 1: Exclude-Patterns in der Hauptkonfiguration**

```bash
sudo nano /etc/snapper/configs/root
```

Füge hinzu:
```ini
# EXCLUDE_PATTERNS: Glob-Patterns für auszuschließende Dateien/Ordner
EXCLUDE_PATTERNS="/var/cache/* /var/tmp/* /var/log/* /home/*/.cache/* /root/.cache/*"
```

**Option 2: Separate Filter-Datei (empfohlen)**

```bash
# Filter-Datei erstellen
sudo mkdir -p /etc/snapper/filters
sudo nano /etc/snapper/filters/root.txt
```

Inhalt mit Erklärungen:
```bash
# Cache-Verzeichnisse (können jederzeit neu erstellt werden)
/var/cache/*
/home/*/.cache/*
/root/.cache/*

# Temporäre Dateien
/var/tmp/*
/tmp/*

# Log-Dateien (werden laufend überschrieben, Snapshots wenig sinnvoll)
/var/log/*

# Browser-Profile (sehr große, häufig ändernde Dateien)
/home/*/.mozilla/firefox/*/Cache/*
/home/*/.config/google-chrome/Default/Cache/*

# Papierkorb
/home/*/.local/share/Trash/*

# Downloads (optional - je nach Bedarf)
# /home/*/Downloads/*

# Virtuelle Maschinen (sehr groß)
/home/*/.local/share/libvirt/*
/var/lib/libvirt/*

# Docker-Daten (sehr groß und dynamisch)
/var/lib/docker/*
```

Dann in der Hauptkonfiguration referenzieren:
```ini
# In /etc/snapper/configs/root hinzufügen:
EXCLUDE_FILE="/etc/snapper/filters/root.txt"
```

### Warum diese Ausschlüsse?

- **Cache-Verzeichnisse**: Werden automatisch neu erstellt, verschwenden nur Platz
- **Log-Dateien**: Ändern sich ständig, Snapshots helfen nicht bei der Fehlersuche
- **Temporäre Dateien**: Per Definition temporär
- **Browser-Caches**: Riesig und unwichtig für System-Recovery
- **VM/Docker-Daten**: Sehr groß, haben eigene Backup-Strategien

## Manuelle Snapshots erstellen

### Einfache Snapshots

```bash
# Einfacher Snapshot mit Beschreibung
sudo snapper -c root create -d "Vor Firefox-Installation"

# Snapshot mit benutzerdefinierten Attributen
sudo snapper -c root create -d "Backup vor Kernel-Update" -u "important=yes"
```

### Pre/Post-Snapshot-Paare (empfohlen für größere Änderungen)

```bash
# 1. PRE-Snapshot erstellen (vor der Änderung)
sudo snapper -c root create -t pre -p -d "Vor großem System-Update"
# Merke dir die Nummer! Z.B. "42"

# 2. Deine Systemänderungen durchführen
sudo pacman -Syu

# 3. POST-Snapshot erstellen (nach der Änderung)
sudo snapper -c root create -t post --pre-number 42 -d "Nach großem System-Update"
```

**Warum Pre/Post-Paare?**
- Snapper kann exakt die Unterschiede zwischen vorher/nachher zeigen
- Einfacheres Rollback nur der Änderungen
- Bessere Übersicht was sich geändert hat

### Snapshots verwalten

```bash
# Alle Snapshots auflisten
sudo snapper -c root list

# Detaillierte Ansicht mit Größe
sudo snapper -c root list -t all

# Informationen zu einem bestimmten Snapshot
sudo snapper -c root info 42

# Unterschiede zwischen zwei Snapshots anzeigen
sudo snapper -c root status 40..45

# Geänderte Dateien zwischen Snapshots zeigen
sudo snapper -c root diff 40..45
```

## Automatisierung der Snapshot-Erstellung

### 1. Timeline-Snapshots (zeitbasiert)

```bash
# Systemd-Timer für stündliche Timeline-Snapshots aktivieren
sudo systemctl enable --now snapper-timeline.timer

# Timer für automatische Bereinigung alter Snapshots aktivieren  
sudo systemctl enable --now snapper-cleanup.timer

# Status der Timer prüfen
systemctl status snapper-timeline.timer
systemctl status snapper-cleanup.timer

# Nächste geplante Ausführung anzeigen
systemctl list-timers | grep snapper
```

**Was macht snapper-timeline.timer?**
- Läuft stündlich
- Erstellt automatisch Timeline-Snapshots basierend auf der Konfiguration
- Berücksichtigt die TIMELINE_LIMIT-Einstellungen

**Was macht snapper-cleanup.timer?**
- Läuft täglich
- Löscht alte Snapshots basierend auf den Cleanup-Regeln
- Verhindert, dass das System mit Snapshots volläuft

### 2. Automatische Snapshots bei Package-Updates

Das Paket `snap-pac` erstellt automatisch Pre/Post-Snapshots bei jeder pacman-Operation.

```bash
# Konfiguration von snap-pac anpassen
sudo nano /etc/snap-pac.ini
```

```ini
[DEFAULT]
# Maximale Länge der Snapshot-Beschreibung
desc_limit = 72

# Standard-Beschreibungen für automatische Snapshots
pre_description = pacman pre snapshot
post_description = pacman post snapshot

# Soll snap-pac auch bei AUR-Helper-Updates Snapshots erstellen?
aur_helper = yay,paru,pikaur

[root]
# Snapshots für das root-Subvolume aktivieren
snapshot = yes

# Welche Cleanup-Strategie verwenden?
cleanup = number

# Soll snap-pac auch bei normalen pacman-Operationen (nicht nur -S) Snapshots erstellen?
important = yes
```

**Was passiert jetzt?**
- Bei jedem `sudo pacman -S paket` → automatisches Pre/Post-Snapshot-Paar
- Bei `yay -S aur-paket` → ebenfalls Snapshots (wenn konfiguriert)
- Bei `sudo pacman -R paket` → ebenfalls Snapshots

### 3. GRUB-Integration für Boot-Menü

```bash
# GRUB-Btrfs-Daemon aktivieren (überwacht Snapshot-Änderungen)
sudo systemctl enable --now grub-btrfsd

# Initramfs-Hook für Snapshot-Booting hinzufügen
sudo nano /etc/mkinitcpio.conf
```

In der HOOKS-Zeile hinzufügen:
```bash
HOOKS=(base udev autodetect modconf kms keyboard keymap consolefont block filesystems grub-btrfs-overlayfs fsck)
```

```bash
# Initramfs neu generieren
sudo mkinitcpio -P

# GRUB-Konfiguration aktualisieren
sudo grub-mkconfig -o /boot/grub/grub.cfg
```

**Was bringt das?**
- Im GRUB-Boot-Menü erscheint ein neuer Eintrag "Snapshots for GNU/Linux"
- Du kannst direkt von einem Snapshot booten ohne das System zu ändern
- Perfekt um zu testen, ob ein älterer Zustand das Problem löst

## Snapshots wiederherstellen

### 1. Einzelne Dateien wiederherstellen

```bash
# Snapshot mounten (macht ihn als Verzeichnis verfügbar)
sudo snapper -c root mount 42

# Jetzt ist der Snapshot verfügbar unter:
# /.snapshots/42/snapshot/

# Beispiel: Konfigurationsdatei wiederherstellen
sudo cp /.snapshots/42/snapshot/etc/fstab /etc/fstab

# Beispiel: Ganzes Verzeichnis wiederherstellen
sudo cp -r /.snapshots/42/snapshot/etc/NetworkManager/ /etc/

# Snapshot wieder unmounten (Speicher freigeben)
sudo snapper -c root umount 42
```

### 2. Änderungen zwischen Snapshots rückgängig machen

```bash
# Zeige was sich zwischen zwei Snapshots geändert hat
sudo snapper -c root status 40..45

# Mache alle Änderungen zwischen den Snapshots rückgängig
sudo snapper -c root undochange 40..45

# Alternativ: Rollback zu einem bestimmten Snapshot
sudo snapper -c root rollback 42
```

**Vorsicht bei undochange:**
- Überschreibt aktuelle Dateien!
- Erstelle vorher einen aktuellen Snapshot als Backup
- Teste erst in einer nicht-kritischen Umgebung

### 3. Komplettes System-Rollback (für Experten)

```bash
# ACHTUNG: Dies überschreibt dein aktuelles System!
# Erstelle erst einen Snapshot des aktuellen Zustands
sudo snapper -c root create -d "Vor Rollback - Notfall-Backup"

# Zeige verfügbare Snapshots
sudo snapper -c root list

# Rollback zu Snapshot (z.B. Nummer 42)
sudo btrfs subvolume snapshot /.snapshots/42/snapshot / 
```

### 4. Boot von Snapshot über GRUB

Wenn grub-btrfs installiert ist:

1. **Computer neu starten**
2. **Im GRUB-Menü**: "Snapshots for GNU/Linux" wählen
3. **Snapshot auswählen**: Den gewünschten Snapshot aus der Liste wählen  
4. **System startet** vom gewählten Snapshot (read-only)
5. **Wenn alles funktioniert**: `sudo snapper rollback` um permanent zu wechseln

## Überwachung und Wartung

### Speicherplatz überwachen

```bash
# BTRFS-Dateisystem-Nutzung anzeigen
sudo btrfs filesystem usage /

# Größe aller Snapshots anzeigen
sudo btrfs subvolume list / | grep snapshots

# Detaillierte Snapshot-Größen
for snap in $(sudo snapper -c root list | tail -n +3 | awk '{print $1}'); do
    if [ "$snap" != "0" ]; then
        size=$(sudo btrfs subvolume show "/.snapshots/$snap/snapshot" 2>/dev/null | grep -E "^\s*Gen:" | wc -l)
        echo "Snapshot $snap: Exists"
    fi
done
```

### Automatische Bereinigung konfigurieren

```bash
# Manuelle Bereinigung ausführen
sudo snapper -c root cleanup number    # Nach Anzahl-Regeln
sudo snapper -c root cleanup timeline  # Nach Zeit-Regeln

# Bereinigung-Logs anzeigen
journalctl -u snapper-cleanup.service
```

## Fehlerbehandlung und Tipps

### Häufige Probleme

**Problem**: `/.snapshots` ist ein normaler Ordner, kein Subvolume
```bash
# Lösung:
sudo umount /.snapshots
sudo rm -rf /.snapshots  
sudo btrfs subvolume create /.snapshots
sudo systemctl restart snapper-timeline.timer
```

**Problem**: Snapshots verbrauchen zu viel Speicher
```bash
# Lösung: Bereinigungsregeln anpassen
sudo nano /etc/snapper/configs/root
# NUMBER_LIMIT reduzieren (z.B. auf 20)
# Mehr Ausschlüsse hinzufügen
```

**Problem**: Automatische Snapshots funktionieren nicht
```bash
# Debugging:
systemctl status snapper-timeline.timer
journalctl -u snapper-timeline.service
sudo snapper -c root create -d "Test"  # Manuell testen
```

### Best Practices

1. **Vor großen Änderungen**: Immer manuelles Pre/Post-Snapshot-Paar
2. **Regelmäßige Kontrolle**: `sudo snapper list` alle paar Tage prüfen
3. **Speicherplatz überwachen**: Bei >80% Festplattenbelegung Snapshots reduzieren
4. **Test-Rollbacks**: Erst in VM oder Testsystem ausprobieren
5. **Backup-Strategie**: Snapper ersetzt keine externe Datensicherung!
6. **Wichtige Daten**: Separat in `/home` mit eigenem Snapshot-Schema verwalten

### Erweiterte Konfiguration für /home

```bash
# Separate Snapshot-Konfiguration für Home-Verzeichnis
sudo snapper -c home create-config /home

# Andere Bereinigungsregeln für /home (mehr Snapshots, da wichtiger)
sudo nano /etc/snapper/configs/home
```

Diese detaillierte Anleitung sollte dir ein vollständiges Verständnis von Snapper und dessen Konfiguration geben!