package backup import ( "archive/tar" "compress/gzip" "crypto/sha256" "encoding/hex" "encoding/json" "errors" "fmt" "io" "io/fs" "os" "path" "path/filepath" "sort" "strings" "time" ) // Wat er in een backup zit. Logische paden beginnen met state/ of data/. // // state/bluegit.db consistente kopie (VACUUM INTO), niet het live bestand // state/secret.key nodig om de geheimen in de database te lezen // state/ssh/… SSH-hostkey // state/logos/… project- en groepslogo's // state/avatars/… geüploade avatars // data/repos/… bare repositories // data/releases/… gepubliceerde release-assets (zonder .incoming) // data/artifacts/… CI-artifacts // // Niet mee: storage_path, cache.json, backup.json en instance_id (horen bij // de installatie), data/work (tijdelijke werkmappen), lock-bestanden en // symlinks. var ( stateFiles = []string{"bluegit.db", "secret.key"} stateDirs = []string{"ssh", "logos", "avatars"} dataDirs = []string{"repos", "releases", "artifacts"} ) // DBPath is het logische pad van de databasekopie. const DBPath = "state/bluegit.db" // Entry is één bestand in het manifest. type Entry struct { Path string `json:"path"` Size int64 `json:"size"` MTime int64 `json:"mtime"` // Unix-milliseconden Mode uint32 `json:"mode"` SHA256 string `json:"sha256,omitempty"` } // Manifest is de volledige lijst op één moment. type Manifest struct { Instance string `json:"instance_id"` CreatedAt time.Time `json:"created_at"` Files []Entry `json:"files"` } // Tree kent de twee mappen van een installatie. type Tree struct { StateDir string DataDir string // leeg als er geen datadisk is // Snapshot schrijft een consistente kopie van de database naar pad. Snapshot func(dst string) error } func (t Tree) snapshotPath() string { return filepath.Join(t.StateDir, ".backup", "snapshot.db") } // Build maakt een nieuwe databasekopie en loopt alle bestanden af. func (t Tree) Build(instance string) (Manifest, error) { m := Manifest{Instance: instance, CreatedAt: time.Now().UTC(), Files: []Entry{}} if t.Snapshot != nil { snap := t.snapshotPath() if err := os.MkdirAll(filepath.Dir(snap), 0o700); err != nil { return m, err } tmp := snap + ".new" _ = os.Remove(tmp) if err := t.Snapshot(tmp); err != nil { return m, fmt.Errorf("databasekopie: %w", err) } if err := os.Rename(tmp, snap); err != nil { return m, err } e, err := entryOf(DBPath, snap, true) if err != nil { return m, err } m.Files = append(m.Files, e) } for _, f := range stateFiles[1:] { p := filepath.Join(t.StateDir, f) if e, err := entryOf("state/"+f, p, false); err == nil { m.Files = append(m.Files, e) } } for _, d := range stateDirs { if err := walk(&m, "state/"+d, filepath.Join(t.StateDir, d)); err != nil { return m, err } } if t.DataDir != "" { for _, d := range dataDirs { if err := walk(&m, "data/"+d, filepath.Join(t.DataDir, d)); err != nil { return m, err } } } sort.Slice(m.Files, func(i, j int) bool { return m.Files[i].Path < m.Files[j].Path }) return m, nil } func entryOf(logical, real string, hash bool) (Entry, error) { fi, err := os.Lstat(real) if err != nil { return Entry{}, err } if !fi.Mode().IsRegular() { return Entry{}, errors.New("geen gewoon bestand") } e := Entry{Path: logical, Size: fi.Size(), MTime: fi.ModTime().UnixMilli(), Mode: uint32(fi.Mode().Perm())} if hash { f, err := os.Open(real) if err != nil { return e, err } defer f.Close() h := sha256.New() if _, err := io.Copy(h, f); err != nil { return e, err } e.SHA256 = hex.EncodeToString(h.Sum(nil)) } return e, nil } func skipName(name string) bool { return strings.HasSuffix(name, ".lock") || strings.HasPrefix(name, "tmp_") || name == ".incoming" } func walk(m *Manifest, logical, root string) error { err := filepath.WalkDir(root, func(p string, d fs.DirEntry, err error) error { if err != nil { if errors.Is(err, fs.ErrNotExist) { return nil } // Een map die tijdens het lopen verdwijnt (git gc) slaan we over. if d != nil && d.IsDir() { return fs.SkipDir } return nil } if p != root && skipName(d.Name()) { if d.IsDir() { return fs.SkipDir } return nil } if d.IsDir() || d.Type()&fs.ModeSymlink != 0 || !d.Type().IsRegular() { return nil } rel, err := filepath.Rel(root, p) if err != nil { return nil } if e, err := entryOf(logical+"/"+filepath.ToSlash(rel), p, false); err == nil { m.Files = append(m.Files, e) } return nil }) if errors.Is(err, fs.ErrNotExist) { return nil } return err } // CleanLogical controleert een logisch pad en geeft het genormaliseerd terug. func CleanLogical(p string) (string, bool) { if p == "" || strings.Contains(p, "\\") || strings.ContainsRune(p, 0) || strings.HasPrefix(p, "/") { return "", false } c := path.Clean(p) if c != p || c == "." || strings.HasPrefix(c, "../") || strings.Contains(c, "/../") { return "", false } parts := strings.Split(c, "/") for _, part := range parts { if part == ".." || part == "." || part == "" { return "", false } } if len(parts) < 2 { return "", false } switch parts[0] { case "state": if len(parts) == 2 && contains(stateFiles, parts[1]) { return c, true } if len(parts) >= 3 && contains(stateDirs, parts[1]) { return c, true } case "data": if len(parts) >= 3 && contains(dataDirs, parts[1]) && parts[2] != ".incoming" { return c, true } } return "", false } func contains(list []string, v string) bool { for _, x := range list { if x == v { return true } } return false } // Resolve geeft het echte bestand bij een logisch pad. De database komt // uit de laatste kopie van Build. func (t Tree) Resolve(logical string) (string, error) { c, ok := CleanLogical(logical) if !ok { return "", errors.New("ongeldig pad") } var real string switch { case c == DBPath: real = t.snapshotPath() case strings.HasPrefix(c, "state/"): real = filepath.Join(t.StateDir, filepath.FromSlash(strings.TrimPrefix(c, "state/"))) default: if t.DataDir == "" { return "", errors.New("geen datadisk") } real = filepath.Join(t.DataDir, filepath.FromSlash(strings.TrimPrefix(c, "data/"))) } fi, err := os.Lstat(real) if err != nil { return "", err } if !fi.Mode().IsRegular() { return "", errors.New("geen gewoon bestand") } return real, nil } // ---------- terugzetten ---------- const restoreDir = ".restore" type pending struct { DataDir string `json:"data_dir"` At time.Time `json:"at"` Files int `json:"files"` } // Stage pakt een tar.gz met logische paden uit naast de live mappen. Er // verandert nog niets aan de live gegevens; dat doet ApplyPending bij de // volgende start. De database en secret.key moeten in het archief zitten. func (t Tree) Stage(r io.Reader) (int, error) { stateStage := filepath.Join(t.StateDir, restoreDir) _ = os.RemoveAll(stateStage) var dataStage string if t.DataDir != "" { dataStage = filepath.Join(t.DataDir, restoreDir) _ = os.RemoveAll(dataStage) } fail := func(err error) (int, error) { _ = os.RemoveAll(stateStage) if dataStage != "" { _ = os.RemoveAll(dataStage) } return 0, err } gz, err := gzip.NewReader(r) if err != nil { return fail(fmt.Errorf("geen gzip: %w", err)) } tr := tar.NewReader(gz) n := 0 seenDB, seenKey := false, false for { h, err := tr.Next() if err == io.EOF { break } if err != nil { return fail(err) } if h.Typeflag == tar.TypeDir { continue } if h.Typeflag != tar.TypeReg { return fail(fmt.Errorf("%s: alleen gewone bestanden", h.Name)) } c, ok := CleanLogical(strings.TrimPrefix(h.Name, "./")) if !ok { return fail(fmt.Errorf("ongeldig pad in archief: %q", h.Name)) } var dst string if strings.HasPrefix(c, "state/") { dst = filepath.Join(stateStage, filepath.FromSlash(c)) } else { if dataStage == "" { return fail(errors.New("het archief bevat repositories, maar deze BlueGit heeft nog geen datadisk")) } dst = filepath.Join(dataStage, filepath.FromSlash(c)) } seenDB = seenDB || c == DBPath seenKey = seenKey || c == "state/secret.key" if err := os.MkdirAll(filepath.Dir(dst), 0o750); err != nil { return fail(err) } mode := os.FileMode(h.Mode).Perm() & 0o755 if mode == 0 { mode = 0o640 } f, err := os.OpenFile(dst, os.O_CREATE|os.O_EXCL|os.O_WRONLY, mode|0o600) if err != nil { return fail(err) } if _, err := io.Copy(f, tr); err != nil { f.Close() return fail(err) } if err := f.Close(); err != nil { return fail(err) } _ = os.Chtimes(dst, h.ModTime, h.ModTime) n++ } if !seenDB || !seenKey { return fail(errors.New("het archief mist state/bluegit.db of state/secret.key")) } b, _ := json.Marshal(pending{DataDir: t.DataDir, At: time.Now().UTC(), Files: n}) if err := os.WriteFile(filepath.Join(stateStage, "READY"), b, 0o600); err != nil { return fail(err) } return n, nil } // HasPending zegt of er een uitgepakte backup klaarstaat. func HasPending(stateDir string) bool { _, err := os.Stat(filepath.Join(stateDir, restoreDir, "READY")) return err == nil } // ApplyPending zet een klaarstaande backup op zijn plek. Aanroepen bij de // start, vóór de database open gaat. Geen READY: niets te doen. func ApplyPending(stateDir string) (bool, error) { stage := filepath.Join(stateDir, restoreDir) b, err := os.ReadFile(filepath.Join(stage, "READY")) if errors.Is(err, os.ErrNotExist) { return false, nil } if err != nil { return false, err } var p pending if err := json.Unmarshal(b, &p); err != nil { return false, err } for _, f := range []string{"bluegit.db-wal", "bluegit.db-shm"} { _ = os.Remove(filepath.Join(stateDir, f)) } for _, name := range append(append([]string{}, stateFiles...), stateDirs...) { if err := swap(filepath.Join(stateDir, name), filepath.Join(stage, "state", name)); err != nil { return false, err } } if p.DataDir != "" { dstage := filepath.Join(p.DataDir, restoreDir) for _, name := range dataDirs { if err := swap(filepath.Join(p.DataDir, name), filepath.Join(dstage, "data", name)); err != nil { return false, err } } _ = os.RemoveAll(dstage) } _ = os.RemoveAll(filepath.Join(stateDir, ".backup")) return true, os.RemoveAll(stage) } // swap vervangt live door staged. Ontbreekt staged, dan verdwijnt live. func swap(live, staged string) error { old := live + ".restore-old" _ = os.RemoveAll(old) if _, err := os.Lstat(live); err == nil { if err := os.Rename(live, old); err != nil { return err } } if _, err := os.Lstat(staged); err == nil { if err := os.Rename(staged, live); err != nil { return err } } return os.RemoveAll(old) }