BlueGit

timfa bluegit

Onderhoud: periodieke git gc op hosted bare repositories

Elke 24 uur (instelbaar met git.maintenance_interval) draait BlueGit
git gc --auto op de bare repos, plus optioneel git maintenance voor
loose-objects en incremental-repack. Eén repo tegelijk, lage prioriteit,
gits eigen locking, nooit --prune=now. Fouten slaan alleen die repo over.
Installatiebeheerders starten of bekijken een ronde via
/api/v1/admin/git-maintenance.

timfa Grok Bot · pushed by timfa

Authored 2026-11-12 · 4 days ago

Hash
a68880315afda7df46955d0d46c5e5798d0eaf93
Parent
d9aef995
Pipeline
Passed
11 files changed +661 −1
README.md +1 −0
@@ -20,6 +20,7 @@ Het logo is de blauwe ster: [`assets/logo.svg`](assets/logo.svg).
20 20 - Geheimen als omgevingsvariabelen in een job. Een beschermd geheim gaat alleen mee op een beschermde branch of een tag die op een beschermd tagpatroon past.
21 21 - Groepen, met eigen leden, geheimen en webhooks.
22 22 - Git over SSH en over HTTPS.
23 - Periodiek onderhoud van de bare repositories (`git gc --auto`, plus `git maintenance` voor loose objects en incremental-repack als de git-binary dat kent). Standaard elke 24 uur (`git.maintenance_interval`; `off` of `0` zet het uit). Eén repo tegelijk, met lage prioriteit (`nice -n 19`) en gits eigen locking, nooit `--prune=now`. Een fout op één repo slaat die over. Installatiebeheerders zien de status en kunnen een ronde starten via `GET`/`POST /api/v1/admin/git-maintenance`.
23 24 - REST-API. Het schema staat op `/api/v1/openapi.json`.
24 25 - Self-update: de instantie installeert een nieuw AUR-pakket met pacman.
25 26 - Linkpreviews: een gedeelde pagina krijgt een kaart via Open Graph, oEmbed en `/-/card.png`.
@@ -20,6 +20,7 @@ Het logo is de blauwe ster: [`assets/logo.svg`](assets/logo.svg).
20- Geheimen als omgevingsvariabelen in een job. Een beschermd geheim gaat alleen mee op een beschermde branch of een tag die op een beschermd tagpatroon past.
20- Geheimen als omgevingsvariabelen in een job. Een beschermd geheim gaat alleen mee op een beschermde branch of een tag die op een beschermd tagpatroon past.
21- Groepen, met eigen leden, geheimen en webhooks.
21- Groepen, met eigen leden, geheimen en webhooks.
22- Git over SSH en over HTTPS.
22- Git over SSH en over HTTPS.
23- Periodiek onderhoud van de bare repositories (`git gc --auto`, plus `git maintenance` voor loose objects en incremental-repack als de git-binary dat kent). Standaard elke 24 uur (`git.maintenance_interval`; `off` of `0` zet het uit). Eén repo tegelijk, met lage prioriteit (`nice -n 19`) en gits eigen locking, nooit `--prune=now`. Een fout op één repo slaat die over. Installatiebeheerders zien de status en kunnen een ronde starten via `GET`/`POST /api/v1/admin/git-maintenance`.
23- REST-API. Het schema staat op `/api/v1/openapi.json`.
24- REST-API. Het schema staat op `/api/v1/openapi.json`.
24- Self-update: de instantie installeert een nieuw AUR-pakket met pacman.
25- Self-update: de instantie installeert een nieuw AUR-pakket met pacman.
25- Linkpreviews: een gedeelde pagina krijgt een kaart via Open Graph, oEmbed en `/-/card.png`.
26- Linkpreviews: een gedeelde pagina krijgt een kaart via Open Graph, oEmbed en `/-/card.png`.
cmd/bluegit/main.go +1 −0
@@ -135,6 +135,7 @@ func serve(args []string) error {
135 135 go rn.Loop(ctx, cfg.CI.Concurrency)
136 136 }
137 137 go srv.StaleManualSweeper(ctx)
138 go srv.GitMaintenanceSweeper(ctx)
138 139 var sh *sshd.Server
139 140 if cfg.SSH.Enabled {
140 141 sh = &sshd.Server{
@@ -135,6 +135,7 @@ func serve(args []string) error {
135 go rn.Loop(ctx, cfg.CI.Concurrency)
135 go rn.Loop(ctx, cfg.CI.Concurrency)
136 }
136 }
137 go srv.StaleManualSweeper(ctx)
137 go srv.StaleManualSweeper(ctx)
138 go srv.GitMaintenanceSweeper(ctx)
138 var sh *sshd.Server
139 var sh *sshd.Server
139 if cfg.SSH.Enabled {
140 if cfg.SSH.Enabled {
140 sh = &sshd.Server{
141 sh = &sshd.Server{
docs/ARCHITECTURE.md +3 −1
@@ -1,6 +1,6 @@
1 1 # Architectuur
2 2
3 BlueGit is één proces. Het bedient de website, de git-HTTP-server, de API en (als het aanstaat) de SSH-listener. Een tweede goroutine plant CI-jobs. Metadata staat in SQLite. Git-objecten staan in bare repositories op de datadisk.
3 BlueGit is één proces. Het bedient de website, de git-HTTP-server, de API en (als het aanstaat) de SSH-listener. Een tweede goroutine plant CI-jobs. Een achtergrondtaak onderhoudt periodiek de bare repositories (`git gc --auto` en optioneel `git maintenance`). Metadata staat in SQLite. Git-objecten staan in bare repositories op de datadisk.
4 4
5 5 ```text
6 6 browser ──HTTPS──▶ ingress ──HTTP──▶ bluegit (web + smart HTTP + API)
@@ -40,6 +40,8 @@ Onder `ProtectSystem=strict` mag het proces alleen in de state-map schrijven, to
40 40 <datadisk>/work/pipeline/job/
41 41 ```
42 42
43 Op de bare repositories onder `<datadisk>/repos` draait BlueGit periodiek git-onderhoud (standaard elke 24 uur, instelbaar met `git.maintenance_interval`). Eerst `git gc --auto`, daarna best-effort `git maintenance run` voor loose-objects en incremental-repack. Dat gebruikt gits eigen locks, zodat een push of clone niet wordt gebroken; `--prune=now` wordt nooit meegegeven, zodat bereikbare refs en objecten blijven. Repositories worden één voor één en met lage prioriteit behandeld. Een fout slaat alleen die repo over. Zonder datadisk is de ronde een no-op. Installatiebeheerders kunnen de status opvragen en een ronde starten met `GET`/`POST /api/v1/admin/git-maintenance` (optioneel `{"repo":"eigenaar/naam"}`).
44
43 45 Geheimen in de database zijn versleuteld. Sessietokens van de auth-server staan als tekst in SQLite; de bestandsmachtiging van de database is de grens. Versleutelen van die sessies staat op de roadmap.
44 46
45 47 ## Auth
@@ -1,6 +1,6 @@
1# Architectuur
1# Architectuur
2
2
3BlueGit is één proces. Het bedient de website, de git-HTTP-server, de API en (als het aanstaat) de SSH-listener. Een tweede goroutine plant CI-jobs. Metadata staat in SQLite. Git-objecten staan in bare repositories op de datadisk.
3BlueGit is één proces. Het bedient de website, de git-HTTP-server, de API en (als het aanstaat) de SSH-listener. Een tweede goroutine plant CI-jobs. Een achtergrondtaak onderhoudt periodiek de bare repositories (`git gc --auto` en optioneel `git maintenance`). Metadata staat in SQLite. Git-objecten staan in bare repositories op de datadisk.
4
4
5```text
5```text
6browser ──HTTPS──▶ ingress ──HTTP──▶ bluegit (web + smart HTTP + API)
6browser ──HTTPS──▶ ingress ──HTTP──▶ bluegit (web + smart HTTP + API)
@@ -40,6 +40,8 @@ Onder `ProtectSystem=strict` mag het proces alleen in de state-map schrijven, to
40<datadisk>/work/pipeline/job/
40<datadisk>/work/pipeline/job/
41```
41```
42
42
43Op de bare repositories onder `<datadisk>/repos` draait BlueGit periodiek git-onderhoud (standaard elke 24 uur, instelbaar met `git.maintenance_interval`). Eerst `git gc --auto`, daarna best-effort `git maintenance run` voor loose-objects en incremental-repack. Dat gebruikt gits eigen locks, zodat een push of clone niet wordt gebroken; `--prune=now` wordt nooit meegegeven, zodat bereikbare refs en objecten blijven. Repositories worden één voor één en met lage prioriteit behandeld. Een fout slaat alleen die repo over. Zonder datadisk is de ronde een no-op. Installatiebeheerders kunnen de status opvragen en een ronde starten met `GET`/`POST /api/v1/admin/git-maintenance` (optioneel `{"repo":"eigenaar/naam"}`).
44
43Geheimen in de database zijn versleuteld. Sessietokens van de auth-server staan als tekst in SQLite; de bestandsmachtiging van de database is de grens. Versleutelen van die sessies staat op de roadmap.
45Geheimen in de database zijn versleuteld. Sessietokens van de auth-server staan als tekst in SQLite; de bestandsmachtiging van de database is de grens. Versleutelen van die sessies staat op de roadmap.
44
46
45## Auth
47## Auth
internal/config/config.go +49 −0
@@ -9,6 +9,7 @@ import (
9 9 "path/filepath"
10 10 "strconv"
11 11 "strings"
12 "time"
12 13
13 14 "gitlab.com/Timfa/bluegit/internal/images"
14 15 "gitlab.com/Timfa/bluegit/internal/realip"
@@ -65,6 +66,47 @@ type Git struct {
65 66 Binary string `yaml:"binary"`
66 67 DefaultBranch string `yaml:"default_branch"`
67 68 HookBinary string `yaml:"hook_binary"`
69 // MaintenanceInterval is hoe vaak bare repositories onderhouden worden
70 // (git maintenance of git gc --auto). Leeg is 24h. "off" of "0" zet uit.
71 // Gebruik een Go-duur (24h, 168h) of een aantal dagen (7d).
72 MaintenanceInterval string `yaml:"maintenance_interval"`
73 }
74
75 // DefaultMaintenanceInterval is de standaard: elke nacht.
76 const DefaultMaintenanceInterval = 24 * time.Hour
77
78 // MaintenanceEvery geeft het interval en of onderhoud aan staat.
79 func (g Git) MaintenanceEvery() (time.Duration, bool, error) {
80 return ParseMaintenanceInterval(g.MaintenanceInterval)
81 }
82
83 // ParseMaintenanceInterval leest een duur. Leeg wordt 24 uur.
84 func ParseMaintenanceInterval(s string) (time.Duration, bool, error) {
85 s = strings.TrimSpace(strings.ToLower(s))
86 if s == "" {
87 return DefaultMaintenanceInterval, true, nil
88 }
89 if s == "off" || s == "false" || s == "no" {
90 return 0, false, nil
91 }
92 if s == "0" || s == "0s" || s == "0h" || s == "0d" {
93 return 0, false, nil
94 }
95 if strings.HasSuffix(s, "d") {
96 n, err := strconv.Atoi(strings.TrimSuffix(s, "d"))
97 if err != nil || n <= 0 {
98 return 0, false, fmt.Errorf("ongeldig maintenance_interval %q", s)
99 }
100 return time.Duration(n) * 24 * time.Hour, true, nil
101 }
102 d, err := time.ParseDuration(s)
103 if err != nil {
104 return 0, false, fmt.Errorf("ongeldig maintenance_interval %q", s)
105 }
106 if d <= 0 {
107 return 0, false, nil
108 }
109 return d, true, nil
68 110 }
69 111
70 112 // SSH is de git-over-SSH-listener en het adres dat in clone-URL's staat.
@@ -290,6 +332,9 @@ func (c *Config) Validate() error {
290 332 if _, err := images.Effective(c.CI.ImageOverrides()); err != nil {
291 333 return err
292 334 }
335 if _, _, err := c.Git.MaintenanceEvery(); err != nil {
336 return err
337 }
293 338 return nil
294 339 }
295 340
@@ -412,6 +457,10 @@ auth:
412 457 git:
413 458 binary: git
414 459 default_branch: master
460 # Periodiek onderhoud van bare repositories (git maintenance of
461 # git gc --auto). Standaard 24h. Zet op off om uit te schakelen.
462 # Nooit --prune=now; één repo tegelijk, met gits eigen locking.
463 # maintenance_interval: 24h
415 464
416 465 ssh:
417 466 enabled: true
@@ -9,6 +9,7 @@ import (
9 "path/filepath"
9 "path/filepath"
10 "strconv"
10 "strconv"
11 "strings"
11 "strings"
12 "time"
12
13
13 "gitlab.com/Timfa/bluegit/internal/images"
14 "gitlab.com/Timfa/bluegit/internal/images"
14 "gitlab.com/Timfa/bluegit/internal/realip"
15 "gitlab.com/Timfa/bluegit/internal/realip"
@@ -65,6 +66,47 @@ type Git struct {
65 Binary string `yaml:"binary"`
66 Binary string `yaml:"binary"`
66 DefaultBranch string `yaml:"default_branch"`
67 DefaultBranch string `yaml:"default_branch"`
67 HookBinary string `yaml:"hook_binary"`
68 HookBinary string `yaml:"hook_binary"`
69 // MaintenanceInterval is hoe vaak bare repositories onderhouden worden
70 // (git maintenance of git gc --auto). Leeg is 24h. "off" of "0" zet uit.
71 // Gebruik een Go-duur (24h, 168h) of een aantal dagen (7d).
72 MaintenanceInterval string `yaml:"maintenance_interval"`
73}
74
75// DefaultMaintenanceInterval is de standaard: elke nacht.
76const DefaultMaintenanceInterval = 24 * time.Hour
77
78// MaintenanceEvery geeft het interval en of onderhoud aan staat.
79func (g Git) MaintenanceEvery() (time.Duration, bool, error) {
80 return ParseMaintenanceInterval(g.MaintenanceInterval)
81}
82
83// ParseMaintenanceInterval leest een duur. Leeg wordt 24 uur.
84func ParseMaintenanceInterval(s string) (time.Duration, bool, error) {
85 s = strings.TrimSpace(strings.ToLower(s))
86 if s == "" {
87 return DefaultMaintenanceInterval, true, nil
88 }
89 if s == "off" || s == "false" || s == "no" {
90 return 0, false, nil
91 }
92 if s == "0" || s == "0s" || s == "0h" || s == "0d" {
93 return 0, false, nil
94 }
95 if strings.HasSuffix(s, "d") {
96 n, err := strconv.Atoi(strings.TrimSuffix(s, "d"))
97 if err != nil || n <= 0 {
98 return 0, false, fmt.Errorf("ongeldig maintenance_interval %q", s)
99 }
100 return time.Duration(n) * 24 * time.Hour, true, nil
101 }
102 d, err := time.ParseDuration(s)
103 if err != nil {
104 return 0, false, fmt.Errorf("ongeldig maintenance_interval %q", s)
105 }
106 if d <= 0 {
107 return 0, false, nil
108 }
109 return d, true, nil
68}
110}
69
111
70// SSH is de git-over-SSH-listener en het adres dat in clone-URL's staat.
112// SSH is de git-over-SSH-listener en het adres dat in clone-URL's staat.
@@ -290,6 +332,9 @@ func (c *Config) Validate() error {
290 if _, err := images.Effective(c.CI.ImageOverrides()); err != nil {
332 if _, err := images.Effective(c.CI.ImageOverrides()); err != nil {
291 return err
333 return err
292 }
334 }
335 if _, _, err := c.Git.MaintenanceEvery(); err != nil {
336 return err
337 }
293 return nil
338 return nil
294}
339}
295
340
@@ -412,6 +457,10 @@ auth:
412git:
457git:
413 binary: git
458 binary: git
414 default_branch: master
459 default_branch: master
460 # Periodiek onderhoud van bare repositories (git maintenance of
461 # git gc --auto). Standaard 24h. Zet op off om uit te schakelen.
462 # Nooit --prune=now; één repo tegelijk, met gits eigen locking.
463 # maintenance_interval: 24h
415
464
416ssh:
465ssh:
417 enabled: true
466 enabled: true
internal/config/config_test.go +42 −0
@@ -5,6 +5,7 @@ import (
5 5 "path/filepath"
6 6 "strings"
7 7 "testing"
8 "time"
8 9 )
9 10
10 11 func TestPresetConfig(t *testing.T) {
@@ -349,3 +350,44 @@ func TestCloneSSHForms(t *testing.T) {
349 350 t.Fatal(got)
350 351 }
351 352 }
353
354 func TestParseMaintenanceInterval(t *testing.T) {
355 cases := []struct {
356 in string
357 want time.Duration
358 enabled bool
359 fail bool
360 }{
361 {"", 24 * time.Hour, true, false},
362 {"24h", 24 * time.Hour, true, false},
363 {"168h", 7 * 24 * time.Hour, true, false},
364 {"7d", 7 * 24 * time.Hour, true, false},
365 {"off", 0, false, false},
366 {"0", 0, false, false},
367 {"niet-geldig", 0, false, true},
368 }
369 for _, c := range cases {
370 d, on, err := ParseMaintenanceInterval(c.in)
371 if c.fail {
372 if err == nil {
373 t.Fatalf("%q: verwacht een fout", c.in)
374 }
375 continue
376 }
377 if err != nil || d != c.want || on != c.enabled {
378 t.Fatalf("%q: got %v %v %v, wil %v %v nil", c.in, d, on, err, c.want, c.enabled)
379 }
380 }
381 }
382
383 func TestLoadRejectsBadMaintenanceInterval(t *testing.T) {
384 dir := t.TempDir()
385 path := dir + "/bluegit.yml"
386 body := []byte("base_url: https://git.example.test\nstorage_path: " + dir + "\nauth:\n mode: dev\ngit:\n maintenance_interval: kapot\n")
387 if err := os.WriteFile(path, body, 0o644); err != nil {
388 t.Fatal(err)
389 }
390 if _, err := Load(path); err == nil {
391 t.Fatal("verwacht een fout bij ongeldig maintenance_interval")
392 }
393 }
@@ -5,6 +5,7 @@ import (
5 "path/filepath"
5 "path/filepath"
6 "strings"
6 "strings"
7 "testing"
7 "testing"
8 "time"
8)
9)
9
10
10func TestPresetConfig(t *testing.T) {
11func TestPresetConfig(t *testing.T) {
@@ -349,3 +350,44 @@ func TestCloneSSHForms(t *testing.T) {
349 t.Fatal(got)
350 t.Fatal(got)
350 }
351 }
351}
352}
353
354func TestParseMaintenanceInterval(t *testing.T) {
355 cases := []struct {
356 in string
357 want time.Duration
358 enabled bool
359 fail bool
360 }{
361 {"", 24 * time.Hour, true, false},
362 {"24h", 24 * time.Hour, true, false},
363 {"168h", 7 * 24 * time.Hour, true, false},
364 {"7d", 7 * 24 * time.Hour, true, false},
365 {"off", 0, false, false},
366 {"0", 0, false, false},
367 {"niet-geldig", 0, false, true},
368 }
369 for _, c := range cases {
370 d, on, err := ParseMaintenanceInterval(c.in)
371 if c.fail {
372 if err == nil {
373 t.Fatalf("%q: verwacht een fout", c.in)
374 }
375 continue
376 }
377 if err != nil || d != c.want || on != c.enabled {
378 t.Fatalf("%q: got %v %v %v, wil %v %v nil", c.in, d, on, err, c.want, c.enabled)
379 }
380 }
381}
382
383func TestLoadRejectsBadMaintenanceInterval(t *testing.T) {
384 dir := t.TempDir()
385 path := dir + "/bluegit.yml"
386 body := []byte("base_url: https://git.example.test\nstorage_path: " + dir + "\nauth:\n mode: dev\ngit:\n maintenance_interval: kapot\n")
387 if err := os.WriteFile(path, body, 0o644); err != nil {
388 t.Fatal(err)
389 }
390 if _, err := Load(path); err == nil {
391 t.Fatal("verwacht een fout bij ongeldig maintenance_interval")
392 }
393}
internal/gitrepo/maintain.go added +122 −0
@@ -0,0 +1,122 @@
1 package gitrepo
2
3 import (
4 "context"
5 "fmt"
6 "os/exec"
7 "strings"
8 "time"
9 )
10
11 // DefaultMaintTimeout is de maximale duur van onderhoud op één repository.
12 const DefaultMaintTimeout = 30 * time.Minute
13
14 // MaintenanceArgs is het voorkeurscommando (modern git). Geen --prune=now.
15 func MaintenanceArgs() []string {
16 return []string{"maintenance", "run", "--task=gc", "--task=loose-objects", "--task=incremental-repack"}
17 }
18
19 // GCAutoArgs is de veilige kern: git's eigen auto-drempels, standaard prune-termijn, locking.
20 func GCAutoArgs() []string {
21 return []string{"gc", "--auto"}
22 }
23
24 // extraMaintTasks zijn optionele stappen na gc --auto. Een taak die niets
25 // te doen heeft (geen packfiles) is geen fout.
26 func extraMaintTasks() [][]string {
27 return [][]string{
28 {"maintenance", "run", "--task=loose-objects"},
29 {"maintenance", "run", "--task=incremental-repack"},
30 }
31 }
32
33 // MaintResult is de uitkomst van onderhoud op één bare repository.
34 type MaintResult struct {
35 Dir string
36 OK bool
37 Output string
38 Err string
39 Duration time.Duration
40 }
41
42 // Maintain voert veilig git-onderhoud uit op één bare repository.
43 // Eerst `git gc --auto` (locking, geen --prune=now). Daarna optioneel
44 // loose-objects en incremental-repack; die mogen stil falen als er niets
45 // te doen is of als de git-binary maintenance niet kent. Een lock van
46 // een push of clone laat git falen; de aanroeper slaat de repo over.
47 func Maintain(ctx context.Context, gitBin, dir string) MaintResult {
48 start := time.Now()
49 res := MaintResult{Dir: dir}
50 if gitBin == "" {
51 gitBin = "git"
52 }
53 if dir == "" {
54 res.Err = "leeg pad"
55 res.Duration = time.Since(start)
56 return res
57 }
58
59 var logs []string
60 out, err := runNice(ctx, gitBin, append([]string{"-C", dir}, GCAutoArgs()...)...)
61 if strings.TrimSpace(out) != "" {
62 logs = append(logs, strings.TrimSpace(out))
63 }
64 if err != nil {
65 res.Err = err.Error()
66 res.Output = strings.Join(logs, "\n")
67 res.Duration = time.Since(start)
68 return res
69 }
70 for _, args := range extraMaintTasks() {
71 if ctx.Err() != nil {
72 break
73 }
74 out, err = runNice(ctx, gitBin, append([]string{"-C", dir}, args...)...)
75 if strings.TrimSpace(out) != "" {
76 logs = append(logs, strings.TrimSpace(out))
77 }
78 if err == nil || isSkippableMaint(err) {
79 continue
80 }
81 // Een echte fout op een extra taak is geen reden de ronde te
82 // laten mislukken: gc --auto is al gelukt. We loggen het wel.
83 logs = append(logs, err.Error())
84 }
85 res.Output = strings.Join(logs, "\n")
86 res.Duration = time.Since(start)
87 res.OK = true
88 return res
89 }
90
91 func isSkippableMaint(err error) bool {
92 if err == nil {
93 return true
94 }
95 msg := strings.ToLower(err.Error())
96 return strings.Contains(msg, "is not a git command") ||
97 strings.Contains(msg, "unknown subcommand") ||
98 strings.Contains(msg, "unknown command") ||
99 strings.Contains(msg, "no pack files") ||
100 strings.Contains(msg, "nothing to repack") ||
101 strings.Contains(msg, "nothing to do")
102 }
103
104 func runNice(ctx context.Context, bin string, args ...string) (string, error) {
105 var cmd *exec.Cmd
106 if nice, err := exec.LookPath("nice"); err == nil {
107 cmd = exec.CommandContext(ctx, nice, append([]string{"-n", "19", bin}, args...)...)
108 } else {
109 cmd = exec.CommandContext(ctx, bin, args...)
110 }
111 var stdout, stderr strings.Builder
112 cmd.Stdout = &stdout
113 cmd.Stderr = &stderr
114 if err := cmd.Run(); err != nil {
115 msg := strings.TrimSpace(stderr.String())
116 if msg == "" {
117 msg = err.Error()
118 }
119 return stdout.String(), fmt.Errorf("%s", msg)
120 }
121 return stdout.String(), nil
122 }
@@ -0,0 +1,122 @@
1package gitrepo
2
3import (
4 "context"
5 "fmt"
6 "os/exec"
7 "strings"
8 "time"
9)
10
11// DefaultMaintTimeout is de maximale duur van onderhoud op één repository.
12const DefaultMaintTimeout = 30 * time.Minute
13
14// MaintenanceArgs is het voorkeurscommando (modern git). Geen --prune=now.
15func MaintenanceArgs() []string {
16 return []string{"maintenance", "run", "--task=gc", "--task=loose-objects", "--task=incremental-repack"}
17}
18
19// GCAutoArgs is de veilige kern: git's eigen auto-drempels, standaard prune-termijn, locking.
20func GCAutoArgs() []string {
21 return []string{"gc", "--auto"}
22}
23
24// extraMaintTasks zijn optionele stappen na gc --auto. Een taak die niets
25// te doen heeft (geen packfiles) is geen fout.
26func extraMaintTasks() [][]string {
27 return [][]string{
28 {"maintenance", "run", "--task=loose-objects"},
29 {"maintenance", "run", "--task=incremental-repack"},
30 }
31}
32
33// MaintResult is de uitkomst van onderhoud op één bare repository.
34type MaintResult struct {
35 Dir string
36 OK bool
37 Output string
38 Err string
39 Duration time.Duration
40}
41
42// Maintain voert veilig git-onderhoud uit op één bare repository.
43// Eerst `git gc --auto` (locking, geen --prune=now). Daarna optioneel
44// loose-objects en incremental-repack; die mogen stil falen als er niets
45// te doen is of als de git-binary maintenance niet kent. Een lock van
46// een push of clone laat git falen; de aanroeper slaat de repo over.
47func Maintain(ctx context.Context, gitBin, dir string) MaintResult {
48 start := time.Now()
49 res := MaintResult{Dir: dir}
50 if gitBin == "" {
51 gitBin = "git"
52 }
53 if dir == "" {
54 res.Err = "leeg pad"
55 res.Duration = time.Since(start)
56 return res
57 }
58
59 var logs []string
60 out, err := runNice(ctx, gitBin, append([]string{"-C", dir}, GCAutoArgs()...)...)
61 if strings.TrimSpace(out) != "" {
62 logs = append(logs, strings.TrimSpace(out))
63 }
64 if err != nil {
65 res.Err = err.Error()
66 res.Output = strings.Join(logs, "\n")
67 res.Duration = time.Since(start)
68 return res
69 }
70 for _, args := range extraMaintTasks() {
71 if ctx.Err() != nil {
72 break
73 }
74 out, err = runNice(ctx, gitBin, append([]string{"-C", dir}, args...)...)
75 if strings.TrimSpace(out) != "" {
76 logs = append(logs, strings.TrimSpace(out))
77 }
78 if err == nil || isSkippableMaint(err) {
79 continue
80 }
81 // Een echte fout op een extra taak is geen reden de ronde te
82 // laten mislukken: gc --auto is al gelukt. We loggen het wel.
83 logs = append(logs, err.Error())
84 }
85 res.Output = strings.Join(logs, "\n")
86 res.Duration = time.Since(start)
87 res.OK = true
88 return res
89}
90
91func isSkippableMaint(err error) bool {
92 if err == nil {
93 return true
94 }
95 msg := strings.ToLower(err.Error())
96 return strings.Contains(msg, "is not a git command") ||
97 strings.Contains(msg, "unknown subcommand") ||
98 strings.Contains(msg, "unknown command") ||
99 strings.Contains(msg, "no pack files") ||
100 strings.Contains(msg, "nothing to repack") ||
101 strings.Contains(msg, "nothing to do")
102}
103
104func runNice(ctx context.Context, bin string, args ...string) (string, error) {
105 var cmd *exec.Cmd
106 if nice, err := exec.LookPath("nice"); err == nil {
107 cmd = exec.CommandContext(ctx, nice, append([]string{"-n", "19", bin}, args...)...)
108 } else {
109 cmd = exec.CommandContext(ctx, bin, args...)
110 }
111 var stdout, stderr strings.Builder
112 cmd.Stdout = &stdout
113 cmd.Stderr = &stderr
114 if err := cmd.Run(); err != nil {
115 msg := strings.TrimSpace(stderr.String())
116 if msg == "" {
117 msg = err.Error()
118 }
119 return stdout.String(), fmt.Errorf("%s", msg)
120 }
121 return stdout.String(), nil
122}
internal/gitrepo/maintain_test.go added +69 −0
@@ -0,0 +1,69 @@
1 package gitrepo
2
3 import (
4 "context"
5 "os"
6 "os/exec"
7 "path/filepath"
8 "strings"
9 "testing"
10 "time"
11 )
12
13 func TestMaintenanceArgsNeverPruneNow(t *testing.T) {
14 for _, args := range [][]string{MaintenanceArgs(), GCAutoArgs()} {
15 joined := strings.Join(args, " ")
16 if strings.Contains(joined, "--prune=now") || strings.Contains(joined, "prune=now") {
17 t.Fatalf("onderhoud mag nooit --prune=now gebruiken: %s", joined)
18 }
19 }
20 }
21
22 func TestMaintainKeepsReachableObjects(t *testing.T) {
23 bare, work := testRepo(t)
24 sha := gitSHA(t, bare, "refs/heads/master")
25 // Een paar losse objecten zodat gc iets te doen heeft, zonder
26 // onbereikbare refs te willen wissen.
27 if err := os.WriteFile(filepath.Join(work, "g"), []byte("meer\n"), 0o644); err != nil {
28 t.Fatal(err)
29 }
30 gitOK(t, work, "add", "g")
31 gitOK(t, work, "commit", "-qm", "meer")
32 gitOK(t, work, "push", "-q", "origin", "master")
33 head := gitSHA(t, bare, "refs/heads/master")
34
35 ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
36 defer cancel()
37 res := Maintain(ctx, "git", bare)
38 if !res.OK {
39 t.Fatalf("maintain: ok=false err=%s out=%s", res.Err, res.Output)
40 }
41 if got := gitSHA(t, bare, "refs/heads/master"); got != head {
42 t.Fatalf("head veranderde: %s -> %s", head, got)
43 }
44 if err := exec.Command("git", "-C", bare, "cat-file", "-e", sha).Run(); err != nil {
45 t.Fatalf("bereikbaar object %s is weg: %v", sha, err)
46 }
47 if err := exec.Command("git", "-C", bare, "cat-file", "-e", head).Run(); err != nil {
48 t.Fatalf("nieuwe head %s is weg: %v", head, err)
49 }
50 }
51
52 func TestMaintainMissingDirIsSkipped(t *testing.T) {
53 ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
54 defer cancel()
55 res := Maintain(ctx, "git", filepath.Join(t.TempDir(), "ontbreekt.git"))
56 if res.OK {
57 t.Fatal("ontbrekende repo zou moeten falen (en overgeslagen worden)")
58 }
59 if res.Err == "" {
60 t.Fatal("verwacht een fouttekst")
61 }
62 }
63
64 func TestMaintainEmptyPathFails(t *testing.T) {
65 res := Maintain(context.Background(), "git", "")
66 if res.OK || res.Err == "" {
67 t.Fatalf("leeg pad moet falen, kreeg %+v", res)
68 }
69 }
@@ -0,0 +1,69 @@
1package gitrepo
2
3import (
4 "context"
5 "os"
6 "os/exec"
7 "path/filepath"
8 "strings"
9 "testing"
10 "time"
11)
12
13func TestMaintenanceArgsNeverPruneNow(t *testing.T) {
14 for _, args := range [][]string{MaintenanceArgs(), GCAutoArgs()} {
15 joined := strings.Join(args, " ")
16 if strings.Contains(joined, "--prune=now") || strings.Contains(joined, "prune=now") {
17 t.Fatalf("onderhoud mag nooit --prune=now gebruiken: %s", joined)
18 }
19 }
20}
21
22func TestMaintainKeepsReachableObjects(t *testing.T) {
23 bare, work := testRepo(t)
24 sha := gitSHA(t, bare, "refs/heads/master")
25 // Een paar losse objecten zodat gc iets te doen heeft, zonder
26 // onbereikbare refs te willen wissen.
27 if err := os.WriteFile(filepath.Join(work, "g"), []byte("meer\n"), 0o644); err != nil {
28 t.Fatal(err)
29 }
30 gitOK(t, work, "add", "g")
31 gitOK(t, work, "commit", "-qm", "meer")
32 gitOK(t, work, "push", "-q", "origin", "master")
33 head := gitSHA(t, bare, "refs/heads/master")
34
35 ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
36 defer cancel()
37 res := Maintain(ctx, "git", bare)
38 if !res.OK {
39 t.Fatalf("maintain: ok=false err=%s out=%s", res.Err, res.Output)
40 }
41 if got := gitSHA(t, bare, "refs/heads/master"); got != head {
42 t.Fatalf("head veranderde: %s -> %s", head, got)
43 }
44 if err := exec.Command("git", "-C", bare, "cat-file", "-e", sha).Run(); err != nil {
45 t.Fatalf("bereikbaar object %s is weg: %v", sha, err)
46 }
47 if err := exec.Command("git", "-C", bare, "cat-file", "-e", head).Run(); err != nil {
48 t.Fatalf("nieuwe head %s is weg: %v", head, err)
49 }
50}
51
52func TestMaintainMissingDirIsSkipped(t *testing.T) {
53 ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
54 defer cancel()
55 res := Maintain(ctx, "git", filepath.Join(t.TempDir(), "ontbreekt.git"))
56 if res.OK {
57 t.Fatal("ontbrekende repo zou moeten falen (en overgeslagen worden)")
58 }
59 if res.Err == "" {
60 t.Fatal("verwacht een fouttekst")
61 }
62}
63
64func TestMaintainEmptyPathFails(t *testing.T) {
65 res := Maintain(context.Background(), "git", "")
66 if res.OK || res.Err == "" {
67 t.Fatalf("leeg pad moet falen, kreeg %+v", res)
68 }
69}
internal/server/api_routes.go +2 −0
@@ -10,6 +10,8 @@ var apiCatalog = []apiRoute{
10 10 {http.MethodGet, "/api/v1/admin/pipelines/settings", access.ScopeAdmin, authUser, "Pipeline settings: stale_manual_days (instance admin)", (*Server).apiAdminPipelineSettings},
11 11 {http.MethodPut, "/api/v1/admin/pipelines/settings", access.ScopeAdmin, authUser, "Change stale_manual_days: manual jobs expire when their pipeline waited only for manual action this many days; 0 = off (instance admin)", (*Server).apiAdminPipelineSettings},
12 12 {http.MethodPost, "/api/v1/admin/pipelines/expire-stale", access.ScopeAdmin, authUser, "Expire stale manual jobs now (superseded and age rule) and list what expired (instance admin)", (*Server).apiAdminExpireStale},
13 {http.MethodGet, "/api/v1/admin/git-maintenance", access.ScopeAdmin, authUser, "Git maintenance status: interval, last run (instance admin)", (*Server).apiAdminGitMaintenance},
14 {http.MethodPost, "/api/v1/admin/git-maintenance", access.ScopeAdmin, authUser, "Run git maintenance now, optionally on one repo (instance admin)", (*Server).apiAdminGitMaintenance},
13 15 {http.MethodGet, "/api/v1/admin/users", access.ScopeAdmin, authUser, "List users and their admin status (instance admin)", (*Server).apiAdminUsers},
14 16 {http.MethodPut, "/api/v1/admin/users/{username}/admin", access.ScopeAdmin, authUser, "Grant or revoke instance admin (instance admin; not yourself)", (*Server).apiAdminUserRole},
15 17 {http.MethodGet, "/api/v1/admin/runner/status", access.ScopeRunnerRead, authUser, "Built-in runner status (instance admin)", (*Server).apiAdminRunnerStatus},
@@ -10,6 +10,8 @@ var apiCatalog = []apiRoute{
10 {http.MethodGet, "/api/v1/admin/pipelines/settings", access.ScopeAdmin, authUser, "Pipeline settings: stale_manual_days (instance admin)", (*Server).apiAdminPipelineSettings},
10 {http.MethodGet, "/api/v1/admin/pipelines/settings", access.ScopeAdmin, authUser, "Pipeline settings: stale_manual_days (instance admin)", (*Server).apiAdminPipelineSettings},
11 {http.MethodPut, "/api/v1/admin/pipelines/settings", access.ScopeAdmin, authUser, "Change stale_manual_days: manual jobs expire when their pipeline waited only for manual action this many days; 0 = off (instance admin)", (*Server).apiAdminPipelineSettings},
11 {http.MethodPut, "/api/v1/admin/pipelines/settings", access.ScopeAdmin, authUser, "Change stale_manual_days: manual jobs expire when their pipeline waited only for manual action this many days; 0 = off (instance admin)", (*Server).apiAdminPipelineSettings},
12 {http.MethodPost, "/api/v1/admin/pipelines/expire-stale", access.ScopeAdmin, authUser, "Expire stale manual jobs now (superseded and age rule) and list what expired (instance admin)", (*Server).apiAdminExpireStale},
12 {http.MethodPost, "/api/v1/admin/pipelines/expire-stale", access.ScopeAdmin, authUser, "Expire stale manual jobs now (superseded and age rule) and list what expired (instance admin)", (*Server).apiAdminExpireStale},
13 {http.MethodGet, "/api/v1/admin/git-maintenance", access.ScopeAdmin, authUser, "Git maintenance status: interval, last run (instance admin)", (*Server).apiAdminGitMaintenance},
14 {http.MethodPost, "/api/v1/admin/git-maintenance", access.ScopeAdmin, authUser, "Run git maintenance now, optionally on one repo (instance admin)", (*Server).apiAdminGitMaintenance},
13 {http.MethodGet, "/api/v1/admin/users", access.ScopeAdmin, authUser, "List users and their admin status (instance admin)", (*Server).apiAdminUsers},
15 {http.MethodGet, "/api/v1/admin/users", access.ScopeAdmin, authUser, "List users and their admin status (instance admin)", (*Server).apiAdminUsers},
14 {http.MethodPut, "/api/v1/admin/users/{username}/admin", access.ScopeAdmin, authUser, "Grant or revoke instance admin (instance admin; not yourself)", (*Server).apiAdminUserRole},
16 {http.MethodPut, "/api/v1/admin/users/{username}/admin", access.ScopeAdmin, authUser, "Grant or revoke instance admin (instance admin; not yourself)", (*Server).apiAdminUserRole},
15 {http.MethodGet, "/api/v1/admin/runner/status", access.ScopeRunnerRead, authUser, "Built-in runner status (instance admin)", (*Server).apiAdminRunnerStatus},
17 {http.MethodGet, "/api/v1/admin/runner/status", access.ScopeRunnerRead, authUser, "Built-in runner status (instance admin)", (*Server).apiAdminRunnerStatus},
internal/server/maintain.go added +249 −0
@@ -0,0 +1,249 @@
1 package server
2
3 import (
4 "context"
5 "net/http"
6 "strings"
7 "sync"
8 "time"
9
10 "gitlab.com/Timfa/bluegit/internal/gitrepo"
11 "gitlab.com/Timfa/bluegit/internal/i18n"
12 "gitlab.com/Timfa/bluegit/internal/store"
13 )
14
15 // gitMaintFirstDelay is de pauze na het starten, zodat de website
16 // eerst opkomt. In tests lager zetten.
17 var gitMaintFirstDelay = 2 * time.Minute
18
19 // gitMaintRepoTimeout is de maximale duur per repository.
20 var gitMaintRepoTimeout = gitrepo.DefaultMaintTimeout
21
22 // GitMaintRepoResult is de uitkomst voor één repository.
23 type GitMaintRepoResult struct {
24 Repo string `json:"repo"`
25 OK bool `json:"ok"`
26 Duration int64 `json:"duration_ms"`
27 Error string `json:"error,omitempty"`
28 }
29
30 // GitMaintReport is de laatste onderhoudsronde.
31 type GitMaintReport struct {
32 Started time.Time `json:"started,omitempty"`
33 Finished time.Time `json:"finished,omitempty"`
34 Repos int `json:"repos"`
35 OK int `json:"ok"`
36 Skipped int `json:"skipped"`
37 Error string `json:"error,omitempty"`
38 Results []GitMaintRepoResult `json:"results,omitempty"`
39 }
40
41 type gitMaintState struct {
42 mu sync.Mutex
43 running bool
44 last GitMaintReport
45 }
46
47 // GitMaintenanceSweeper draait periodiek onderhoud op alle bare
48 // repositories. Uit als maintenance_interval "off" is.
49 func (s *Server) GitMaintenanceSweeper(ctx context.Context) {
50 every, on, err := s.Cfg.Git.MaintenanceEvery()
51 if err != nil {
52 if s.Log != nil {
53 s.Log.Error("git maintenance", "err", err)
54 }
55 return
56 }
57 if !on {
58 if s.Log != nil {
59 s.Log.Info("git maintenance disabled")
60 }
61 return
62 }
63 if s.Log != nil {
64 s.Log.Info("git maintenance scheduled", "interval", every.String())
65 }
66 first := time.NewTimer(gitMaintFirstDelay)
67 defer first.Stop()
68 tick := time.NewTicker(every)
69 defer tick.Stop()
70 for {
71 select {
72 case <-ctx.Done():
73 return
74 case <-first.C:
75 case <-tick.C:
76 }
77 s.RunGitMaintenance(ctx, "")
78 }
79 }
80
81 // RunGitMaintenance onderhoudt alle bare repositories, of één als
82 // repoPath (eigenaar/naam) gezet is. Eén ronde tegelijk; een tweede
83 // aanroep krijgt ok=false. Fouten op één repo slaan die over.
84 func (s *Server) RunGitMaintenance(ctx context.Context, repoPath string) (GitMaintReport, bool) {
85 s.gitMaint.mu.Lock()
86 if s.gitMaint.running {
87 s.gitMaint.mu.Unlock()
88 return s.gitMaint.last, false
89 }
90 s.gitMaint.running = true
91 s.gitMaint.mu.Unlock()
92 defer func() {
93 s.gitMaint.mu.Lock()
94 s.gitMaint.running = false
95 s.gitMaint.mu.Unlock()
96 }()
97
98 rep := GitMaintReport{Started: time.Now().UTC()}
99 defer func() {
100 rep.Finished = time.Now().UTC()
101 s.gitMaint.mu.Lock()
102 s.gitMaint.last = rep
103 s.gitMaint.mu.Unlock()
104 }()
105
106 storage := s.StoragePath()
107 if storage == "" {
108 if s.Log != nil {
109 s.Log.Info("git maintenance skipped", "reason", "no storage")
110 }
111 return rep, true
112 }
113 repos, err := s.reposForMaintenance(ctx, repoPath)
114 if err != nil {
115 rep.Error = err.Error()
116 if s.Log != nil {
117 s.Log.Error("git maintenance list", "err", err)
118 }
119 return rep, true
120 }
121 gitBin := s.Git
122 if gitBin == "" {
123 gitBin = s.Cfg.Git.Binary
124 }
125 for _, repo := range repos {
126 if ctx.Err() != nil {
127 break
128 }
129 path := gitrepo.Dir(storage, repo.OwnerPath, repo.Name)
130 name := repo.FullPath()
131 repoCtx, cancel := context.WithTimeout(ctx, gitMaintRepoTimeout)
132 res := gitrepo.Maintain(repoCtx, gitBin, path)
133 cancel()
134 item := GitMaintRepoResult{Repo: name, OK: res.OK, Duration: res.Duration.Milliseconds(), Error: res.Err}
135 rep.Repos++
136 if res.OK {
137 rep.OK++
138 if s.Log != nil {
139 s.Log.Info("git maintenance", "repo", name, "duration", res.Duration.Round(time.Millisecond).String())
140 }
141 } else {
142 rep.Skipped++
143 if s.Log != nil {
144 s.Log.Error("git maintenance skip", "repo", name, "err", res.Err)
145 }
146 }
147 rep.Results = append(rep.Results, item)
148 }
149 if s.Log != nil {
150 s.Log.Info("git maintenance done", "repos", rep.Repos, "ok", rep.OK, "skipped", rep.Skipped)
151 }
152 return rep, true
153 }
154
155 func (s *Server) reposForMaintenance(ctx context.Context, repoPath string) ([]store.Repo, error) {
156 if repoPath == "" {
157 return s.Store.AllRepos(ctx)
158 }
159 owner, name, ok := splitRepoPath(repoPath)
160 if !ok {
161 return nil, errBadRepoPath
162 }
163 repo, err := s.Store.RepoByPath(ctx, owner, name)
164 if err != nil {
165 return nil, err
166 }
167 return []store.Repo{repo}, nil
168 }
169
170 func splitRepoPath(p string) (owner, name string, ok bool) {
171 p = strings.Trim(strings.TrimSpace(p), "/")
172 owner, name, ok = strings.Cut(p, "/")
173 if !ok || owner == "" || name == "" || strings.Contains(name, "/") {
174 return "", "", false
175 }
176 return owner, name, true
177 }
178
179 var errBadRepoPath = fail(400, i18n.E("err.notFound"))
180
181 func (s *Server) gitMaintStatus() map[string]any {
182 every, on, err := s.Cfg.Git.MaintenanceEvery()
183 interval := ""
184 if err == nil && on {
185 interval = every.String()
186 }
187 s.gitMaint.mu.Lock()
188 defer s.gitMaint.mu.Unlock()
189 out := map[string]any{
190 "enabled": on && err == nil,
191 "interval": interval,
192 "running": s.gitMaint.running,
193 }
194 last := s.gitMaint.last
195 if !last.Started.IsZero() {
196 out["last_started"] = last.Started.Format(time.RFC3339)
197 out["last_finished"] = last.Finished.Format(time.RFC3339)
198 out["repos"] = last.Repos
199 out["ok"] = last.OK
200 out["skipped"] = last.Skipped
201 out["results"] = last.Results
202 if last.Error != "" {
203 out["error"] = last.Error
204 }
205 }
206 return out
207 }
208
209 func (s *Server) apiAdminGitMaintenance(w http.ResponseWriter, r *http.Request) {
210 if !apiUser(r).InstanceAdmin {
211 s.writeAPIErr(w, r, fail(403, i18n.E("err.forbidden")))
212 return
213 }
214 if r.Method == http.MethodPost {
215 var in struct {
216 Repo string `json:"repo"`
217 }
218 if err := readJSON(r, &in); err != nil {
219 s.writeAPIErr(w, r, fail(400, i18n.E("err.json")))
220 return
221 }
222 rep, started := s.RunGitMaintenance(r.Context(), in.Repo)
223 if !started {
224 http.Error(w, "maintenance already running\n", http.StatusConflict)
225 return
226 }
227 writeJSON(w, http.StatusOK, s.reportJSON(rep))
228 return
229 }
230 writeJSON(w, http.StatusOK, s.gitMaintStatus())
231 }
232
233 func (s *Server) reportJSON(rep GitMaintReport) map[string]any {
234 out := s.gitMaintStatus()
235 out["repos"] = rep.Repos
236 out["ok"] = rep.OK
237 out["skipped"] = rep.Skipped
238 out["results"] = rep.Results
239 if rep.Error != "" {
240 out["error"] = rep.Error
241 }
242 if !rep.Started.IsZero() {
243 out["last_started"] = rep.Started.Format(time.RFC3339)
244 }
245 if !rep.Finished.IsZero() {
246 out["last_finished"] = rep.Finished.Format(time.RFC3339)
247 }
248 return out
249 }
@@ -0,0 +1,249 @@
1package server
2
3import (
4 "context"
5 "net/http"
6 "strings"
7 "sync"
8 "time"
9
10 "gitlab.com/Timfa/bluegit/internal/gitrepo"
11 "gitlab.com/Timfa/bluegit/internal/i18n"
12 "gitlab.com/Timfa/bluegit/internal/store"
13)
14
15// gitMaintFirstDelay is de pauze na het starten, zodat de website
16// eerst opkomt. In tests lager zetten.
17var gitMaintFirstDelay = 2 * time.Minute
18
19// gitMaintRepoTimeout is de maximale duur per repository.
20var gitMaintRepoTimeout = gitrepo.DefaultMaintTimeout
21
22// GitMaintRepoResult is de uitkomst voor één repository.
23type GitMaintRepoResult struct {
24 Repo string `json:"repo"`
25 OK bool `json:"ok"`
26 Duration int64 `json:"duration_ms"`
27 Error string `json:"error,omitempty"`
28}
29
30// GitMaintReport is de laatste onderhoudsronde.
31type GitMaintReport struct {
32 Started time.Time `json:"started,omitempty"`
33 Finished time.Time `json:"finished,omitempty"`
34 Repos int `json:"repos"`
35 OK int `json:"ok"`
36 Skipped int `json:"skipped"`
37 Error string `json:"error,omitempty"`
38 Results []GitMaintRepoResult `json:"results,omitempty"`
39}
40
41type gitMaintState struct {
42 mu sync.Mutex
43 running bool
44 last GitMaintReport
45}
46
47// GitMaintenanceSweeper draait periodiek onderhoud op alle bare
48// repositories. Uit als maintenance_interval "off" is.
49func (s *Server) GitMaintenanceSweeper(ctx context.Context) {
50 every, on, err := s.Cfg.Git.MaintenanceEvery()
51 if err != nil {
52 if s.Log != nil {
53 s.Log.Error("git maintenance", "err", err)
54 }
55 return
56 }
57 if !on {
58 if s.Log != nil {
59 s.Log.Info("git maintenance disabled")
60 }
61 return
62 }
63 if s.Log != nil {
64 s.Log.Info("git maintenance scheduled", "interval", every.String())
65 }
66 first := time.NewTimer(gitMaintFirstDelay)
67 defer first.Stop()
68 tick := time.NewTicker(every)
69 defer tick.Stop()
70 for {
71 select {
72 case <-ctx.Done():
73 return
74 case <-first.C:
75 case <-tick.C:
76 }
77 s.RunGitMaintenance(ctx, "")
78 }
79}
80
81// RunGitMaintenance onderhoudt alle bare repositories, of één als
82// repoPath (eigenaar/naam) gezet is. Eén ronde tegelijk; een tweede
83// aanroep krijgt ok=false. Fouten op één repo slaan die over.
84func (s *Server) RunGitMaintenance(ctx context.Context, repoPath string) (GitMaintReport, bool) {
85 s.gitMaint.mu.Lock()
86 if s.gitMaint.running {
87 s.gitMaint.mu.Unlock()
88 return s.gitMaint.last, false
89 }
90 s.gitMaint.running = true
91 s.gitMaint.mu.Unlock()
92 defer func() {
93 s.gitMaint.mu.Lock()
94 s.gitMaint.running = false
95 s.gitMaint.mu.Unlock()
96 }()
97
98 rep := GitMaintReport{Started: time.Now().UTC()}
99 defer func() {
100 rep.Finished = time.Now().UTC()
101 s.gitMaint.mu.Lock()
102 s.gitMaint.last = rep
103 s.gitMaint.mu.Unlock()
104 }()
105
106 storage := s.StoragePath()
107 if storage == "" {
108 if s.Log != nil {
109 s.Log.Info("git maintenance skipped", "reason", "no storage")
110 }
111 return rep, true
112 }
113 repos, err := s.reposForMaintenance(ctx, repoPath)
114 if err != nil {
115 rep.Error = err.Error()
116 if s.Log != nil {
117 s.Log.Error("git maintenance list", "err", err)
118 }
119 return rep, true
120 }
121 gitBin := s.Git
122 if gitBin == "" {
123 gitBin = s.Cfg.Git.Binary
124 }
125 for _, repo := range repos {
126 if ctx.Err() != nil {
127 break
128 }
129 path := gitrepo.Dir(storage, repo.OwnerPath, repo.Name)
130 name := repo.FullPath()
131 repoCtx, cancel := context.WithTimeout(ctx, gitMaintRepoTimeout)
132 res := gitrepo.Maintain(repoCtx, gitBin, path)
133 cancel()
134 item := GitMaintRepoResult{Repo: name, OK: res.OK, Duration: res.Duration.Milliseconds(), Error: res.Err}
135 rep.Repos++
136 if res.OK {
137 rep.OK++
138 if s.Log != nil {
139 s.Log.Info("git maintenance", "repo", name, "duration", res.Duration.Round(time.Millisecond).String())
140 }
141 } else {
142 rep.Skipped++
143 if s.Log != nil {
144 s.Log.Error("git maintenance skip", "repo", name, "err", res.Err)
145 }
146 }
147 rep.Results = append(rep.Results, item)
148 }
149 if s.Log != nil {
150 s.Log.Info("git maintenance done", "repos", rep.Repos, "ok", rep.OK, "skipped", rep.Skipped)
151 }
152 return rep, true
153}
154
155func (s *Server) reposForMaintenance(ctx context.Context, repoPath string) ([]store.Repo, error) {
156 if repoPath == "" {
157 return s.Store.AllRepos(ctx)
158 }
159 owner, name, ok := splitRepoPath(repoPath)
160 if !ok {
161 return nil, errBadRepoPath
162 }
163 repo, err := s.Store.RepoByPath(ctx, owner, name)
164 if err != nil {
165 return nil, err
166 }
167 return []store.Repo{repo}, nil
168}
169
170func splitRepoPath(p string) (owner, name string, ok bool) {
171 p = strings.Trim(strings.TrimSpace(p), "/")
172 owner, name, ok = strings.Cut(p, "/")
173 if !ok || owner == "" || name == "" || strings.Contains(name, "/") {
174 return "", "", false
175 }
176 return owner, name, true
177}
178
179var errBadRepoPath = fail(400, i18n.E("err.notFound"))
180
181func (s *Server) gitMaintStatus() map[string]any {
182 every, on, err := s.Cfg.Git.MaintenanceEvery()
183 interval := ""
184 if err == nil && on {
185 interval = every.String()
186 }
187 s.gitMaint.mu.Lock()
188 defer s.gitMaint.mu.Unlock()
189 out := map[string]any{
190 "enabled": on && err == nil,
191 "interval": interval,
192 "running": s.gitMaint.running,
193 }
194 last := s.gitMaint.last
195 if !last.Started.IsZero() {
196 out["last_started"] = last.Started.Format(time.RFC3339)
197 out["last_finished"] = last.Finished.Format(time.RFC3339)
198 out["repos"] = last.Repos
199 out["ok"] = last.OK
200 out["skipped"] = last.Skipped
201 out["results"] = last.Results
202 if last.Error != "" {
203 out["error"] = last.Error
204 }
205 }
206 return out
207}
208
209func (s *Server) apiAdminGitMaintenance(w http.ResponseWriter, r *http.Request) {
210 if !apiUser(r).InstanceAdmin {
211 s.writeAPIErr(w, r, fail(403, i18n.E("err.forbidden")))
212 return
213 }
214 if r.Method == http.MethodPost {
215 var in struct {
216 Repo string `json:"repo"`
217 }
218 if err := readJSON(r, &in); err != nil {
219 s.writeAPIErr(w, r, fail(400, i18n.E("err.json")))
220 return
221 }
222 rep, started := s.RunGitMaintenance(r.Context(), in.Repo)
223 if !started {
224 http.Error(w, "maintenance already running\n", http.StatusConflict)
225 return
226 }
227 writeJSON(w, http.StatusOK, s.reportJSON(rep))
228 return
229 }
230 writeJSON(w, http.StatusOK, s.gitMaintStatus())
231}
232
233func (s *Server) reportJSON(rep GitMaintReport) map[string]any {
234 out := s.gitMaintStatus()
235 out["repos"] = rep.Repos
236 out["ok"] = rep.OK
237 out["skipped"] = rep.Skipped
238 out["results"] = rep.Results
239 if rep.Error != "" {
240 out["error"] = rep.Error
241 }
242 if !rep.Started.IsZero() {
243 out["last_started"] = rep.Started.Format(time.RFC3339)
244 }
245 if !rep.Finished.IsZero() {
246 out["last_finished"] = rep.Finished.Format(time.RFC3339)
247 }
248 return out
249}
internal/server/maintain_test.go added +121 −0
@@ -0,0 +1,121 @@
1 package server
2
3 import (
4 "context"
5 "encoding/json"
6 "io"
7 "net/http"
8 "net/url"
9 "os/exec"
10 "strings"
11 "testing"
12 "time"
13
14 "gitlab.com/Timfa/bluegit/internal/gitrepo"
15 )
16
17 func TestGitMaintenanceAPI(t *testing.T) {
18 ts, client, srv := graphTestRepo(t)
19 page := read(t, mustGet(t, client, ts.URL+"/settings"))
20 page = read(t, mustPost(t, client, ts.URL+"/settings/tokens", url.Values{"csrf": {csrfOf(t, page)}, "name": {"maint"}}))
21 token := between(page, `<p class="code">`, "</p>")
22 if token == "" {
23 t.Fatal("geen API-token")
24 }
25
26 res := getBearer(t, ts.URL+"/api/v1/admin/git-maintenance", token)
27 defer res.Body.Close()
28 if res.StatusCode != 200 {
29 b, _ := io.ReadAll(res.Body)
30 t.Fatalf("GET status %d %s", res.StatusCode, b)
31 }
32 var st map[string]any
33 if err := json.NewDecoder(res.Body).Decode(&st); err != nil {
34 t.Fatal(err)
35 }
36 if st["enabled"] != true {
37 t.Fatalf("onderhoud zou standaard aan moeten staan: %v", st)
38 }
39 if iv, _ := st["interval"].(string); !strings.Contains(iv, "h") {
40 t.Fatalf("interval ontbreekt: %v", st)
41 }
42
43 req, err := http.NewRequest(http.MethodPost, ts.URL+"/api/v1/admin/git-maintenance", strings.NewReader(`{"repo":"tim/grafiek"}`))
44 if err != nil {
45 t.Fatal(err)
46 }
47 req.Header.Set("Authorization", "Bearer "+token)
48 req.Header.Set("Content-Type", "application/json")
49 post, err := http.DefaultClient.Do(req)
50 if err != nil {
51 t.Fatal(err)
52 }
53 defer post.Body.Close()
54 body, _ := io.ReadAll(post.Body)
55 if post.StatusCode != 200 {
56 t.Fatalf("POST %d %s", post.StatusCode, body)
57 }
58 var out map[string]any
59 if err := json.Unmarshal(body, &out); err != nil {
60 t.Fatal(err)
61 }
62 if out["ok"] != float64(1) || out["skipped"] != float64(0) {
63 t.Fatalf("handmatige run op tim/grafiek mislukte: %s", body)
64 }
65 dir := gitrepo.Dir(srv.StoragePath(), "tim", "grafiek")
66 cmd := exec.Command("git", "-C", dir, "rev-parse", "refs/heads/master")
67 if b, err := cmd.CombinedOutput(); err != nil {
68 t.Fatalf("master-ref verdween na onderhoud: %s %v", b, err)
69 }
70 cmd = exec.Command("git", "-C", dir, "cat-file", "-t", "v1")
71 if b, err := cmd.CombinedOutput(); err != nil {
72 t.Fatalf("tag v1 verdween na onderhoud: %s %v", b, err)
73 }
74
75 bad, err := http.Get(ts.URL + "/api/v1/admin/git-maintenance")
76 if err != nil {
77 t.Fatal(err)
78 }
79 bad.Body.Close()
80 if bad.StatusCode != http.StatusUnauthorized {
81 t.Fatalf("zonder token: %d, wil 401", bad.StatusCode)
82 }
83 }
84
85 func TestGitMaintenanceSweeperRunsOnce(t *testing.T) {
86 ts, _, srv := graphTestRepo(t)
87 _ = ts
88 oldDelay := gitMaintFirstDelay
89 gitMaintFirstDelay = 20 * time.Millisecond
90 t.Cleanup(func() { gitMaintFirstDelay = oldDelay })
91 srv.Cfg.Git.MaintenanceInterval = "30ms"
92
93 ctx, cancel := context.WithCancel(context.Background())
94 t.Cleanup(cancel)
95 go srv.GitMaintenanceSweeper(ctx)
96
97 deadline := time.Now().Add(3 * time.Second)
98 for time.Now().Before(deadline) {
99 st := srv.gitMaintStatus()
100 ok, _ := st["ok"].(int)
101 if ok >= 1 {
102 return
103 }
104 time.Sleep(20 * time.Millisecond)
105 }
106 t.Fatalf("sweeper draaide niet: %+v", srv.gitMaintStatus())
107 }
108
109 func TestGitMaintenanceSkipsMissingRepo(t *testing.T) {
110 _, _, srv := graphTestRepo(t)
111 rep, started := srv.RunGitMaintenance(context.Background(), "tim/bestaat-niet")
112 if !started {
113 t.Fatal("ronde startte niet")
114 }
115 if rep.Error == "" && rep.Skipped == 0 && rep.Repos == 0 {
116 t.Fatalf("ontbrekende repo zou als fout gelogd moeten worden: %+v", rep)
117 }
118 if rep.Error == "" {
119 t.Fatalf("verwacht een foutmelding: %+v", rep)
120 }
121 }
@@ -0,0 +1,121 @@
1package server
2
3import (
4 "context"
5 "encoding/json"
6 "io"
7 "net/http"
8 "net/url"
9 "os/exec"
10 "strings"
11 "testing"
12 "time"
13
14 "gitlab.com/Timfa/bluegit/internal/gitrepo"
15)
16
17func TestGitMaintenanceAPI(t *testing.T) {
18 ts, client, srv := graphTestRepo(t)
19 page := read(t, mustGet(t, client, ts.URL+"/settings"))
20 page = read(t, mustPost(t, client, ts.URL+"/settings/tokens", url.Values{"csrf": {csrfOf(t, page)}, "name": {"maint"}}))
21 token := between(page, `<p class="code">`, "</p>")
22 if token == "" {
23 t.Fatal("geen API-token")
24 }
25
26 res := getBearer(t, ts.URL+"/api/v1/admin/git-maintenance", token)
27 defer res.Body.Close()
28 if res.StatusCode != 200 {
29 b, _ := io.ReadAll(res.Body)
30 t.Fatalf("GET status %d %s", res.StatusCode, b)
31 }
32 var st map[string]any
33 if err := json.NewDecoder(res.Body).Decode(&st); err != nil {
34 t.Fatal(err)
35 }
36 if st["enabled"] != true {
37 t.Fatalf("onderhoud zou standaard aan moeten staan: %v", st)
38 }
39 if iv, _ := st["interval"].(string); !strings.Contains(iv, "h") {
40 t.Fatalf("interval ontbreekt: %v", st)
41 }
42
43 req, err := http.NewRequest(http.MethodPost, ts.URL+"/api/v1/admin/git-maintenance", strings.NewReader(`{"repo":"tim/grafiek"}`))
44 if err != nil {
45 t.Fatal(err)
46 }
47 req.Header.Set("Authorization", "Bearer "+token)
48 req.Header.Set("Content-Type", "application/json")
49 post, err := http.DefaultClient.Do(req)
50 if err != nil {
51 t.Fatal(err)
52 }
53 defer post.Body.Close()
54 body, _ := io.ReadAll(post.Body)
55 if post.StatusCode != 200 {
56 t.Fatalf("POST %d %s", post.StatusCode, body)
57 }
58 var out map[string]any
59 if err := json.Unmarshal(body, &out); err != nil {
60 t.Fatal(err)
61 }
62 if out["ok"] != float64(1) || out["skipped"] != float64(0) {
63 t.Fatalf("handmatige run op tim/grafiek mislukte: %s", body)
64 }
65 dir := gitrepo.Dir(srv.StoragePath(), "tim", "grafiek")
66 cmd := exec.Command("git", "-C", dir, "rev-parse", "refs/heads/master")
67 if b, err := cmd.CombinedOutput(); err != nil {
68 t.Fatalf("master-ref verdween na onderhoud: %s %v", b, err)
69 }
70 cmd = exec.Command("git", "-C", dir, "cat-file", "-t", "v1")
71 if b, err := cmd.CombinedOutput(); err != nil {
72 t.Fatalf("tag v1 verdween na onderhoud: %s %v", b, err)
73 }
74
75 bad, err := http.Get(ts.URL + "/api/v1/admin/git-maintenance")
76 if err != nil {
77 t.Fatal(err)
78 }
79 bad.Body.Close()
80 if bad.StatusCode != http.StatusUnauthorized {
81 t.Fatalf("zonder token: %d, wil 401", bad.StatusCode)
82 }
83}
84
85func TestGitMaintenanceSweeperRunsOnce(t *testing.T) {
86 ts, _, srv := graphTestRepo(t)
87 _ = ts
88 oldDelay := gitMaintFirstDelay
89 gitMaintFirstDelay = 20 * time.Millisecond
90 t.Cleanup(func() { gitMaintFirstDelay = oldDelay })
91 srv.Cfg.Git.MaintenanceInterval = "30ms"
92
93 ctx, cancel := context.WithCancel(context.Background())
94 t.Cleanup(cancel)
95 go srv.GitMaintenanceSweeper(ctx)
96
97 deadline := time.Now().Add(3 * time.Second)
98 for time.Now().Before(deadline) {
99 st := srv.gitMaintStatus()
100 ok, _ := st["ok"].(int)
101 if ok >= 1 {
102 return
103 }
104 time.Sleep(20 * time.Millisecond)
105 }
106 t.Fatalf("sweeper draaide niet: %+v", srv.gitMaintStatus())
107}
108
109func TestGitMaintenanceSkipsMissingRepo(t *testing.T) {
110 _, _, srv := graphTestRepo(t)
111 rep, started := srv.RunGitMaintenance(context.Background(), "tim/bestaat-niet")
112 if !started {
113 t.Fatal("ronde startte niet")
114 }
115 if rep.Error == "" && rep.Skipped == 0 && rep.Repos == 0 {
116 t.Fatalf("ontbrekende repo zou als fout gelogd moeten worden: %+v", rep)
117 }
118 if rep.Error == "" {
119 t.Fatalf("verwacht een foutmelding: %+v", rep)
120 }
121}
internal/server/server.go +2 −0
@@ -75,6 +75,8 @@ type Server struct {
75 75
76 76 graphOnce sync.Once
77 77 graphCache *gitgraph.Cache
78
79 gitMaint gitMaintState
78 80 }
79 81
80 82 type principal struct {
@@ -75,6 +75,8 @@ type Server struct {
75
75
76 graphOnce sync.Once
76 graphOnce sync.Once
77 graphCache *gitgraph.Cache
77 graphCache *gitgraph.Cache
78
79 gitMaint gitMaintState
78}
80}
79
81
80type principal struct {
82type principal struct {