feat(archive): BAK-03 Restore-Verfahren fuer Datenbank und Objekt-Storage
internal/restore: Atomarer Restore ueber Temp-Verzeichnis + Rename, nicht-leeres Ziel ohne -force bricht VOR jeder Beruehrung ab, JSONL- Protokoll jedes Laufs. Drei reale Defekte beim Bau gefunden und behoben: pg_combinebackup braucht Plain- statt Tar-Format (Extraktionsschritt ergaenzt), pg_wal.tar.gz wurde nie verifiziert/wiederhergestellt (BAK-01s Verify jetzt erweitert), Go-exec haengt bei pg_ctl start wegen vererbter Pipes (Testfix: echte Logdatei statt CombinedOutput). Beide Restore-Pfade real auf 131 ueber restore-cli nachgewiesen, inkl. echtem Postgres-Start aus wiederhergestelltem Verzeichnis.
This commit is contained in:
sysops
@@ -0,0 +1,133 @@
|
||||
// Package restore implementiert BAK-03: dokumentiertes, wiederholbares
|
||||
// Restore-Verfahren für Datenbank (BAK-01) und Objekt-Storage (BAK-02).
|
||||
// Enthält NUR die gemeinsame Ablauflogik (Atomarität über Temp-Verzeichnis,
|
||||
// Protokollierung) — die eigentliche Wiederherstellung bleibt in den
|
||||
// jeweiligen Paketen (backup.Restore, objectbackup.Restore), damit
|
||||
// internal/restore nicht weiß, WIE eine Sicherung gelesen wird, nur WANN
|
||||
// und WIE SICHER sie an ihren Zielort darf.
|
||||
package restore
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"time"
|
||||
)
|
||||
|
||||
// Kind unterscheidet die beiden Restore-Arten im Protokoll.
|
||||
type Kind string
|
||||
|
||||
const (
|
||||
KindDatabase Kind = "database"
|
||||
KindObjects Kind = "objects"
|
||||
)
|
||||
|
||||
// LogEntry ist EIN Protokolleintrag (Akzeptanzkriterium 3: Quelle,
|
||||
// Zeitpunkt, Ergebnis).
|
||||
type LogEntry struct {
|
||||
Timestamp time.Time `json:"timestamp"`
|
||||
Kind Kind `json:"kind"`
|
||||
Source string `json:"source"` // Generation-ID oder Snapshot-ID
|
||||
Target string `json:"target"`
|
||||
Result string `json:"result"` // "ok", "abgebrochen: ...", "fehlgeschlagen: ..."
|
||||
}
|
||||
|
||||
// ErrTargetNotEmpty wird zurückgegeben, wenn targetDir bereits Inhalt hat
|
||||
// und force nicht gesetzt ist — Akzeptanzkriterium 2: bestehender Inhalt
|
||||
// bleibt unangetastet, solange der Vorgang nicht bestätigt wird.
|
||||
var ErrTargetNotEmpty = fmt.Errorf("restore: zielverzeichnis ist nicht leer, restore ohne bestätigung (force) abgebrochen")
|
||||
|
||||
// AtomicRestore führt restoreFn gegen ein FRISCHES temporäres Verzeichnis
|
||||
// aus (niemals direkt gegen target) und übernimmt es erst bei Erfolg —
|
||||
// entweder wenn target leer ist, oder wenn force=true (bewusste
|
||||
// Bestätigung, bestehenden Inhalt zu überschreiben). Bei jedem Fehler
|
||||
// oder abgelehnter Bestätigung bleibt target garantiert unverändert
|
||||
// (Akzeptanzkriterium 2), das temporäre Verzeichnis wird aufgeräumt.
|
||||
// Jeder Aufruf – erfolgreich oder nicht – erzeugt genau einen
|
||||
// Protokolleintrag in logPath (Akzeptanzkriterium 3).
|
||||
func AtomicRestore(kind Kind, source, target string, force bool, logPath string, restoreFn func(tempDir string) error) (LogEntry, error) {
|
||||
entry := LogEntry{Timestamp: time.Now().UTC(), Kind: kind, Source: source, Target: target}
|
||||
|
||||
empty, err := dirIsEmptyOrMissing(target)
|
||||
if err != nil {
|
||||
entry.Result = "fehlgeschlagen: " + err.Error()
|
||||
_ = appendLog(logPath, entry)
|
||||
return entry, err
|
||||
}
|
||||
if !empty && !force {
|
||||
entry.Result = "abgebrochen: " + ErrTargetNotEmpty.Error()
|
||||
_ = appendLog(logPath, entry)
|
||||
return entry, ErrTargetNotEmpty
|
||||
}
|
||||
|
||||
parent := filepath.Dir(filepath.Clean(target))
|
||||
tempDir, err := os.MkdirTemp(parent, ".restore-tmp-*")
|
||||
if err != nil {
|
||||
entry.Result = "fehlgeschlagen: temp-verzeichnis anlegen: " + err.Error()
|
||||
_ = appendLog(logPath, entry)
|
||||
return entry, fmt.Errorf("restore: temp-verzeichnis anlegen: %w", err)
|
||||
}
|
||||
defer func() { _ = os.RemoveAll(tempDir) }() // no-op nach erfolgreichem Rename (Verzeichnis existiert dann nicht mehr)
|
||||
|
||||
if err := restoreFn(tempDir); err != nil {
|
||||
entry.Result = "fehlgeschlagen: " + err.Error()
|
||||
_ = appendLog(logPath, entry)
|
||||
return entry, fmt.Errorf("restore: wiederherstellung: %w", err)
|
||||
}
|
||||
|
||||
if !empty {
|
||||
// force=true, bewusste Bestätigung: alter Inhalt wird ERST JETZT
|
||||
// entfernt, nachdem restoreFn bereits erfolgreich in tempDir
|
||||
// abgeschlossen hat — ein Fehlschlag oben hätte target nie berührt.
|
||||
if err := os.RemoveAll(target); err != nil {
|
||||
entry.Result = "fehlgeschlagen: altes ziel entfernen: " + err.Error()
|
||||
_ = appendLog(logPath, entry)
|
||||
return entry, fmt.Errorf("restore: altes ziel entfernen: %w", err)
|
||||
}
|
||||
} else if err := os.MkdirAll(parent, 0o750); err != nil {
|
||||
entry.Result = "fehlgeschlagen: übergeordnetes verzeichnis anlegen: " + err.Error()
|
||||
_ = appendLog(logPath, entry)
|
||||
return entry, fmt.Errorf("restore: übergeordnetes verzeichnis anlegen: %w", err)
|
||||
}
|
||||
|
||||
if err := os.Rename(tempDir, target); err != nil {
|
||||
entry.Result = "fehlgeschlagen: umbenennen: " + err.Error()
|
||||
_ = appendLog(logPath, entry)
|
||||
return entry, fmt.Errorf("restore: temp-verzeichnis nach ziel umbenennen: %w", err)
|
||||
}
|
||||
|
||||
entry.Result = "ok"
|
||||
if err := appendLog(logPath, entry); err != nil {
|
||||
return entry, fmt.Errorf("restore: protokoll schreiben: %w", err)
|
||||
}
|
||||
return entry, nil
|
||||
}
|
||||
|
||||
func dirIsEmptyOrMissing(dir string) (bool, error) {
|
||||
entries, err := os.ReadDir(dir)
|
||||
if err != nil {
|
||||
if os.IsNotExist(err) {
|
||||
return true, nil
|
||||
}
|
||||
return false, fmt.Errorf("zielverzeichnis lesen: %w", err)
|
||||
}
|
||||
return len(entries) == 0, nil
|
||||
}
|
||||
|
||||
func appendLog(logPath string, entry LogEntry) error {
|
||||
f, err := os.OpenFile(logPath, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0o600)
|
||||
if err != nil {
|
||||
return fmt.Errorf("protokolldatei öffnen: %w", err)
|
||||
}
|
||||
defer func() { _ = f.Close() }()
|
||||
|
||||
line, err := json.Marshal(entry)
|
||||
if err != nil {
|
||||
return fmt.Errorf("protokolleintrag kodieren: %w", err)
|
||||
}
|
||||
if _, err := f.Write(append(line, '\n')); err != nil {
|
||||
return fmt.Errorf("protokolleintrag schreiben: %w", err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
@@ -0,0 +1,181 @@
|
||||
package restore
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func readLog(t *testing.T, path string) []LogEntry {
|
||||
t.Helper()
|
||||
data, err := os.ReadFile(path)
|
||||
if err != nil {
|
||||
t.Fatalf("protokolldatei lesen: %v", err)
|
||||
}
|
||||
var entries []LogEntry
|
||||
for _, line := range splitLines(data) {
|
||||
if len(line) == 0 {
|
||||
continue
|
||||
}
|
||||
var e LogEntry
|
||||
if err := json.Unmarshal(line, &e); err != nil {
|
||||
t.Fatalf("protokollzeile dekodieren: %v (%s)", err, line)
|
||||
}
|
||||
entries = append(entries, e)
|
||||
}
|
||||
return entries
|
||||
}
|
||||
|
||||
func splitLines(data []byte) [][]byte {
|
||||
var out [][]byte
|
||||
start := 0
|
||||
for i, b := range data {
|
||||
if b == '\n' {
|
||||
out = append(out, data[start:i])
|
||||
start = i + 1
|
||||
}
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
// TestAtomicRestore_EmptyTarget_Succeeds ist Pruefung 1: Restore auf
|
||||
// leerem (nicht vorhandenem) Ziel vollstaendig erfolgreich.
|
||||
func TestAtomicRestore_EmptyTarget_Succeeds(t *testing.T) {
|
||||
root := t.TempDir()
|
||||
target := filepath.Join(root, "ziel")
|
||||
logPath := filepath.Join(root, "restore.log")
|
||||
|
||||
entry, err := AtomicRestore(KindDatabase, "gen-1", target, false, logPath, func(tempDir string) error {
|
||||
return os.WriteFile(filepath.Join(tempDir, "marker"), []byte("wiederhergestellt"), 0o600)
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("atomicRestore: %v", err)
|
||||
}
|
||||
if entry.Result != "ok" {
|
||||
t.Fatalf("result = %q, want ok", entry.Result)
|
||||
}
|
||||
content, err := os.ReadFile(filepath.Join(target, "marker"))
|
||||
if err != nil || string(content) != "wiederhergestellt" {
|
||||
t.Fatalf("ziel nicht korrekt befuellt: %v %q", err, content)
|
||||
}
|
||||
}
|
||||
|
||||
// TestAtomicRestore_NonEmptyTargetWithoutForce_LeavesOriginalUntouched ist
|
||||
// Pruefung 2: Restore auf nicht-leeres Zielverzeichnis laesst bei Abbruch
|
||||
// (keine Bestaetigung) den urspruenglichen Inhalt unveraendert.
|
||||
func TestAtomicRestore_NonEmptyTargetWithoutForce_LeavesOriginalUntouched(t *testing.T) {
|
||||
root := t.TempDir()
|
||||
target := filepath.Join(root, "ziel")
|
||||
logPath := filepath.Join(root, "restore.log")
|
||||
if err := os.MkdirAll(target, 0o750); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := os.WriteFile(filepath.Join(target, "bestehend"), []byte("original"), 0o600); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
restoreFnCalled := false
|
||||
_, err := AtomicRestore(KindObjects, "snap-1", target, false, logPath, func(tempDir string) error {
|
||||
restoreFnCalled = true
|
||||
return nil
|
||||
})
|
||||
if err != ErrTargetNotEmpty {
|
||||
t.Fatalf("erwartet ErrTargetNotEmpty, habe: %v", err)
|
||||
}
|
||||
if restoreFnCalled {
|
||||
t.Fatal("restoreFn haette bei nicht-leerem ziel ohne force NIE aufgerufen werden duerfen")
|
||||
}
|
||||
content, err := os.ReadFile(filepath.Join(target, "bestehend"))
|
||||
if err != nil || string(content) != "original" {
|
||||
t.Fatalf("urspruenglicher inhalt veraendert: %v %q", err, content)
|
||||
}
|
||||
}
|
||||
|
||||
// TestAtomicRestore_FailedRestoreFn_LeavesTargetUntouched ist Nachweis,
|
||||
// dass ein Fehler WAEHREND der Wiederherstellung (in tempDir) das
|
||||
// bestehende Ziel nicht beschaedigt, weil erst nach Erfolg umbenannt wird.
|
||||
func TestAtomicRestore_FailedRestoreFn_LeavesTargetUntouched(t *testing.T) {
|
||||
root := t.TempDir()
|
||||
target := filepath.Join(root, "ziel")
|
||||
logPath := filepath.Join(root, "restore.log")
|
||||
if err := os.MkdirAll(target, 0o750); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := os.WriteFile(filepath.Join(target, "bestehend"), []byte("original"), 0o600); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
_, err := AtomicRestore(KindDatabase, "gen-2", target, true, logPath, func(tempDir string) error {
|
||||
return os.ErrInvalid // simuliert fehlgeschlagene wiederherstellung
|
||||
})
|
||||
if err == nil {
|
||||
t.Fatal("erwartet fehler")
|
||||
}
|
||||
content, err := os.ReadFile(filepath.Join(target, "bestehend"))
|
||||
if err != nil || string(content) != "original" {
|
||||
t.Fatalf("ziel bei fehlgeschlagenem restoreFn veraendert: %v %q", err, content)
|
||||
}
|
||||
}
|
||||
|
||||
// TestAtomicRestore_ForceOverwritesNonEmptyTarget ist Nachweis, dass eine
|
||||
// BEWUSSTE Bestaetigung (force) bestehenden Inhalt ersetzen darf.
|
||||
func TestAtomicRestore_ForceOverwritesNonEmptyTarget(t *testing.T) {
|
||||
root := t.TempDir()
|
||||
target := filepath.Join(root, "ziel")
|
||||
logPath := filepath.Join(root, "restore.log")
|
||||
if err := os.MkdirAll(target, 0o750); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := os.WriteFile(filepath.Join(target, "alt"), []byte("alt"), 0o600); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
_, err := AtomicRestore(KindObjects, "snap-2", target, true, logPath, func(tempDir string) error {
|
||||
return os.WriteFile(filepath.Join(tempDir, "neu"), []byte("neu"), 0o600)
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("atomicRestore mit force: %v", err)
|
||||
}
|
||||
if _, err := os.Stat(filepath.Join(target, "alt")); !os.IsNotExist(err) {
|
||||
t.Fatal("alter inhalt haette nach force-restore ersetzt sein muessen")
|
||||
}
|
||||
if _, err := os.Stat(filepath.Join(target, "neu")); err != nil {
|
||||
t.Fatalf("neuer inhalt fehlt: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
// TestAtomicRestore_LogsCompleteEntry ist Pruefung 3: Protokolleintrag
|
||||
// ist vollstaendig und nachvollziehbar (Quelle, Zeitpunkt, Ergebnis) -
|
||||
// sowohl fuer Erfolg als auch fuer Abbruch, in derselben Datei.
|
||||
func TestAtomicRestore_LogsCompleteEntry(t *testing.T) {
|
||||
root := t.TempDir()
|
||||
logPath := filepath.Join(root, "restore.log")
|
||||
|
||||
okTarget := filepath.Join(root, "ok-ziel")
|
||||
if _, err := AtomicRestore(KindDatabase, "gen-3", okTarget, false, logPath, func(tempDir string) error {
|
||||
return os.WriteFile(filepath.Join(tempDir, "x"), []byte("x"), 0o600)
|
||||
}); err != nil {
|
||||
t.Fatalf("erfolgreicher restore: %v", err)
|
||||
}
|
||||
|
||||
blockedTarget := filepath.Join(root, "blockiert-ziel")
|
||||
if err := os.MkdirAll(blockedTarget, 0o750); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := os.WriteFile(filepath.Join(blockedTarget, "bestehend"), []byte("y"), 0o600); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
_, _ = AtomicRestore(KindObjects, "snap-3", blockedTarget, false, logPath, func(tempDir string) error { return nil })
|
||||
|
||||
entries := readLog(t, logPath)
|
||||
if len(entries) != 2 {
|
||||
t.Fatalf("erwartet 2 protokolleintraege, habe %d: %+v", len(entries), entries)
|
||||
}
|
||||
if entries[0].Source != "gen-3" || entries[0].Kind != KindDatabase || entries[0].Result != "ok" || entries[0].Timestamp.IsZero() {
|
||||
t.Fatalf("erster eintrag unvollstaendig: %+v", entries[0])
|
||||
}
|
||||
if entries[1].Source != "snap-3" || entries[1].Kind != KindObjects || entries[1].Result == "" || entries[1].Timestamp.IsZero() {
|
||||
t.Fatalf("zweiter eintrag unvollstaendig: %+v", entries[1])
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user