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.
@@ -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`.@@ -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.Server139
var sh *sshd.Server139
if cfg.SSH.Enabled {140
if cfg.SSH.Enabled {140
sh = &sshd.Server{141
sh = &sshd.Server{@@ -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
# Architectuur1
# Architectuur2
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
```text5
```text6
browser ──HTTPS──▶ ingress ──HTTP──▶ bluegit (web + smart HTTP + API)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, to40
<datadisk>/work/pipeline/job/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
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.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
## Auth47
## Auth@@ -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 worden70
// (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.Hour77
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, nil88
}89
if s == "off" || s == "false" || s == "no" {90
return 0, false, nil91
}92
if s == "0" || s == "0s" || s == "0h" || s == "0d" {93
return 0, false, nil94
}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, nil101
}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, nil108
}109
return d, true, nil68
}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 err333
return err292
}334
}335
if _, _, err := c.Git.MaintenanceEvery(); err != nil {336
return err337
}293
return nil338
return nil294
}339
}295
340
@@ -412,6 +457,10 @@ auth:412
git:457
git:413
binary: git458
binary: git414
default_branch: master459
default_branch: master460
# Periodiek onderhoud van bare repositories (git maintenance of461
# 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: 24h415
464
416
ssh:465
ssh:417
enabled: true466
enabled: true@@ -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
10
func TestPresetConfig(t *testing.T) {11
func 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
354
func TestParseMaintenanceInterval(t *testing.T) {355
cases := []struct {356
in string357
want time.Duration358
enabled bool359
fail bool360
}{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
continue376
}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
}@@ -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 @@1
package gitrepo2
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.Minute13
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 niets25
// 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 string36
OK bool37
Output string38
Err string39
Duration time.Duration40
}41
42
// Maintain voert veilig git-onderhoud uit op één bare repository.43
// Eerst `git gc --auto` (locking, geen --prune=now). Daarna optioneel44
// loose-objects en incremental-repack; die mogen stil falen als er niets45
// te doen is of als de git-binary maintenance niet kent. Een lock van46
// 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 res57
}58
59
var logs []string60
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 res69
}70
for _, args := range extraMaintTasks() {71
if ctx.Err() != nil {72
break73
}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
continue80
}81
// Een echte fout op een extra taak is geen reden de ronde te82
// 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 = true88
return res89
}90
91
func isSkippableMaint(err error) bool {92
if err == nil {93
return true94
}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.Cmd106
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.Builder112
cmd.Stdout = &stdout113
cmd.Stderr = &stderr114
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(), nil122
}@@ -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 @@1
package gitrepo2
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, zonder26
// 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
}@@ -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},@@ -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 @@1
package server2
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 website16
// eerst opkomt. In tests lager zetten.17
var gitMaintFirstDelay = 2 * time.Minute18
19
// gitMaintRepoTimeout is de maximale duur per repository.20
var gitMaintRepoTimeout = gitrepo.DefaultMaintTimeout21
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.Mutex43
running bool44
last GitMaintReport45
}46
47
// GitMaintenanceSweeper draait periodiek onderhoud op alle bare48
// 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
return56
}57
if !on {58
if s.Log != nil {59
s.Log.Info("git maintenance disabled")60
}61
return62
}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
return74
case <-first.C:75
case <-tick.C:76
}77
s.RunGitMaintenance(ctx, "")78
}79
}80
81
// RunGitMaintenance onderhoudt alle bare repositories, of één als82
// repoPath (eigenaar/naam) gezet is. Eén ronde tegelijk; een tweede83
// 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, false89
}90
s.gitMaint.running = true91
s.gitMaint.mu.Unlock()92
defer func() {93
s.gitMaint.mu.Lock()94
s.gitMaint.running = false95
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 = rep103
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, true112
}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, true120
}121
gitBin := s.Git122
if gitBin == "" {123
gitBin = s.Cfg.Git.Binary124
}125
for _, repo := range repos {126
if ctx.Err() != nil {127
break128
}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, true153
}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, errBadRepoPath162
}163
repo, err := s.Store.RepoByPath(ctx, owner, name)164
if err != nil {165
return nil, err166
}167
return []store.Repo{repo}, nil168
}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 "", "", false175
}176
return owner, name, true177
}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.last195
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.Repos199
out["ok"] = last.OK200
out["skipped"] = last.Skipped201
out["results"] = last.Results202
if last.Error != "" {203
out["error"] = last.Error204
}205
}206
return out207
}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
return213
}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
return221
}222
rep, started := s.RunGitMaintenance(r.Context(), in.Repo)223
if !started {224
http.Error(w, "maintenance already running\n", http.StatusConflict)225
return226
}227
writeJSON(w, http.StatusOK, s.reportJSON(rep))228
return229
}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.Repos236
out["ok"] = rep.OK237
out["skipped"] = rep.Skipped238
out["results"] = rep.Results239
if rep.Error != "" {240
out["error"] = rep.Error241
}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 out249
}@@ -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 @@1
package server2
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]any33
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]any59
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
_ = ts88
oldDelay := gitMaintFirstDelay89
gitMaintFirstDelay = 20 * time.Millisecond90
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
return103
}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
}@@ -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.Once76
graphOnce sync.Once77
graphCache *gitgraph.Cache77
graphCache *gitgraph.Cache78
79
gitMaint gitMaintState78
}80
}79
81
80
type principal struct {82
type principal struct {