BlueGit

timfa bluegit

Files

bluegit / internal / backup / tree.go

tree.go

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