Merge branch 'fix/backup-lege-refs' into 'master'
@@ -112,7 +112,7 @@ Deze keuzes heb ik gemaakt waar de opdracht niets vastlegde. Wil je iets anders,
112
112
113
113
### Archieven
114
114
115
- Formaat: `tar.gz` (PAX), met de lopende kopie als inhoud (`state/…` en `data/…`). Je kunt een archief dus ook met de hand uitpakken.
115
- 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.
116
116
- Naam: `bluegit-YYYYMMDD-HHMMSS.tar.gz` in UTC, met `-2`, `-3`, … als er in dezelfde seconde meer zijn.
117
117
- Het eerste archief komt binnen een minuut na de eerste geslaagde sync, daarna elk `archive_interval` (standaard 24u).
118
118
- Er wordt eerst naar een tijdelijk bestand geschreven en daarna hernoemd. Een half archief komt dus nooit in de lijst.
@@ -112,7 +112,7 @@ Deze keuzes heb ik gemaakt waar de opdracht niets vastlegde. Wil je iets anders,112
112
113
### Archieven113
### Archieven114
114
115
- Formaat: `tar.gz` (PAX), met de lopende kopie als inhoud (`state/…` en `data/…`). Je kunt een archief dus ook met de hand uitpakken.115
- 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.116
- Naam: `bluegit-YYYYMMDD-HHMMSS.tar.gz` in UTC, met `-2`, `-3`, … als er in dezelfde seconde meer zijn.116
- Naam: `bluegit-YYYYMMDD-HHMMSS.tar.gz` in UTC, met `-2`, `-3`, … als er in dezelfde seconde meer zijn.117
- Het eerste archief komt binnen een minuut na de eerste geslaagde sync, daarna elk `archive_interval` (standaard 24u).117
- Het eerste archief komt binnen een minuut na de eerste geslaagde sync, daarna elk `archive_interval` (standaard 24u).118
- Er wordt eerst naar een tijdelijk bestand geschreven en daarna hernoemd. Een half archief komt dus nooit in de lijst.118
- Er wordt eerst naar een tijdelijk bestand geschreven en daarna hernoemd. Een half archief komt dus nooit in de lijst.@@ -104,4 +104,4 @@ Niet mee: `config.yml`, `storage_path`, `cache.json`, `backup.json` en `instance
104
104
105
105
## Terugzetten
106
106
107
`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`.
107
`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`.
@@ -104,4 +104,4 @@ Niet mee: `config.yml`, `storage_path`, `cache.json`, `backup.json` en `instance104
104
105
## Terugzetten105
## Terugzetten106
106
107
`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`.107
`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
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 `instance97
97
98
## Terugzetten98
## Terugzetten99
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`.@@ -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 @@1
package backup2
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 = dir19
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: alleen47
// gewone bestanden, geen mappen.48
var buf bytes.Buffer49
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 err60
}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 nil68
})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
}@@ -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/ van329
// 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
continue335
}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
continue342
continue327
}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 bare387
// 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)@@ -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
25
var nameRE = regexp.MustCompile(`^bluegit-\d{8}-\d{6}(-\d{1,3})?\.tar\.gz$`)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
return err256
return err256
}257
}257
sort.Strings(paths)258
sort.Strings(paths)259
var logicals []string258
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
continue264
continue263
}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 lege269
// refs/ (alle refs in packed-refs) zou anders ontbreken, en dan is de270
// 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 err280
}281
}282
}283
for _, logical := range logicals {284
if err := addFile(tw, filepath.Join(dir, filepath.FromSlash(logical)), logical); err != nil {265
return err285
return err266
}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). Alleen315
// Extract pakt archief src uit in dst (dat nog niet mag bestaan). Alleen296
// gewone bestanden met geldige logische paden.316
// gewone bestanden en mappen met geldige logische paden. Daarna krijgt elke317
// bare repo zijn verplichte mappen, ook bij een archief zonder mappen.297
func Extract(src, dst string) error {318
func 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 nil340
_, err := barerepo.Repair(filepath.Join(dst, "data", "repos"))341
return err320
}342
}321
if err != nil {343
if err != nil {322
return err344
return err323
}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 err352
}353
}325
continue354
continue326
}355
}327
logical, ok := protocol.CleanLogical(strings.TrimPrefix(h.Name, "./"))356
logical, ok := protocol.CleanLogical(strings.TrimPrefix(h.Name, "./"))@@ -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 @@1
package archive2
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 = dir20
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 leeg31
// 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 err59
}60
rel, _ := filepath.Rel(src, p)61
b, err := os.ReadFile(p)62
if err != nil {63
return err64
}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, head76
}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 en90
// Extract levert een repo op die git herkent.91
func TestPackedRefsOnlyRepoRoundtrip(t *testing.T) {92
mirror, head := packedMirror(t)93
var buf bytes.Buffer94
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 ook100
// 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
break108
}109
if err != nil {110
t.Fatal(err)111
}112
if h.Typeflag == tar.TypeDir {113
dirs[h.Name] = true114
}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.Buffer143
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 err148
}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
}@@ -500,3 +500,40 @@ func TestCLIConnectAsksOnConflict(t *testing.T) {
500
500
t.Fatalf("status: %v %s", err, out)
501
501
}
502
502
}
503
504
// Feature: een volledig gepackte repo (alle refs in packed-refs, refs/ leeg)
505
// komt na archief en restore terug als geldige repository.
506
func TestRestorePackedRefsOnlyRepo(t *testing.T) {
507
a := startBlueGit(t)
508
a.Project("Alpha", "a.txt", "van A")
509
repo := filepath.Join(a.Storage, "repos", "tim", "alpha.git")
510
a.Git(repo, "--git-dir", repo, "pack-refs", "--all")
511
if ents, _ := os.ReadDir(filepath.Join(repo, "refs", "heads")); len(ents) != 0 {
512
t.Fatalf("refs/heads niet leeg na pack-refs: %v", ents)
513
}
514
b := startBackup(t, nil)
515
b.Connect(a, a.NewKey())
516
b.Sync()
517
name := b.Archive()
518
519
// Uitgepakt met gewone tar is het een geldige repo.
520
plain := t.TempDir()
521
if out, err := exec.Command("tar", "-xzf", filepath.Join(b.Dir, "archives", name), "-C", plain).CombinedOutput(); err != nil {
522
t.Fatalf("tar: %v %s", err, out)
523
}
524
a.Git(plain, "--git-dir", filepath.Join(plain, "data/repos/tim/alpha.git"), "fsck", "--full")
525
526
// En via de backup server teruggezet op een nieuwe BlueGit.
527
fresh := startBlueGit(t)
528
code, raw := b.Admin("POST", "/connect", server.ConnectRequest{URL: fresh.URL, Key: fresh.NewKey(), OnConflict: "restore"})
529
if code != 200 || !strings.Contains(string(raw), `"restored":true`) {
530
t.Fatalf("restore: %d %s", code, raw)
531
}
532
fresh.WaitUp(30 * time.Second)
533
fresh.Token = a.Token
534
if code, s := fresh.File("alpha", "a.txt"); code != 200 || s != "van A" {
535
t.Fatalf("gepackte repo na restore: %d %q", code, s)
536
}
537
restored := filepath.Join(fresh.Storage, "repos", "tim", "alpha.git")
538
fresh.Git(restored, "--git-dir", restored, "fsck", "--full")
539
}
@@ -500,3 +500,40 @@ func TestCLIConnectAsksOnConflict(t *testing.T) {500
t.Fatalf("status: %v %s", err, out)500
t.Fatalf("status: %v %s", err, out)501
}501
}502
}502
}503
504
// Feature: een volledig gepackte repo (alle refs in packed-refs, refs/ leeg)505
// komt na archief en restore terug als geldige repository.506
func TestRestorePackedRefsOnlyRepo(t *testing.T) {507
a := startBlueGit(t)508
a.Project("Alpha", "a.txt", "van A")509
repo := filepath.Join(a.Storage, "repos", "tim", "alpha.git")510
a.Git(repo, "--git-dir", repo, "pack-refs", "--all")511
if ents, _ := os.ReadDir(filepath.Join(repo, "refs", "heads")); len(ents) != 0 {512
t.Fatalf("refs/heads niet leeg na pack-refs: %v", ents)513
}514
b := startBackup(t, nil)515
b.Connect(a, a.NewKey())516
b.Sync()517
name := b.Archive()518
519
// Uitgepakt met gewone tar is het een geldige repo.520
plain := t.TempDir()521
if out, err := exec.Command("tar", "-xzf", filepath.Join(b.Dir, "archives", name), "-C", plain).CombinedOutput(); err != nil {522
t.Fatalf("tar: %v %s", err, out)523
}524
a.Git(plain, "--git-dir", filepath.Join(plain, "data/repos/tim/alpha.git"), "fsck", "--full")525
526
// En via de backup server teruggezet op een nieuwe BlueGit.527
fresh := startBlueGit(t)528
code, raw := b.Admin("POST", "/connect", server.ConnectRequest{URL: fresh.URL, Key: fresh.NewKey(), OnConflict: "restore"})529
if code != 200 || !strings.Contains(string(raw), `"restored":true`) {530
t.Fatalf("restore: %d %s", code, raw)531
}532
fresh.WaitUp(30 * time.Second)533
fresh.Token = a.Token534
if code, s := fresh.File("alpha", "a.txt"); code != 200 || s != "van A" {535
t.Fatalf("gepackte repo na restore: %d %q", code, s)536
}537
restored := filepath.Join(fresh.Storage, "repos", "tim", "alpha.git")538
fresh.Git(restored, "--git-dir", restored, "fsck", "--full")539
}@@ -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 een4
// repository in packed-refs (na git gc of git pack-refs --all), dan is5
// refs/ leeg en komt die map niet in het archief. Zonder refs/ is de map na6
// het uitpakken geen git-repository meer ("not a git repository"). Daarom7
// schrijft het archief deze mappen expliciet mee en maken restore en8
// uitpakken ze alsnog aan, ook voor archieven van vóór deze fix.9
package barerepo10
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 heeft22
// om een map als repository te herkennen (refs/ en objects/), relatief aan23
// 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: elke27
// 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 []string32
for _, f := range files {33
if !strings.HasPrefix(f, prefix) || path.Base(f) != "HEAD" {34
continue35
}36
dir := path.Dir(f)37
if !strings.HasSuffix(dir, ".git") || dir+"/" == prefix || seen[dir] {38
continue39
}40
seen[dir] = true41
out = append(out, dir)42
}43
sort.Strings(out)44
return out45
}46
47
// Repair maakt onder root de ontbrekende Dirs aan in elke bare repository48
// (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 := 052
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 nil56
}57
return err58
}59
if !d.IsDir() || p == root || !strings.HasSuffix(d.Name(), ".git") {60
return nil61
}62
fi, err := os.Lstat(filepath.Join(p, "HEAD"))63
if err != nil || !fi.Mode().IsRegular() {64
return nil65
}66
fixed := false67
for _, sub := range Dirs {68
dir := filepath.Join(p, filepath.FromSlash(sub))69
if _, err := os.Lstat(dir); err == nil {70
continue71
}72
if err := os.MkdirAll(dir, 0o755); err != nil {73
return err74
}75
fixed = true76
}77
if fixed {78
n++79
}80
// Geen geneste repositories in een bare repo.81
return fs.SkipDir82
})83
return n, err84
}@@ -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 @@1
package barerepo2
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 heet17
"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
}