BlueGit

timfa bluegit

Files

bluegit / internal / backup / tree.go

tree.go

tree.go 12.1 KiB Download Raw
1package backup
2
3import (
4 "archive/tar"
5 "compress/gzip"
6 "crypto/sha256"
7 "encoding/hex"
8 "encoding/json"
9 "errors"
10 "fmt"
11 "io"
12 "io/fs"
13 "os"
14 "path"
15 "path/filepath"
16 "sort"
17 "strings"
18 "sync"
19 "time"
20
21 "gitlab.com/Timfa/bluegit/internal/barerepo"
22)
23
24// Wat er in een backup zit. Logische paden beginnen met state/ of data/.
25//
26// state/bluegit.db consistente kopie (VACUUM INTO), niet het live bestand
27// state/secret.key nodig om de geheimen in de database te lezen
28// state/ssh/… SSH-hostkey
29// state/logos/… project- en groepslogo's
30// state/avatars/… geüploade avatars
31// data/repos/… bare repositories
32// data/releases/… gepubliceerde release-assets (zonder .incoming)
33// data/artifacts/… CI-artifacts
34//
35// Niet mee: storage_path, cache.json, backup.json en instance_id (horen bij
36// de installatie), data/work (tijdelijke werkmappen), lock-bestanden en
37// symlinks.
38var (
39 stateFiles = []string{"bluegit.db", "secret.key"}
40 stateDirs = []string{"ssh", "logos", "avatars"}
41 dataDirs = []string{"repos", "releases", "artifacts"}
42)
43
44// DBPath is het logische pad van de databasekopie.
45const DBPath = "state/bluegit.db"
46
47// Entry is één bestand in het manifest.
48type Entry struct {
49 Path string `json:"path"`
50 Size int64 `json:"size"`
51 MTime int64 `json:"mtime"` // Unix-milliseconden
52 Mode uint32 `json:"mode"`
53 SHA256 string `json:"sha256,omitempty"`
54}
55
56// Manifest is de volledige lijst op één moment.
57type Manifest struct {
58 Instance string `json:"instance_id"`
59 CreatedAt time.Time `json:"created_at"`
60 Files []Entry `json:"files"`
61}
62
63// Tree kent de twee mappen van een installatie.
64type Tree struct {
65 StateDir string
66 DataDir string // leeg als er geen datadisk is
67 // Snapshot schrijft een consistente kopie van de database naar pad.
68 Snapshot func(dst string) error
69 // Conn is de koppeling waarvoor de kopie is. Elke backup server krijgt
70 // een eigen databasekopie, zodat twee servers die tegelijk een
71 // manifest ophalen elkaars kopie niet vervangen.
72 Conn string
73}
74
75// snapshotMu zorgt dat er maar één databasekopie tegelijk gemaakt wordt.
76var snapshotMu sync.Mutex
77
78func (t Tree) snapshotPath() string {
79 name := "snapshot.db"
80 if t.Conn != "" {
81 name = "snapshot-" + safeName(t.Conn) + ".db"
82 }
83 return filepath.Join(t.StateDir, ".backup", name)
84}
85
86// RemoveSnapshot ruimt de databasekopie van een koppeling op.
87func (t Tree) RemoveSnapshot() { _ = os.Remove(t.snapshotPath()) }
88
89func safeName(s string) string {
90 var b strings.Builder
91 for _, r := range s {
92 if r >= 'a' && r <= 'z' || r >= 'A' && r <= 'Z' || r >= '0' && r <= '9' || r == '-' || r == '_' {
93 b.WriteRune(r)
94 }
95 }
96 return b.String()
97}
98
99// Build maakt een nieuwe databasekopie en loopt alle bestanden af.
100func (t Tree) Build(instance string) (Manifest, error) {
101 m := Manifest{Instance: instance, CreatedAt: time.Now().UTC(), Files: []Entry{}}
102 if t.Snapshot != nil {
103 snap := t.snapshotPath()
104 if err := os.MkdirAll(filepath.Dir(snap), 0o700); err != nil {
105 return m, err
106 }
107 tmp := snap + ".new"
108 snapshotMu.Lock()
109 _ = os.Remove(tmp)
110 err := t.Snapshot(tmp)
111 if err == nil {
112 err = os.Rename(tmp, snap)
113 } else {
114 err = fmt.Errorf("databasekopie: %w", err)
115 }
116 snapshotMu.Unlock()
117 if err != nil {
118 return m, err
119 }
120 e, err := entryOf(DBPath, snap, true)
121 if err != nil {
122 return m, err
123 }
124 m.Files = append(m.Files, e)
125 }
126 for _, f := range stateFiles[1:] {
127 p := filepath.Join(t.StateDir, f)
128 if e, err := entryOf("state/"+f, p, false); err == nil {
129 m.Files = append(m.Files, e)
130 }
131 }
132 for _, d := range stateDirs {
133 if err := walk(&m, "state/"+d, filepath.Join(t.StateDir, d)); err != nil {
134 return m, err
135 }
136 }
137 if t.DataDir != "" {
138 for _, d := range dataDirs {
139 if err := walk(&m, "data/"+d, filepath.Join(t.DataDir, d)); err != nil {
140 return m, err
141 }
142 }
143 }
144 sort.Slice(m.Files, func(i, j int) bool { return m.Files[i].Path < m.Files[j].Path })
145 return m, nil
146}
147
148func entryOf(logical, real string, hash bool) (Entry, error) {
149 fi, err := os.Lstat(real)
150 if err != nil {
151 return Entry{}, err
152 }
153 if !fi.Mode().IsRegular() {
154 return Entry{}, errors.New("geen gewoon bestand")
155 }
156 e := Entry{Path: logical, Size: fi.Size(), MTime: fi.ModTime().UnixMilli(), Mode: uint32(fi.Mode().Perm())}
157 if hash {
158 f, err := os.Open(real)
159 if err != nil {
160 return e, err
161 }
162 defer f.Close()
163 h := sha256.New()
164 if _, err := io.Copy(h, f); err != nil {
165 return e, err
166 }
167 e.SHA256 = hex.EncodeToString(h.Sum(nil))
168 }
169 return e, nil
170}
171
172func skipName(name string) bool {
173 return strings.HasSuffix(name, ".lock") || strings.HasPrefix(name, "tmp_") || name == ".incoming"
174}
175
176func walk(m *Manifest, logical, root string) error {
177 err := filepath.WalkDir(root, func(p string, d fs.DirEntry, err error) error {
178 if err != nil {
179 if errors.Is(err, fs.ErrNotExist) {
180 return nil
181 }
182 // Een map die tijdens het lopen verdwijnt (git gc) slaan we over.
183 if d != nil && d.IsDir() {
184 return fs.SkipDir
185 }
186 return nil
187 }
188 if p != root && skipName(d.Name()) {
189 if d.IsDir() {
190 return fs.SkipDir
191 }
192 return nil
193 }
194 if d.IsDir() || d.Type()&fs.ModeSymlink != 0 || !d.Type().IsRegular() {
195 return nil
196 }
197 rel, err := filepath.Rel(root, p)
198 if err != nil {
199 return nil
200 }
201 if e, err := entryOf(logical+"/"+filepath.ToSlash(rel), p, false); err == nil {
202 m.Files = append(m.Files, e)
203 }
204 return nil
205 })
206 if errors.Is(err, fs.ErrNotExist) {
207 return nil
208 }
209 return err
210}
211
212// CleanLogical controleert een logisch pad en geeft het genormaliseerd terug.
213func CleanLogical(p string) (string, bool) {
214 if p == "" || strings.Contains(p, "\\") || strings.ContainsRune(p, 0) || strings.HasPrefix(p, "/") {
215 return "", false
216 }
217 c := path.Clean(p)
218 if c != p || c == "." || strings.HasPrefix(c, "../") || strings.Contains(c, "/../") {
219 return "", false
220 }
221 parts := strings.Split(c, "/")
222 for _, part := range parts {
223 if part == ".." || part == "." || part == "" {
224 return "", false
225 }
226 }
227 if len(parts) < 2 {
228 return "", false
229 }
230 switch parts[0] {
231 case "state":
232 if len(parts) == 2 && contains(stateFiles, parts[1]) {
233 return c, true
234 }
235 if len(parts) >= 3 && contains(stateDirs, parts[1]) {
236 return c, true
237 }
238 case "data":
239 if len(parts) >= 3 && contains(dataDirs, parts[1]) && parts[2] != ".incoming" {
240 return c, true
241 }
242 }
243 return "", false
244}
245
246func contains(list []string, v string) bool {
247 for _, x := range list {
248 if x == v {
249 return true
250 }
251 }
252 return false
253}
254
255// Resolve geeft het echte bestand bij een logisch pad. De database komt
256// uit de laatste kopie van Build.
257func (t Tree) Resolve(logical string) (string, error) {
258 c, ok := CleanLogical(logical)
259 if !ok {
260 return "", errors.New("ongeldig pad")
261 }
262 var real string
263 switch {
264 case c == DBPath:
265 real = t.snapshotPath()
266 case strings.HasPrefix(c, "state/"):
267 real = filepath.Join(t.StateDir, filepath.FromSlash(strings.TrimPrefix(c, "state/")))
268 default:
269 if t.DataDir == "" {
270 return "", errors.New("geen datadisk")
271 }
272 real = filepath.Join(t.DataDir, filepath.FromSlash(strings.TrimPrefix(c, "data/")))
273 }
274 fi, err := os.Lstat(real)
275 if err != nil {
276 return "", err
277 }
278 if !fi.Mode().IsRegular() {
279 return "", errors.New("geen gewoon bestand")
280 }
281 return real, nil
282}
283
284// ---------- terugzetten ----------
285
286const restoreDir = ".restore"
287
288type pending struct {
289 DataDir string `json:"data_dir"`
290 At time.Time `json:"at"`
291 Files int `json:"files"`
292}
293
294// Stage pakt een tar.gz met logische paden uit naast de live mappen. Er
295// verandert nog niets aan de live gegevens; dat doet ApplyPending bij de
296// volgende start. De database en secret.key moeten in het archief zitten.
297func (t Tree) Stage(r io.Reader) (int, error) {
298 stateStage := filepath.Join(t.StateDir, restoreDir)
299 _ = os.RemoveAll(stateStage)
300 var dataStage string
301 if t.DataDir != "" {
302 dataStage = filepath.Join(t.DataDir, restoreDir)
303 _ = os.RemoveAll(dataStage)
304 }
305 fail := func(err error) (int, error) {
306 _ = os.RemoveAll(stateStage)
307 if dataStage != "" {
308 _ = os.RemoveAll(dataStage)
309 }
310 return 0, err
311 }
312 gz, err := gzip.NewReader(r)
313 if err != nil {
314 return fail(fmt.Errorf("geen gzip: %w", err))
315 }
316 tr := tar.NewReader(gz)
317 n := 0
318 seenDB, seenKey := false, false
319 for {
320 h, err := tr.Next()
321 if err == io.EOF {
322 break
323 }
324 if err != nil {
325 return fail(err)
326 }
327 if h.Typeflag == tar.TypeDir {
328 // Mappen met een geldig logisch pad maken we aan (lege refs/ van
329 // een volledig gepackte repo); andere negeren we.
330 if c, ok := CleanLogical(strings.TrimSuffix(strings.TrimPrefix(h.Name, "./"), "/")); ok {
331 dst := filepath.Join(stateStage, filepath.FromSlash(c))
332 if !strings.HasPrefix(c, "state/") {
333 if dataStage == "" {
334 continue
335 }
336 dst = filepath.Join(dataStage, filepath.FromSlash(c))
337 }
338 if err := os.MkdirAll(dst, 0o750); err != nil {
339 return fail(err)
340 }
341 }
342 continue
343 }
344 if h.Typeflag != tar.TypeReg {
345 return fail(fmt.Errorf("%s: alleen gewone bestanden", h.Name))
346 }
347 c, ok := CleanLogical(strings.TrimPrefix(h.Name, "./"))
348 if !ok {
349 return fail(fmt.Errorf("ongeldig pad in archief: %q", h.Name))
350 }
351 var dst string
352 if strings.HasPrefix(c, "state/") {
353 dst = filepath.Join(stateStage, filepath.FromSlash(c))
354 } else {
355 if dataStage == "" {
356 return fail(errors.New("het archief bevat repositories, maar deze BlueGit heeft nog geen datadisk"))
357 }
358 dst = filepath.Join(dataStage, filepath.FromSlash(c))
359 }
360 seenDB = seenDB || c == DBPath
361 seenKey = seenKey || c == "state/secret.key"
362 if err := os.MkdirAll(filepath.Dir(dst), 0o750); err != nil {
363 return fail(err)
364 }
365 mode := os.FileMode(h.Mode).Perm() & 0o755
366 if mode == 0 {
367 mode = 0o640
368 }
369 f, err := os.OpenFile(dst, os.O_CREATE|os.O_EXCL|os.O_WRONLY, mode|0o600)
370 if err != nil {
371 return fail(err)
372 }
373 if _, err := io.Copy(f, tr); err != nil {
374 f.Close()
375 return fail(err)
376 }
377 if err := f.Close(); err != nil {
378 return fail(err)
379 }
380 _ = os.Chtimes(dst, h.ModTime, h.ModTime)
381 n++
382 }
383 if !seenDB || !seenKey {
384 return fail(errors.New("het archief mist state/bluegit.db of state/secret.key"))
385 }
386 // Ook bij een archief zonder mappen (van vóór deze fix) krijgt elke bare
387 // repo zijn refs/ en objects/ terug.
388 if dataStage != "" {
389 if _, err := barerepo.Repair(filepath.Join(dataStage, "data", "repos")); err != nil {
390 return fail(err)
391 }
392 }
393 b, _ := json.Marshal(pending{DataDir: t.DataDir, At: time.Now().UTC(), Files: n})
394 if err := os.WriteFile(filepath.Join(stateStage, "READY"), b, 0o600); err != nil {
395 return fail(err)
396 }
397 return n, nil
398}
399
400// HasPending zegt of er een uitgepakte backup klaarstaat.
401func HasPending(stateDir string) bool {
402 _, err := os.Stat(filepath.Join(stateDir, restoreDir, "READY"))
403 return err == nil
404}
405
406// ApplyPending zet een klaarstaande backup op zijn plek. Aanroepen bij de
407// start, vóór de database open gaat. Geen READY: niets te doen.
408func ApplyPending(stateDir string) (bool, error) {
409 stage := filepath.Join(stateDir, restoreDir)
410 b, err := os.ReadFile(filepath.Join(stage, "READY"))
411 if errors.Is(err, os.ErrNotExist) {
412 return false, nil
413 }
414 if err != nil {
415 return false, err
416 }
417 var p pending
418 if err := json.Unmarshal(b, &p); err != nil {
419 return false, err
420 }
421 for _, f := range []string{"bluegit.db-wal", "bluegit.db-shm"} {
422 _ = os.Remove(filepath.Join(stateDir, f))
423 }
424 for _, name := range append(append([]string{}, stateFiles...), stateDirs...) {
425 if err := swap(filepath.Join(stateDir, name), filepath.Join(stage, "state", name)); err != nil {
426 return false, err
427 }
428 }
429 if p.DataDir != "" {
430 dstage := filepath.Join(p.DataDir, restoreDir)
431 for _, name := range dataDirs {
432 if err := swap(filepath.Join(p.DataDir, name), filepath.Join(dstage, "data", name)); err != nil {
433 return false, err
434 }
435 }
436 _ = os.RemoveAll(dstage)
437 }
438 _ = os.RemoveAll(filepath.Join(stateDir, ".backup"))
439 return true, os.RemoveAll(stage)
440}
441
442// swap vervangt live door staged. Ontbreekt staged, dan verdwijnt live.
443func swap(live, staged string) error {
444 old := live + ".restore-old"
445 _ = os.RemoveAll(old)
446 if _, err := os.Lstat(live); err == nil {
447 if err := os.Rename(live, old); err != nil {
448 return err
449 }
450 }
451 if _, err := os.Lstat(staged); err == nil {
452 if err := os.Rename(staged, live); err != nil {
453 return err
454 }
455 }
456 return os.RemoveAll(old)
457}