BlueGit

timfa bluegit

backup: volledig gepackte repo's blijven na restore een geldige repository (#1)

Staan alle refs van een bare repo in packed-refs (na git gc of git
pack-refs --all), dan is refs/ leeg. De backup neemt alleen gewone
bestanden mee, dus die map ontbrak in het archief en na uitpakken was de
repo "not a git repository".

- Nieuw pakket internal/barerepo: de verplichte mappen (refs/heads,
  refs/tags, objects/info, objects/pack) en Repair, dat ze aanmaakt in
  elke *.git met HEAD.
- archive.WriteTarGz schrijft die mappen per repo als mapitems mee, zodat
  ook een gewone tar -x een geldige repo oplevert.
- archive.ExtractReader (rollback) en Tree.Stage (restore in BlueGit)
  maken mapitems met een geldig pad aan en draaien daarna Repair. Zo
  werken ook archieven van vóór deze fix.
- Tests: unit (barerepo, archive, Stage + ApplyPending) en een
  integratietest met echte BlueGit: pack-refs --all, archief, tar -x en
  restore naar een nieuwe instantie, met git fsck.

Closes nog niet: issue #1 gaat dicht na een nieuwe backuptest.

timfa Grok Bot · pushed by timfa

Authored 2026-11-18 · 2 hours ago

Hash
fc5b2709291c1bb82aa13e83253b9199a866473e
Parent
6763e00f
Pipeline
Passed
10 files changed +484 −6
docs/ASSUMPTIONS.md +1 −1
@@ -103,7 +103,7 @@ Deze keuzes heb ik gemaakt waar de opdracht niets vastlegde. Wil je iets anders,
103 103
104 104 ### Archieven
105 105
106 - Formaat: `tar.gz` (PAX), met de lopende kopie als inhoud (`state/…` en `data/…`). Je kunt een archief dus ook met de hand uitpakken.
106 - Formaat: `tar.gz` (PAX), met de lopende kopie als inhoud (`state/…` en `data/…`). Je kunt een archief dus ook met de hand uitpakken. Naast de bestanden bevat het voor elke bare repository de mappen `refs/`, `refs/heads/`, `refs/tags/`, `objects/`, `objects/info/` en `objects/pack/`, ook als ze leeg zijn. Staan alle refs in `packed-refs` (na `git gc` of `git pack-refs --all`), dan is `refs/` leeg; zonder die map is de map na uitpakken geen git-repository.
107 107 - Naam: `bluegit-YYYYMMDD-HHMMSS.tar.gz` in UTC, met `-2`, `-3`, … als er in dezelfde seconde meer zijn.
108 108 - Het eerste archief komt binnen een minuut na de eerste geslaagde sync, daarna elk `archive_interval` (standaard 24u).
109 109 - Er wordt eerst naar een tijdelijk bestand geschreven en daarna hernoemd. Een half archief komt dus nooit in de lijst.
@@ -103,7 +103,7 @@ Deze keuzes heb ik gemaakt waar de opdracht niets vastlegde. Wil je iets anders,
103
103
104### Archieven
104### Archieven
105
105
106- Formaat: `tar.gz` (PAX), met de lopende kopie als inhoud (`state/…` en `data/…`). Je kunt een archief dus ook met de hand uitpakken.
106- Formaat: `tar.gz` (PAX), met de lopende kopie als inhoud (`state/…` en `data/…`). Je kunt een archief dus ook met de hand uitpakken. Naast de bestanden bevat het voor elke bare repository de mappen `refs/`, `refs/heads/`, `refs/tags/`, `objects/`, `objects/info/` en `objects/pack/`, ook als ze leeg zijn. Staan alle refs in `packed-refs` (na `git gc` of `git pack-refs --all`), dan is `refs/` leeg; zonder die map is de map na uitpakken geen git-repository.
107- Naam: `bluegit-YYYYMMDD-HHMMSS.tar.gz` in UTC, met `-2`, `-3`, … als er in dezelfde seconde meer zijn.
107- Naam: `bluegit-YYYYMMDD-HHMMSS.tar.gz` in UTC, met `-2`, `-3`, … als er in dezelfde seconde meer zijn.
108- Het eerste archief komt binnen een minuut na de eerste geslaagde sync, daarna elk `archive_interval` (standaard 24u).
108- Het eerste archief komt binnen een minuut na de eerste geslaagde sync, daarna elk `archive_interval` (standaard 24u).
109- Er wordt eerst naar een tijdelijk bestand geschreven en daarna hernoemd. Een half archief komt dus nooit in de lijst.
109- Er wordt eerst naar een tijdelijk bestand geschreven en daarna hernoemd. Een half archief komt dus nooit in de lijst.
docs/BACKUP-PROTOCOL.md +1 −1
@@ -97,4 +97,4 @@ Niet mee: `config.yml`, `storage_path`, `cache.json`, `backup.json` en `instance
97 97
98 98 ## Terugzetten
99 99
100 `POST /api/v1/backup/restore` pakt het archief uit in `<state>/.restore` en `<datadisk>/.restore`; de live gegevens blijven tot dan onaangeroerd. Een ongeldig archief (pad buiten de lijst hierboven, `..`, symlink, geen database of `secret.key`) wordt geweigerd en opgeruimd. Daarna weigert BlueGit schrijvende verzoeken (503), sluit af zoals bij een gewone stop en start zichzelf opnieuw met `exec` (zelfde PID, dus systemd ziet geen crash). Bij de start, vóór de database opengaat, worden de mappen omgewisseld: alles uit de lijst hierboven wordt vervangen, ook wat niet in het archief zat. Een BlueGit zonder datadisk kan geen archief met repositories aannemen; kies eerst de datadisk in `/setup`.
100 `POST /api/v1/backup/restore` pakt het archief uit in `<state>/.restore` en `<datadisk>/.restore`; de live gegevens blijven tot dan onaangeroerd. Een ongeldig archief (pad buiten de lijst hierboven, `..`, symlink, geen database of `secret.key`) wordt geweigerd en opgeruimd. Mapitems met een geldig pad worden aangemaakt. Na het uitpakken krijgt elke bare repository (`*.git` met `HEAD`) de mappen `refs/heads`, `refs/tags`, `objects/info` en `objects/pack` als ze ontbreken; zo levert ook een ouder archief zonder lege mappen een geldige repository op. Daarna weigert BlueGit schrijvende verzoeken (503), sluit af zoals bij een gewone stop en start zichzelf opnieuw met `exec` (zelfde PID, dus systemd ziet geen crash). Bij de start, vóór de database opengaat, worden de mappen omgewisseld: alles uit de lijst hierboven wordt vervangen, ook wat niet in het archief zat. Een BlueGit zonder datadisk kan geen archief met repositories aannemen; kies eerst de datadisk in `/setup`.
@@ -97,4 +97,4 @@ Niet mee: `config.yml`, `storage_path`, `cache.json`, `backup.json` en `instance
97
97
98## Terugzetten
98## Terugzetten
99
99
100`POST /api/v1/backup/restore` pakt het archief uit in `<state>/.restore` en `<datadisk>/.restore`; de live gegevens blijven tot dan onaangeroerd. Een ongeldig archief (pad buiten de lijst hierboven, `..`, symlink, geen database of `secret.key`) wordt geweigerd en opgeruimd. Daarna weigert BlueGit schrijvende verzoeken (503), sluit af zoals bij een gewone stop en start zichzelf opnieuw met `exec` (zelfde PID, dus systemd ziet geen crash). Bij de start, vóór de database opengaat, worden de mappen omgewisseld: alles uit de lijst hierboven wordt vervangen, ook wat niet in het archief zat. Een BlueGit zonder datadisk kan geen archief met repositories aannemen; kies eerst de datadisk in `/setup`.
100`POST /api/v1/backup/restore` pakt het archief uit in `<state>/.restore` en `<datadisk>/.restore`; de live gegevens blijven tot dan onaangeroerd. Een ongeldig archief (pad buiten de lijst hierboven, `..`, symlink, geen database of `secret.key`) wordt geweigerd en opgeruimd. Mapitems met een geldig pad worden aangemaakt. Na het uitpakken krijgt elke bare repository (`*.git` met `HEAD`) de mappen `refs/heads`, `refs/tags`, `objects/info` en `objects/pack` als ze ontbreken; zo levert ook een ouder archief zonder lege mappen een geldige repository op. Daarna weigert BlueGit schrijvende verzoeken (503), sluit af zoals bij een gewone stop en start zichzelf opnieuw met `exec` (zelfde PID, dus systemd ziet geen crash). Bij de start, vóór de database opengaat, worden de mappen omgewisseld: alles uit de lijst hierboven wordt vervangen, ook wat niet in het archief zat. Een BlueGit zonder datadisk kan geen archief met repositories aannemen; kies eerst de datadisk in `/setup`.
docs/BACKUP.md +1 −1
@@ -97,4 +97,4 @@ Niet mee: `config.yml`, `storage_path`, `cache.json`, `backup.json` en `instance
97 97
98 98 ## Terugzetten
99 99
100 `POST /api/v1/backup/restore` pakt het archief uit in `<state>/.restore` en `<datadisk>/.restore`; de live gegevens blijven tot dan onaangeroerd. Een ongeldig archief (pad buiten de lijst hierboven, `..`, symlink, geen database of `secret.key`) wordt geweigerd en opgeruimd. Daarna weigert BlueGit schrijvende verzoeken (503), sluit af zoals bij een gewone stop en start zichzelf opnieuw met `exec` (zelfde PID, dus systemd ziet geen crash). Bij de start, vóór de database opengaat, worden de mappen omgewisseld: alles uit de lijst hierboven wordt vervangen, ook wat niet in het archief zat. Een BlueGit zonder datadisk kan geen archief met repositories aannemen; kies eerst de datadisk in `/setup`.
100 `POST /api/v1/backup/restore` pakt het archief uit in `<state>/.restore` en `<datadisk>/.restore`; de live gegevens blijven tot dan onaangeroerd. Een ongeldig archief (pad buiten de lijst hierboven, `..`, symlink, geen database of `secret.key`) wordt geweigerd en opgeruimd. Mapitems met een geldig pad worden aangemaakt. Na het uitpakken krijgt elke bare repository (`*.git` met `HEAD`) de mappen `refs/heads`, `refs/tags`, `objects/info` en `objects/pack` als ze ontbreken; zo levert ook een ouder archief zonder lege mappen een geldige repository op. Daarna weigert BlueGit schrijvende verzoeken (503), sluit af zoals bij een gewone stop en start zichzelf opnieuw met `exec` (zelfde PID, dus systemd ziet geen crash). Bij de start, vóór de database opengaat, worden de mappen omgewisseld: alles uit de lijst hierboven wordt vervangen, ook wat niet in het archief zat. Een BlueGit zonder datadisk kan geen archief met repositories aannemen; kies eerst de datadisk in `/setup`.
@@ -97,4 +97,4 @@ Niet mee: `config.yml`, `storage_path`, `cache.json`, `backup.json` en `instance
97
97
98## Terugzetten
98## Terugzetten
99
99
100`POST /api/v1/backup/restore` pakt het archief uit in `<state>/.restore` en `<datadisk>/.restore`; de live gegevens blijven tot dan onaangeroerd. Een ongeldig archief (pad buiten de lijst hierboven, `..`, symlink, geen database of `secret.key`) wordt geweigerd en opgeruimd. Daarna weigert BlueGit schrijvende verzoeken (503), sluit af zoals bij een gewone stop en start zichzelf opnieuw met `exec` (zelfde PID, dus systemd ziet geen crash). Bij de start, vóór de database opengaat, worden de mappen omgewisseld: alles uit de lijst hierboven wordt vervangen, ook wat niet in het archief zat. Een BlueGit zonder datadisk kan geen archief met repositories aannemen; kies eerst de datadisk in `/setup`.
100`POST /api/v1/backup/restore` pakt het archief uit in `<state>/.restore` en `<datadisk>/.restore`; de live gegevens blijven tot dan onaangeroerd. Een ongeldig archief (pad buiten de lijst hierboven, `..`, symlink, geen database of `secret.key`) wordt geweigerd en opgeruimd. Mapitems met een geldig pad worden aangemaakt. Na het uitpakken krijgt elke bare repository (`*.git` met `HEAD`) de mappen `refs/heads`, `refs/tags`, `objects/info` en `objects/pack` als ze ontbreken; zo levert ook een ouder archief zonder lege mappen een geldige repository op. Daarna weigert BlueGit schrijvende verzoeken (503), sluit af zoals bij een gewone stop en start zichzelf opnieuw met `exec` (zelfde PID, dus systemd ziet geen crash). Bij de start, vóór de database opengaat, worden de mappen omgewisseld: alles uit de lijst hierboven wordt vervangen, ook wat niet in het archief zat. Een BlueGit zonder datadisk kan geen archief met repositories aannemen; kies eerst de datadisk in `/setup`.
internal/backup/restore_packed_test.go added +84 −0
@@ -0,0 +1,84 @@
1 package backup
2
3 import (
4 "archive/tar"
5 "bytes"
6 "compress/gzip"
7 "io/fs"
8 "os"
9 "os/exec"
10 "path/filepath"
11 "strings"
12 "testing"
13 )
14
15 func gitOut(t *testing.T, dir string, args ...string) string {
16 t.Helper()
17 cmd := exec.Command("git", args...)
18 cmd.Dir = dir
19 cmd.Env = append(os.Environ(), "GIT_CONFIG_NOSYSTEM=1", "HOME="+t.TempDir(),
20 "GIT_AUTHOR_NAME=t", "GIT_AUTHOR_EMAIL=t@example.invalid", "GIT_COMMITTER_NAME=t", "GIT_COMMITTER_EMAIL=t@example.invalid")
21 out, err := cmd.CombinedOutput()
22 if err != nil {
23 t.Fatalf("git %v: %v\n%s", args, err, out)
24 }
25 return strings.TrimSpace(string(out))
26 }
27
28 // Restore van een volledig gepackte repo (alle refs in packed-refs, refs/
29 // leeg en dus niet in het archief) levert een geldige repo op.
30 func TestRestorePackedRefsOnlyRepo(t *testing.T) {
31 if _, err := exec.LookPath("git"); err != nil {
32 t.Skip("git niet gevonden")
33 }
34 src := filepath.Join(t.TempDir(), "gepackt.git")
35 gitOut(t, t.TempDir(), "init", "--bare", "-b", "master", src)
36 work := t.TempDir()
37 gitOut(t, work, "init", "-b", "master")
38 _ = os.WriteFile(filepath.Join(work, "a.txt"), []byte("a"), 0o644)
39 gitOut(t, work, "add", ".")
40 gitOut(t, work, "commit", "-m", "eerste")
41 gitOut(t, work, "push", src, "master")
42 gitOut(t, src, "gc", "--quiet")
43 gitOut(t, src, "pack-refs", "--all")
44 head := gitOut(t, src, "rev-parse", "master")
45
46 // Archief zoals de backup server het tot nu toe schreef: alleen
47 // gewone bestanden, geen mappen.
48 var buf bytes.Buffer
49 gz := gzip.NewWriter(&buf)
50 tw := tar.NewWriter(gz)
51 add := func(name string, b []byte) {
52 _ = tw.WriteHeader(&tar.Header{Name: name, Mode: 0o644, Size: int64(len(b)), Typeflag: tar.TypeReg})
53 _, _ = tw.Write(b)
54 }
55 add("state/bluegit.db", []byte("db"))
56 add("state/secret.key", []byte("k"))
57 _ = filepath.WalkDir(src, func(p string, d fs.DirEntry, err error) error {
58 if err != nil || !d.Type().IsRegular() {
59 return err
60 }
61 rel, _ := filepath.Rel(src, p)
62 if strings.HasPrefix(filepath.ToSlash(rel), "refs/") {
63 t.Fatalf("testopzet: %s hoort niet te bestaan", rel)
64 }
65 b, _ := os.ReadFile(p)
66 add("data/repos/tim/gepackt.git/"+filepath.ToSlash(rel), b)
67 return nil
68 })
69 _ = tw.Close()
70 _ = gz.Close()
71
72 tree := Tree{StateDir: t.TempDir(), DataDir: t.TempDir()}
73 if _, err := tree.Stage(&buf); err != nil {
74 t.Fatal(err)
75 }
76 if ok, err := ApplyPending(tree.StateDir); err != nil || !ok {
77 t.Fatal(ok, err)
78 }
79 repo := filepath.Join(tree.DataDir, "repos", "tim", "gepackt.git")
80 gitOut(t, repo, "--git-dir", repo, "fsck", "--full", "--strict")
81 if got := gitOut(t, repo, "--git-dir", repo, "rev-parse", "master"); got != head {
82 t.Fatalf("master %s, verwacht %s", got, head)
83 }
84 }
@@ -0,0 +1,84 @@
1package backup
2
3import (
4 "archive/tar"
5 "bytes"
6 "compress/gzip"
7 "io/fs"
8 "os"
9 "os/exec"
10 "path/filepath"
11 "strings"
12 "testing"
13)
14
15func gitOut(t *testing.T, dir string, args ...string) string {
16 t.Helper()
17 cmd := exec.Command("git", args...)
18 cmd.Dir = dir
19 cmd.Env = append(os.Environ(), "GIT_CONFIG_NOSYSTEM=1", "HOME="+t.TempDir(),
20 "GIT_AUTHOR_NAME=t", "GIT_AUTHOR_EMAIL=t@example.invalid", "GIT_COMMITTER_NAME=t", "GIT_COMMITTER_EMAIL=t@example.invalid")
21 out, err := cmd.CombinedOutput()
22 if err != nil {
23 t.Fatalf("git %v: %v\n%s", args, err, out)
24 }
25 return strings.TrimSpace(string(out))
26}
27
28// Restore van een volledig gepackte repo (alle refs in packed-refs, refs/
29// leeg en dus niet in het archief) levert een geldige repo op.
30func TestRestorePackedRefsOnlyRepo(t *testing.T) {
31 if _, err := exec.LookPath("git"); err != nil {
32 t.Skip("git niet gevonden")
33 }
34 src := filepath.Join(t.TempDir(), "gepackt.git")
35 gitOut(t, t.TempDir(), "init", "--bare", "-b", "master", src)
36 work := t.TempDir()
37 gitOut(t, work, "init", "-b", "master")
38 _ = os.WriteFile(filepath.Join(work, "a.txt"), []byte("a"), 0o644)
39 gitOut(t, work, "add", ".")
40 gitOut(t, work, "commit", "-m", "eerste")
41 gitOut(t, work, "push", src, "master")
42 gitOut(t, src, "gc", "--quiet")
43 gitOut(t, src, "pack-refs", "--all")
44 head := gitOut(t, src, "rev-parse", "master")
45
46 // Archief zoals de backup server het tot nu toe schreef: alleen
47 // gewone bestanden, geen mappen.
48 var buf bytes.Buffer
49 gz := gzip.NewWriter(&buf)
50 tw := tar.NewWriter(gz)
51 add := func(name string, b []byte) {
52 _ = tw.WriteHeader(&tar.Header{Name: name, Mode: 0o644, Size: int64(len(b)), Typeflag: tar.TypeReg})
53 _, _ = tw.Write(b)
54 }
55 add("state/bluegit.db", []byte("db"))
56 add("state/secret.key", []byte("k"))
57 _ = filepath.WalkDir(src, func(p string, d fs.DirEntry, err error) error {
58 if err != nil || !d.Type().IsRegular() {
59 return err
60 }
61 rel, _ := filepath.Rel(src, p)
62 if strings.HasPrefix(filepath.ToSlash(rel), "refs/") {
63 t.Fatalf("testopzet: %s hoort niet te bestaan", rel)
64 }
65 b, _ := os.ReadFile(p)
66 add("data/repos/tim/gepackt.git/"+filepath.ToSlash(rel), b)
67 return nil
68 })
69 _ = tw.Close()
70 _ = gz.Close()
71
72 tree := Tree{StateDir: t.TempDir(), DataDir: t.TempDir()}
73 if _, err := tree.Stage(&buf); err != nil {
74 t.Fatal(err)
75 }
76 if ok, err := ApplyPending(tree.StateDir); err != nil || !ok {
77 t.Fatal(ok, err)
78 }
79 repo := filepath.Join(tree.DataDir, "repos", "tim", "gepackt.git")
80 gitOut(t, repo, "--git-dir", repo, "fsck", "--full", "--strict")
81 if got := gitOut(t, repo, "--git-dir", repo, "rev-parse", "master"); got != head {
82 t.Fatalf("master %s, verwacht %s", got, head)
83 }
84}
internal/backup/tree.go +23 −0
@@ -17,6 +17,8 @@ import (
17 17 "strings"
18 18 "sync"
19 19 "time"
20
21 "gitlab.com/Timfa/bluegit/internal/barerepo"
20 22 )
21 23
22 24 // Wat er in een backup zit. Logische paden beginnen met state/ of data/.
@@ -323,6 +325,20 @@ func (t Tree) Stage(r io.Reader) (int, error) {
323 325 return fail(err)
324 326 }
325 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 }
326 342 continue
327 343 }
328 344 if h.Typeflag != tar.TypeReg {
@@ -367,6 +383,13 @@ func (t Tree) Stage(r io.Reader) (int, error) {
367 383 if !seenDB || !seenKey {
368 384 return fail(errors.New("het archief mist state/bluegit.db of state/secret.key"))
369 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 }
370 393 b, _ := json.Marshal(pending{DataDir: t.DataDir, At: time.Now().UTC(), Files: n})
371 394 if err := os.WriteFile(filepath.Join(stateStage, "READY"), b, 0o600); err != nil {
372 395 return fail(err)
@@ -17,6 +17,8 @@ import (
17 "strings"
17 "strings"
18 "sync"
18 "sync"
19 "time"
19 "time"
20
21 "gitlab.com/Timfa/bluegit/internal/barerepo"
20)
22)
21
23
22// Wat er in een backup zit. Logische paden beginnen met state/ of data/.
24// Wat er in een backup zit. Logische paden beginnen met state/ of data/.
@@ -323,6 +325,20 @@ func (t Tree) Stage(r io.Reader) (int, error) {
323 return fail(err)
325 return fail(err)
324 }
326 }
325 if h.Typeflag == tar.TypeDir {
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 }
326 continue
342 continue
327 }
343 }
328 if h.Typeflag != tar.TypeReg {
344 if h.Typeflag != tar.TypeReg {
@@ -367,6 +383,13 @@ func (t Tree) Stage(r io.Reader) (int, error) {
367 if !seenDB || !seenKey {
383 if !seenDB || !seenKey {
368 return fail(errors.New("het archief mist state/bluegit.db of state/secret.key"))
384 return fail(errors.New("het archief mist state/bluegit.db of state/secret.key"))
369 }
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 }
370 b, _ := json.Marshal(pending{DataDir: t.DataDir, At: time.Now().UTC(), Files: n})
393 b, _ := json.Marshal(pending{DataDir: t.DataDir, At: time.Now().UTC(), Files: n})
371 if err := os.WriteFile(filepath.Join(stateStage, "READY"), b, 0o600); err != nil {
394 if err := os.WriteFile(filepath.Join(stateStage, "READY"), b, 0o600); err != nil {
372 return fail(err)
395 return fail(err)
internal/backupserver/archive/archive.go +32 −3
@@ -20,6 +20,7 @@ import (
20 20 "time"
21 21
22 22 "gitlab.com/Timfa/bluegit/internal/backupserver/protocol"
23 "gitlab.com/Timfa/bluegit/internal/barerepo"
23 24 )
24 25
25 26 var nameRE = regexp.MustCompile(`^bluegit-\d{8}-\d{6}(-\d{1,3})?\.tar\.gz$`)
@@ -255,13 +256,32 @@ func WriteTarGz(w io.Writer, dir string) error {
255 256 return err
256 257 }
257 258 sort.Strings(paths)
259 var logicals []string
258 260 for _, p := range paths {
259 261 rel, _ := filepath.Rel(dir, p)
260 262 logical := filepath.ToSlash(rel)
261 263 if _, ok := protocol.CleanLogical(logical); !ok {
262 264 continue
263 265 }
264 if err := addFile(tw, p, logical); err != nil {
266 logicals = append(logicals, logical)
267 }
268 // De verplichte mappen van elke bare repo gaan expliciet mee. Een lege
269 // refs/ (alle refs in packed-refs) zou anders ontbreken, en dan is de
270 // repo na uitpakken geen git-repository meer.
271 for _, root := range barerepo.Roots(logicals, "data/repos/") {
272 mt := time.Now()
273 if fi, err := os.Stat(filepath.Join(dir, filepath.FromSlash(root), "HEAD")); err == nil {
274 mt = fi.ModTime()
275 }
276 for _, sub := range barerepo.Dirs {
277 h := &tar.Header{Name: root + "/" + sub + "/", Mode: 0o755, Typeflag: tar.TypeDir, ModTime: mt, Format: tar.FormatPAX}
278 if err := tw.WriteHeader(h); err != nil {
279 return err
280 }
281 }
282 }
283 for _, logical := range logicals {
284 if err := addFile(tw, filepath.Join(dir, filepath.FromSlash(logical)), logical); err != nil {
265 285 return err
266 286 }
267 287 }
@@ -293,7 +313,8 @@ func addFile(tw *tar.Writer, p, logical string) error {
293 313 }
294 314
295 315 // Extract pakt archief src uit in dst (dat nog niet mag bestaan). Alleen
296 // gewone bestanden met geldige logische paden.
316 // gewone bestanden en mappen met geldige logische paden. Daarna krijgt elke
317 // bare repo zijn verplichte mappen, ook bij een archief zonder mappen.
297 318 func Extract(src, dst string) error {
298 319 f, err := os.Open(src)
299 320 if err != nil {
@@ -316,12 +337,20 @@ func ExtractReader(r io.Reader, dst string) error {
316 337 for {
317 338 h, err := tr.Next()
318 339 if err == io.EOF {
319 return nil
340 _, err := barerepo.Repair(filepath.Join(dst, "data", "repos"))
341 return err
320 342 }
321 343 if err != nil {
322 344 return err
323 345 }
324 346 if h.Typeflag == tar.TypeDir {
347 // Alleen mappen met een geldig logisch pad; de rest negeren we,
348 // zoals altijd.
349 if logical, ok := protocol.CleanLogical(strings.TrimSuffix(strings.TrimPrefix(h.Name, "./"), "/")); ok {
350 if err := os.MkdirAll(filepath.Join(dst, filepath.FromSlash(logical)), 0o750); err != nil {
351 return err
352 }
353 }
325 354 continue
326 355 }
327 356 logical, ok := protocol.CleanLogical(strings.TrimPrefix(h.Name, "./"))
@@ -20,6 +20,7 @@ import (
20 "time"
20 "time"
21
21
22 "gitlab.com/Timfa/bluegit/internal/backupserver/protocol"
22 "gitlab.com/Timfa/bluegit/internal/backupserver/protocol"
23 "gitlab.com/Timfa/bluegit/internal/barerepo"
23)
24)
24
25
25var nameRE = regexp.MustCompile(`^bluegit-\d{8}-\d{6}(-\d{1,3})?\.tar\.gz$`)
26var nameRE = regexp.MustCompile(`^bluegit-\d{8}-\d{6}(-\d{1,3})?\.tar\.gz$`)
@@ -255,13 +256,32 @@ func WriteTarGz(w io.Writer, dir string) error {
255 return err
256 return err
256 }
257 }
257 sort.Strings(paths)
258 sort.Strings(paths)
259 var logicals []string
258 for _, p := range paths {
260 for _, p := range paths {
259 rel, _ := filepath.Rel(dir, p)
261 rel, _ := filepath.Rel(dir, p)
260 logical := filepath.ToSlash(rel)
262 logical := filepath.ToSlash(rel)
261 if _, ok := protocol.CleanLogical(logical); !ok {
263 if _, ok := protocol.CleanLogical(logical); !ok {
262 continue
264 continue
263 }
265 }
264 if err := addFile(tw, p, logical); err != nil {
266 logicals = append(logicals, logical)
267 }
268 // De verplichte mappen van elke bare repo gaan expliciet mee. Een lege
269 // refs/ (alle refs in packed-refs) zou anders ontbreken, en dan is de
270 // repo na uitpakken geen git-repository meer.
271 for _, root := range barerepo.Roots(logicals, "data/repos/") {
272 mt := time.Now()
273 if fi, err := os.Stat(filepath.Join(dir, filepath.FromSlash(root), "HEAD")); err == nil {
274 mt = fi.ModTime()
275 }
276 for _, sub := range barerepo.Dirs {
277 h := &tar.Header{Name: root + "/" + sub + "/", Mode: 0o755, Typeflag: tar.TypeDir, ModTime: mt, Format: tar.FormatPAX}
278 if err := tw.WriteHeader(h); err != nil {
279 return err
280 }
281 }
282 }
283 for _, logical := range logicals {
284 if err := addFile(tw, filepath.Join(dir, filepath.FromSlash(logical)), logical); err != nil {
265 return err
285 return err
266 }
286 }
267 }
287 }
@@ -293,7 +313,8 @@ func addFile(tw *tar.Writer, p, logical string) error {
293}
313}
294
314
295// Extract pakt archief src uit in dst (dat nog niet mag bestaan). Alleen
315// Extract pakt archief src uit in dst (dat nog niet mag bestaan). Alleen
296// gewone bestanden met geldige logische paden.
316// gewone bestanden en mappen met geldige logische paden. Daarna krijgt elke
317// bare repo zijn verplichte mappen, ook bij een archief zonder mappen.
297func Extract(src, dst string) error {
318func Extract(src, dst string) error {
298 f, err := os.Open(src)
319 f, err := os.Open(src)
299 if err != nil {
320 if err != nil {
@@ -316,12 +337,20 @@ func ExtractReader(r io.Reader, dst string) error {
316 for {
337 for {
317 h, err := tr.Next()
338 h, err := tr.Next()
318 if err == io.EOF {
339 if err == io.EOF {
319 return nil
340 _, err := barerepo.Repair(filepath.Join(dst, "data", "repos"))
341 return err
320 }
342 }
321 if err != nil {
343 if err != nil {
322 return err
344 return err
323 }
345 }
324 if h.Typeflag == tar.TypeDir {
346 if h.Typeflag == tar.TypeDir {
347 // Alleen mappen met een geldig logisch pad; de rest negeren we,
348 // zoals altijd.
349 if logical, ok := protocol.CleanLogical(strings.TrimSuffix(strings.TrimPrefix(h.Name, "./"), "/")); ok {
350 if err := os.MkdirAll(filepath.Join(dst, filepath.FromSlash(logical)), 0o750); err != nil {
351 return err
352 }
353 }
325 continue
354 continue
326 }
355 }
327 logical, ok := protocol.CleanLogical(strings.TrimPrefix(h.Name, "./"))
356 logical, ok := protocol.CleanLogical(strings.TrimPrefix(h.Name, "./"))
internal/backupserver/archive/packed_test.go added +159 −0
@@ -0,0 +1,159 @@
1 package archive
2
3 import (
4 "archive/tar"
5 "bytes"
6 "compress/gzip"
7 "io"
8 "io/fs"
9 "os"
10 "os/exec"
11 "path/filepath"
12 "strings"
13 "testing"
14 )
15
16 func runGit(t *testing.T, dir string, args ...string) string {
17 t.Helper()
18 cmd := exec.Command("git", args...)
19 cmd.Dir = dir
20 cmd.Env = append(os.Environ(), "GIT_CONFIG_NOSYSTEM=1", "HOME="+t.TempDir(),
21 "GIT_AUTHOR_NAME=t", "GIT_AUTHOR_EMAIL=t@example.invalid", "GIT_COMMITTER_NAME=t", "GIT_COMMITTER_EMAIL=t@example.invalid")
22 out, err := cmd.CombinedOutput()
23 if err != nil {
24 t.Fatalf("git %v: %v\n%s", args, err, out)
25 }
26 return strings.TrimSpace(string(out))
27 }
28
29 // packedMirror maakt een kopie (alleen gewone bestanden, zoals de mirror)
30 // met een bare repo waarvan alle refs in packed-refs staan: refs/ is leeg
31 // en ontbreekt dus in de kopie.
32 func packedMirror(t *testing.T) (mirror, head string) {
33 t.Helper()
34 if _, err := exec.LookPath("git"); err != nil {
35 t.Skip("git niet gevonden")
36 }
37 src := filepath.Join(t.TempDir(), "gepackt.git")
38 runGit(t, t.TempDir(), "init", "--bare", "-b", "master", src)
39 work := t.TempDir()
40 runGit(t, work, "init", "-b", "master")
41 _ = os.WriteFile(filepath.Join(work, "a.txt"), []byte("a"), 0o644)
42 runGit(t, work, "add", ".")
43 runGit(t, work, "commit", "-m", "eerste")
44 runGit(t, work, "tag", "v1")
45 runGit(t, work, "push", src, "master", "v1")
46 runGit(t, src, "gc", "--quiet")
47 runGit(t, src, "pack-refs", "--all")
48 head = runGit(t, src, "rev-parse", "master")
49 mirror = t.TempDir()
50 for p, c := range map[string]string{"state/bluegit.db": "db", "state/secret.key": "k"} {
51 full := filepath.Join(mirror, filepath.FromSlash(p))
52 _ = os.MkdirAll(filepath.Dir(full), 0o755)
53 _ = os.WriteFile(full, []byte(c), 0o644)
54 }
55 dstRepo := filepath.Join(mirror, "data", "repos", "tim", "gepackt.git")
56 err := filepath.WalkDir(src, func(p string, d fs.DirEntry, err error) error {
57 if err != nil || !d.Type().IsRegular() {
58 return err
59 }
60 rel, _ := filepath.Rel(src, p)
61 b, err := os.ReadFile(p)
62 if err != nil {
63 return err
64 }
65 out := filepath.Join(dstRepo, rel)
66 _ = os.MkdirAll(filepath.Dir(out), 0o755)
67 return os.WriteFile(out, b, 0o644)
68 })
69 if err != nil {
70 t.Fatal(err)
71 }
72 if _, err := os.Stat(filepath.Join(dstRepo, "refs")); err == nil {
73 t.Fatal("testopzet: refs/ hoort te ontbreken")
74 }
75 return mirror, head
76 }
77
78 func requireValidRepo(t *testing.T, repo, head string) {
79 t.Helper()
80 runGit(t, repo, "--git-dir", repo, "fsck", "--full", "--strict")
81 if got := runGit(t, repo, "--git-dir", repo, "rev-parse", "master"); got != head {
82 t.Fatalf("master %s, verwacht %s", got, head)
83 }
84 if got := runGit(t, repo, "--git-dir", repo, "rev-parse", "v1^{commit}"); got != head {
85 t.Fatalf("v1 %s, verwacht %s", got, head)
86 }
87 }
88
89 // Backup, restore, geldige repo: het archief bevat de verplichte mappen en
90 // Extract levert een repo op die git herkent.
91 func TestPackedRefsOnlyRepoRoundtrip(t *testing.T) {
92 mirror, head := packedMirror(t)
93 var buf bytes.Buffer
94 if err := WriteTarGz(&buf, mirror); err != nil {
95 t.Fatal(err)
96 }
97 raw := buf.Bytes()
98
99 // Het archief heeft mapitems voor refs/heads en refs/tags, zodat ook
100 // een gewone tar -x een geldige repo oplevert.
101 gz, _ := gzip.NewReader(bytes.NewReader(raw))
102 tr := tar.NewReader(gz)
103 dirs := map[string]bool{}
104 for {
105 h, err := tr.Next()
106 if err == io.EOF {
107 break
108 }
109 if err != nil {
110 t.Fatal(err)
111 }
112 if h.Typeflag == tar.TypeDir {
113 dirs[h.Name] = true
114 }
115 }
116 for _, want := range []string{"data/repos/tim/gepackt.git/refs/heads/", "data/repos/tim/gepackt.git/refs/tags/", "data/repos/tim/gepackt.git/objects/pack/"} {
117 if !dirs[want] {
118 t.Fatalf("map %s ontbreekt in archief: %v", want, dirs)
119 }
120 }
121
122 dst := filepath.Join(t.TempDir(), "x")
123 if err := ExtractReader(bytes.NewReader(raw), dst); err != nil {
124 t.Fatal(err)
125 }
126 requireValidRepo(t, filepath.Join(dst, "data/repos/tim/gepackt.git"), head)
127
128 if tarBin, err := exec.LookPath("tar"); err == nil {
129 plain := t.TempDir()
130 cmd := exec.Command(tarBin, "-xzf", "-", "-C", plain)
131 cmd.Stdin = bytes.NewReader(raw)
132 if out, err := cmd.CombinedOutput(); err != nil {
133 t.Fatalf("tar: %v %s", err, out)
134 }
135 requireValidRepo(t, filepath.Join(plain, "data/repos/tim/gepackt.git"), head)
136 }
137 }
138
139 // Een archief van vóór de fix (zonder mapitems) wordt bij Extract hersteld.
140 func TestExtractRepairsOldArchiveWithoutDirs(t *testing.T) {
141 mirror, head := packedMirror(t)
142 var buf bytes.Buffer
143 gz := gzip.NewWriter(&buf)
144 tw := tar.NewWriter(gz)
145 _ = filepath.WalkDir(mirror, func(p string, d fs.DirEntry, err error) error {
146 if err != nil || !d.Type().IsRegular() {
147 return err
148 }
149 rel, _ := filepath.Rel(mirror, p)
150 return addFile(tw, p, filepath.ToSlash(rel))
151 })
152 _ = tw.Close()
153 _ = gz.Close()
154 dst := filepath.Join(t.TempDir(), "x")
155 if err := ExtractReader(&buf, dst); err != nil {
156 t.Fatal(err)
157 }
158 requireValidRepo(t, filepath.Join(dst, "data/repos/tim/gepackt.git"), head)
159 }
@@ -0,0 +1,159 @@
1package archive
2
3import (
4 "archive/tar"
5 "bytes"
6 "compress/gzip"
7 "io"
8 "io/fs"
9 "os"
10 "os/exec"
11 "path/filepath"
12 "strings"
13 "testing"
14)
15
16func runGit(t *testing.T, dir string, args ...string) string {
17 t.Helper()
18 cmd := exec.Command("git", args...)
19 cmd.Dir = dir
20 cmd.Env = append(os.Environ(), "GIT_CONFIG_NOSYSTEM=1", "HOME="+t.TempDir(),
21 "GIT_AUTHOR_NAME=t", "GIT_AUTHOR_EMAIL=t@example.invalid", "GIT_COMMITTER_NAME=t", "GIT_COMMITTER_EMAIL=t@example.invalid")
22 out, err := cmd.CombinedOutput()
23 if err != nil {
24 t.Fatalf("git %v: %v\n%s", args, err, out)
25 }
26 return strings.TrimSpace(string(out))
27}
28
29// packedMirror maakt een kopie (alleen gewone bestanden, zoals de mirror)
30// met een bare repo waarvan alle refs in packed-refs staan: refs/ is leeg
31// en ontbreekt dus in de kopie.
32func packedMirror(t *testing.T) (mirror, head string) {
33 t.Helper()
34 if _, err := exec.LookPath("git"); err != nil {
35 t.Skip("git niet gevonden")
36 }
37 src := filepath.Join(t.TempDir(), "gepackt.git")
38 runGit(t, t.TempDir(), "init", "--bare", "-b", "master", src)
39 work := t.TempDir()
40 runGit(t, work, "init", "-b", "master")
41 _ = os.WriteFile(filepath.Join(work, "a.txt"), []byte("a"), 0o644)
42 runGit(t, work, "add", ".")
43 runGit(t, work, "commit", "-m", "eerste")
44 runGit(t, work, "tag", "v1")
45 runGit(t, work, "push", src, "master", "v1")
46 runGit(t, src, "gc", "--quiet")
47 runGit(t, src, "pack-refs", "--all")
48 head = runGit(t, src, "rev-parse", "master")
49 mirror = t.TempDir()
50 for p, c := range map[string]string{"state/bluegit.db": "db", "state/secret.key": "k"} {
51 full := filepath.Join(mirror, filepath.FromSlash(p))
52 _ = os.MkdirAll(filepath.Dir(full), 0o755)
53 _ = os.WriteFile(full, []byte(c), 0o644)
54 }
55 dstRepo := filepath.Join(mirror, "data", "repos", "tim", "gepackt.git")
56 err := filepath.WalkDir(src, func(p string, d fs.DirEntry, err error) error {
57 if err != nil || !d.Type().IsRegular() {
58 return err
59 }
60 rel, _ := filepath.Rel(src, p)
61 b, err := os.ReadFile(p)
62 if err != nil {
63 return err
64 }
65 out := filepath.Join(dstRepo, rel)
66 _ = os.MkdirAll(filepath.Dir(out), 0o755)
67 return os.WriteFile(out, b, 0o644)
68 })
69 if err != nil {
70 t.Fatal(err)
71 }
72 if _, err := os.Stat(filepath.Join(dstRepo, "refs")); err == nil {
73 t.Fatal("testopzet: refs/ hoort te ontbreken")
74 }
75 return mirror, head
76}
77
78func requireValidRepo(t *testing.T, repo, head string) {
79 t.Helper()
80 runGit(t, repo, "--git-dir", repo, "fsck", "--full", "--strict")
81 if got := runGit(t, repo, "--git-dir", repo, "rev-parse", "master"); got != head {
82 t.Fatalf("master %s, verwacht %s", got, head)
83 }
84 if got := runGit(t, repo, "--git-dir", repo, "rev-parse", "v1^{commit}"); got != head {
85 t.Fatalf("v1 %s, verwacht %s", got, head)
86 }
87}
88
89// Backup, restore, geldige repo: het archief bevat de verplichte mappen en
90// Extract levert een repo op die git herkent.
91func TestPackedRefsOnlyRepoRoundtrip(t *testing.T) {
92 mirror, head := packedMirror(t)
93 var buf bytes.Buffer
94 if err := WriteTarGz(&buf, mirror); err != nil {
95 t.Fatal(err)
96 }
97 raw := buf.Bytes()
98
99 // Het archief heeft mapitems voor refs/heads en refs/tags, zodat ook
100 // een gewone tar -x een geldige repo oplevert.
101 gz, _ := gzip.NewReader(bytes.NewReader(raw))
102 tr := tar.NewReader(gz)
103 dirs := map[string]bool{}
104 for {
105 h, err := tr.Next()
106 if err == io.EOF {
107 break
108 }
109 if err != nil {
110 t.Fatal(err)
111 }
112 if h.Typeflag == tar.TypeDir {
113 dirs[h.Name] = true
114 }
115 }
116 for _, want := range []string{"data/repos/tim/gepackt.git/refs/heads/", "data/repos/tim/gepackt.git/refs/tags/", "data/repos/tim/gepackt.git/objects/pack/"} {
117 if !dirs[want] {
118 t.Fatalf("map %s ontbreekt in archief: %v", want, dirs)
119 }
120 }
121
122 dst := filepath.Join(t.TempDir(), "x")
123 if err := ExtractReader(bytes.NewReader(raw), dst); err != nil {
124 t.Fatal(err)
125 }
126 requireValidRepo(t, filepath.Join(dst, "data/repos/tim/gepackt.git"), head)
127
128 if tarBin, err := exec.LookPath("tar"); err == nil {
129 plain := t.TempDir()
130 cmd := exec.Command(tarBin, "-xzf", "-", "-C", plain)
131 cmd.Stdin = bytes.NewReader(raw)
132 if out, err := cmd.CombinedOutput(); err != nil {
133 t.Fatalf("tar: %v %s", err, out)
134 }
135 requireValidRepo(t, filepath.Join(plain, "data/repos/tim/gepackt.git"), head)
136 }
137}
138
139// Een archief van vóór de fix (zonder mapitems) wordt bij Extract hersteld.
140func TestExtractRepairsOldArchiveWithoutDirs(t *testing.T) {
141 mirror, head := packedMirror(t)
142 var buf bytes.Buffer
143 gz := gzip.NewWriter(&buf)
144 tw := tar.NewWriter(gz)
145 _ = filepath.WalkDir(mirror, func(p string, d fs.DirEntry, err error) error {
146 if err != nil || !d.Type().IsRegular() {
147 return err
148 }
149 rel, _ := filepath.Rel(mirror, p)
150 return addFile(tw, p, filepath.ToSlash(rel))
151 })
152 _ = tw.Close()
153 _ = gz.Close()
154 dst := filepath.Join(t.TempDir(), "x")
155 if err := ExtractReader(&buf, dst); err != nil {
156 t.Fatal(err)
157 }
158 requireValidRepo(t, filepath.Join(dst, "data/repos/tim/gepackt.git"), head)
159}
internal/backupserver/integration/backup_test.go +37 −0
@@ -496,3 +496,40 @@ func TestCLIConnectAsksOnConflict(t *testing.T) {
496 496 t.Fatalf("status: %v %s", err, out)
497 497 }
498 498 }
499
500 // Feature: een volledig gepackte repo (alle refs in packed-refs, refs/ leeg)
501 // komt na archief en restore terug als geldige repository.
502 func TestRestorePackedRefsOnlyRepo(t *testing.T) {
503 a := startBlueGit(t)
504 a.Project("Alpha", "a.txt", "van A")
505 repo := filepath.Join(a.Storage, "repos", "tim", "alpha.git")
506 a.Git(repo, "--git-dir", repo, "pack-refs", "--all")
507 if ents, _ := os.ReadDir(filepath.Join(repo, "refs", "heads")); len(ents) != 0 {
508 t.Fatalf("refs/heads niet leeg na pack-refs: %v", ents)
509 }
510 b := startBackup(t, nil)
511 b.Connect(a, a.NewKey())
512 b.Sync()
513 name := b.Archive()
514
515 // Uitgepakt met gewone tar is het een geldige repo.
516 plain := t.TempDir()
517 if out, err := exec.Command("tar", "-xzf", filepath.Join(b.Dir, "archives", name), "-C", plain).CombinedOutput(); err != nil {
518 t.Fatalf("tar: %v %s", err, out)
519 }
520 a.Git(plain, "--git-dir", filepath.Join(plain, "data/repos/tim/alpha.git"), "fsck", "--full")
521
522 // En via de backup server teruggezet op een nieuwe BlueGit.
523 fresh := startBlueGit(t)
524 code, raw := b.Admin("POST", "/connect", server.ConnectRequest{URL: fresh.URL, Key: fresh.NewKey(), OnConflict: "restore"})
525 if code != 200 || !strings.Contains(string(raw), `"restored":true`) {
526 t.Fatalf("restore: %d %s", code, raw)
527 }
528 fresh.WaitUp(30 * time.Second)
529 fresh.Token = a.Token
530 if code, s := fresh.File("alpha", "a.txt"); code != 200 || s != "van A" {
531 t.Fatalf("gepackte repo na restore: %d %q", code, s)
532 }
533 restored := filepath.Join(fresh.Storage, "repos", "tim", "alpha.git")
534 fresh.Git(restored, "--git-dir", restored, "fsck", "--full")
535 }
@@ -496,3 +496,40 @@ func TestCLIConnectAsksOnConflict(t *testing.T) {
496 t.Fatalf("status: %v %s", err, out)
496 t.Fatalf("status: %v %s", err, out)
497 }
497 }
498}
498}
499
500// Feature: een volledig gepackte repo (alle refs in packed-refs, refs/ leeg)
501// komt na archief en restore terug als geldige repository.
502func TestRestorePackedRefsOnlyRepo(t *testing.T) {
503 a := startBlueGit(t)
504 a.Project("Alpha", "a.txt", "van A")
505 repo := filepath.Join(a.Storage, "repos", "tim", "alpha.git")
506 a.Git(repo, "--git-dir", repo, "pack-refs", "--all")
507 if ents, _ := os.ReadDir(filepath.Join(repo, "refs", "heads")); len(ents) != 0 {
508 t.Fatalf("refs/heads niet leeg na pack-refs: %v", ents)
509 }
510 b := startBackup(t, nil)
511 b.Connect(a, a.NewKey())
512 b.Sync()
513 name := b.Archive()
514
515 // Uitgepakt met gewone tar is het een geldige repo.
516 plain := t.TempDir()
517 if out, err := exec.Command("tar", "-xzf", filepath.Join(b.Dir, "archives", name), "-C", plain).CombinedOutput(); err != nil {
518 t.Fatalf("tar: %v %s", err, out)
519 }
520 a.Git(plain, "--git-dir", filepath.Join(plain, "data/repos/tim/alpha.git"), "fsck", "--full")
521
522 // En via de backup server teruggezet op een nieuwe BlueGit.
523 fresh := startBlueGit(t)
524 code, raw := b.Admin("POST", "/connect", server.ConnectRequest{URL: fresh.URL, Key: fresh.NewKey(), OnConflict: "restore"})
525 if code != 200 || !strings.Contains(string(raw), `"restored":true`) {
526 t.Fatalf("restore: %d %s", code, raw)
527 }
528 fresh.WaitUp(30 * time.Second)
529 fresh.Token = a.Token
530 if code, s := fresh.File("alpha", "a.txt"); code != 200 || s != "van A" {
531 t.Fatalf("gepackte repo na restore: %d %q", code, s)
532 }
533 restored := filepath.Join(fresh.Storage, "repos", "tim", "alpha.git")
534 fresh.Git(restored, "--git-dir", restored, "fsck", "--full")
535}
internal/barerepo/barerepo.go added +84 −0
@@ -0,0 +1,84 @@
1 // Package barerepo kent de mappen die een bare repository nodig heeft.
2 //
3 // Een backup bevat alleen gewone bestanden. Staan alle refs van een
4 // repository in packed-refs (na git gc of git pack-refs --all), dan is
5 // refs/ leeg en komt die map niet in het archief. Zonder refs/ is de map na
6 // het uitpakken geen git-repository meer ("not a git repository"). Daarom
7 // schrijft het archief deze mappen expliciet mee en maken restore en
8 // uitpakken ze alsnog aan, ook voor archieven van vóór deze fix.
9 package barerepo
10
11 import (
12 "errors"
13 "io/fs"
14 "os"
15 "path"
16 "path/filepath"
17 "sort"
18 "strings"
19 )
20
21 // Dirs zijn de mappen die git init --bare aanmaakt en die git nodig heeft
22 // om een map als repository te herkennen (refs/ en objects/), relatief aan
23 // de repository.
24 var Dirs = []string{"objects", "objects/info", "objects/pack", "refs", "refs/heads", "refs/tags"}
25
26 // Roots geeft de repositories bij een lijst logische bestandspaden: elke
27 // map die eindigt op .git en een bestand HEAD bevat, onder prefix (bijv.
28 // "data/repos/"). Gesorteerd, zonder dubbele.
29 func Roots(files []string, prefix string) []string {
30 seen := map[string]bool{}
31 var out []string
32 for _, f := range files {
33 if !strings.HasPrefix(f, prefix) || path.Base(f) != "HEAD" {
34 continue
35 }
36 dir := path.Dir(f)
37 if !strings.HasSuffix(dir, ".git") || dir+"/" == prefix || seen[dir] {
38 continue
39 }
40 seen[dir] = true
41 out = append(out, dir)
42 }
43 sort.Strings(out)
44 return out
45 }
46
47 // Repair maakt onder root de ontbrekende Dirs aan in elke bare repository
48 // (een map *.git met een bestand HEAD). Een ontbrekende root is geen fout.
49 // Geeft het aantal repositories waarin iets is aangemaakt.
50 func Repair(root string) (int, error) {
51 n := 0
52 err := filepath.WalkDir(root, func(p string, d fs.DirEntry, err error) error {
53 if err != nil {
54 if errors.Is(err, fs.ErrNotExist) {
55 return nil
56 }
57 return err
58 }
59 if !d.IsDir() || p == root || !strings.HasSuffix(d.Name(), ".git") {
60 return nil
61 }
62 fi, err := os.Lstat(filepath.Join(p, "HEAD"))
63 if err != nil || !fi.Mode().IsRegular() {
64 return nil
65 }
66 fixed := false
67 for _, sub := range Dirs {
68 dir := filepath.Join(p, filepath.FromSlash(sub))
69 if _, err := os.Lstat(dir); err == nil {
70 continue
71 }
72 if err := os.MkdirAll(dir, 0o755); err != nil {
73 return err
74 }
75 fixed = true
76 }
77 if fixed {
78 n++
79 }
80 // Geen geneste repositories in een bare repo.
81 return fs.SkipDir
82 })
83 return n, err
84 }
@@ -0,0 +1,84 @@
1// Package barerepo kent de mappen die een bare repository nodig heeft.
2//
3// Een backup bevat alleen gewone bestanden. Staan alle refs van een
4// repository in packed-refs (na git gc of git pack-refs --all), dan is
5// refs/ leeg en komt die map niet in het archief. Zonder refs/ is de map na
6// het uitpakken geen git-repository meer ("not a git repository"). Daarom
7// schrijft het archief deze mappen expliciet mee en maken restore en
8// uitpakken ze alsnog aan, ook voor archieven van vóór deze fix.
9package barerepo
10
11import (
12 "errors"
13 "io/fs"
14 "os"
15 "path"
16 "path/filepath"
17 "sort"
18 "strings"
19)
20
21// Dirs zijn de mappen die git init --bare aanmaakt en die git nodig heeft
22// om een map als repository te herkennen (refs/ en objects/), relatief aan
23// de repository.
24var Dirs = []string{"objects", "objects/info", "objects/pack", "refs", "refs/heads", "refs/tags"}
25
26// Roots geeft de repositories bij een lijst logische bestandspaden: elke
27// map die eindigt op .git en een bestand HEAD bevat, onder prefix (bijv.
28// "data/repos/"). Gesorteerd, zonder dubbele.
29func Roots(files []string, prefix string) []string {
30 seen := map[string]bool{}
31 var out []string
32 for _, f := range files {
33 if !strings.HasPrefix(f, prefix) || path.Base(f) != "HEAD" {
34 continue
35 }
36 dir := path.Dir(f)
37 if !strings.HasSuffix(dir, ".git") || dir+"/" == prefix || seen[dir] {
38 continue
39 }
40 seen[dir] = true
41 out = append(out, dir)
42 }
43 sort.Strings(out)
44 return out
45}
46
47// Repair maakt onder root de ontbrekende Dirs aan in elke bare repository
48// (een map *.git met een bestand HEAD). Een ontbrekende root is geen fout.
49// Geeft het aantal repositories waarin iets is aangemaakt.
50func Repair(root string) (int, error) {
51 n := 0
52 err := filepath.WalkDir(root, func(p string, d fs.DirEntry, err error) error {
53 if err != nil {
54 if errors.Is(err, fs.ErrNotExist) {
55 return nil
56 }
57 return err
58 }
59 if !d.IsDir() || p == root || !strings.HasSuffix(d.Name(), ".git") {
60 return nil
61 }
62 fi, err := os.Lstat(filepath.Join(p, "HEAD"))
63 if err != nil || !fi.Mode().IsRegular() {
64 return nil
65 }
66 fixed := false
67 for _, sub := range Dirs {
68 dir := filepath.Join(p, filepath.FromSlash(sub))
69 if _, err := os.Lstat(dir); err == nil {
70 continue
71 }
72 if err := os.MkdirAll(dir, 0o755); err != nil {
73 return err
74 }
75 fixed = true
76 }
77 if fixed {
78 n++
79 }
80 // Geen geneste repositories in een bare repo.
81 return fs.SkipDir
82 })
83 return n, err
84}
internal/barerepo/barerepo_test.go added +62 −0
@@ -0,0 +1,62 @@
1 package barerepo
2
3 import (
4 "os"
5 "os/exec"
6 "path/filepath"
7 "reflect"
8 "testing"
9 )
10
11 func TestRoots(t *testing.T) {
12 got := Roots([]string{
13 "data/repos/tim/gepackt.git/HEAD",
14 "data/repos/tim/gepackt.git/packed-refs",
15 "data/repos/tim/a.git/HEAD",
16 "data/repos/tim/a.git/refs/heads/HEAD", // een branch die HEAD heet
17 "data/repos/tim/geen-repo/HEAD",
18 "data/releases/x.git/HEAD",
19 "state/bluegit.db",
20 }, "data/repos/")
21 want := []string{"data/repos/tim/a.git", "data/repos/tim/gepackt.git"}
22 if !reflect.DeepEqual(got, want) {
23 t.Fatalf("%v", got)
24 }
25 }
26
27 // Een volledig gepackte repo zonder refs/ wordt weer een geldige repo.
28 func TestRepairPackedOnlyRepo(t *testing.T) {
29 root := t.TempDir()
30 repo := filepath.Join(root, "tim", "gepackt.git")
31 _ = os.MkdirAll(filepath.Join(repo, "objects", "pack"), 0o755)
32 _ = os.WriteFile(filepath.Join(repo, "HEAD"), []byte("ref: refs/heads/master\n"), 0o644)
33 _ = os.WriteFile(filepath.Join(repo, "packed-refs"), []byte("# pack-refs with: peeled fully-peeled sorted \n"), 0o644)
34 // Een gewone map met HEAD zonder .git blijft ongemoeid.
35 other := filepath.Join(root, "tim", "los")
36 _ = os.MkdirAll(other, 0o755)
37 _ = os.WriteFile(filepath.Join(other, "HEAD"), []byte("x"), 0o644)
38
39 n, err := Repair(root)
40 if err != nil || n != 1 {
41 t.Fatal(n, err)
42 }
43 for _, d := range Dirs {
44 if fi, err := os.Stat(filepath.Join(repo, d)); err != nil || !fi.IsDir() {
45 t.Fatalf("%s ontbreekt: %v", d, err)
46 }
47 }
48 if _, err := os.Stat(filepath.Join(other, "refs")); err == nil {
49 t.Fatal("map zonder .git aangepast")
50 }
51 if n, err := Repair(root); err != nil || n != 0 {
52 t.Fatalf("tweede keer: %d %v", n, err)
53 }
54 if n, err := Repair(filepath.Join(root, "bestaat-niet")); err != nil || n != 0 {
55 t.Fatalf("ontbrekende root: %d %v", n, err)
56 }
57 if _, err := exec.LookPath("git"); err == nil {
58 if out, err := exec.Command("git", "--git-dir", repo, "rev-parse", "--git-dir").CombinedOutput(); err != nil {
59 t.Fatalf("geen geldige repo: %v %s", err, out)
60 }
61 }
62 }
@@ -0,0 +1,62 @@
1package barerepo
2
3import (
4 "os"
5 "os/exec"
6 "path/filepath"
7 "reflect"
8 "testing"
9)
10
11func TestRoots(t *testing.T) {
12 got := Roots([]string{
13 "data/repos/tim/gepackt.git/HEAD",
14 "data/repos/tim/gepackt.git/packed-refs",
15 "data/repos/tim/a.git/HEAD",
16 "data/repos/tim/a.git/refs/heads/HEAD", // een branch die HEAD heet
17 "data/repos/tim/geen-repo/HEAD",
18 "data/releases/x.git/HEAD",
19 "state/bluegit.db",
20 }, "data/repos/")
21 want := []string{"data/repos/tim/a.git", "data/repos/tim/gepackt.git"}
22 if !reflect.DeepEqual(got, want) {
23 t.Fatalf("%v", got)
24 }
25}
26
27// Een volledig gepackte repo zonder refs/ wordt weer een geldige repo.
28func TestRepairPackedOnlyRepo(t *testing.T) {
29 root := t.TempDir()
30 repo := filepath.Join(root, "tim", "gepackt.git")
31 _ = os.MkdirAll(filepath.Join(repo, "objects", "pack"), 0o755)
32 _ = os.WriteFile(filepath.Join(repo, "HEAD"), []byte("ref: refs/heads/master\n"), 0o644)
33 _ = os.WriteFile(filepath.Join(repo, "packed-refs"), []byte("# pack-refs with: peeled fully-peeled sorted \n"), 0o644)
34 // Een gewone map met HEAD zonder .git blijft ongemoeid.
35 other := filepath.Join(root, "tim", "los")
36 _ = os.MkdirAll(other, 0o755)
37 _ = os.WriteFile(filepath.Join(other, "HEAD"), []byte("x"), 0o644)
38
39 n, err := Repair(root)
40 if err != nil || n != 1 {
41 t.Fatal(n, err)
42 }
43 for _, d := range Dirs {
44 if fi, err := os.Stat(filepath.Join(repo, d)); err != nil || !fi.IsDir() {
45 t.Fatalf("%s ontbreekt: %v", d, err)
46 }
47 }
48 if _, err := os.Stat(filepath.Join(other, "refs")); err == nil {
49 t.Fatal("map zonder .git aangepast")
50 }
51 if n, err := Repair(root); err != nil || n != 0 {
52 t.Fatalf("tweede keer: %d %v", n, err)
53 }
54 if n, err := Repair(filepath.Join(root, "bestaat-niet")); err != nil || n != 0 {
55 t.Fatalf("ontbrekende root: %d %v", n, err)
56 }
57 if _, err := exec.LookPath("git"); err == nil {
58 if out, err := exec.Command("git", "--git-dir", repo, "rev-parse", "--git-dir").CombinedOutput(); err != nil {
59 t.Fatalf("geen geldige repo: %v %s", err, out)
60 }
61 }
62}