package gitrepo import ( "context" "fmt" "os/exec" "strings" "time" ) // DefaultMaintTimeout is de maximale duur van onderhoud op één repository. const DefaultMaintTimeout = 30 * time.Minute // MaintenanceArgs is het voorkeurscommando (modern git). Geen --prune=now. func MaintenanceArgs() []string { return []string{"maintenance", "run", "--task=gc", "--task=loose-objects", "--task=incremental-repack"} } // GCAutoArgs is de veilige kern: git's eigen auto-drempels, standaard prune-termijn, locking. func GCAutoArgs() []string { return []string{"gc", "--auto"} } // extraMaintTasks zijn optionele stappen na gc --auto. Een taak die niets // te doen heeft (geen packfiles) is geen fout. func extraMaintTasks() [][]string { return [][]string{ {"maintenance", "run", "--task=loose-objects"}, {"maintenance", "run", "--task=incremental-repack"}, } } // MaintResult is de uitkomst van onderhoud op één bare repository. type MaintResult struct { Dir string OK bool Output string Err string Duration time.Duration } // Maintain voert veilig git-onderhoud uit op één bare repository. // Eerst `git gc --auto` (locking, geen --prune=now). Daarna optioneel // loose-objects en incremental-repack; die mogen stil falen als er niets // te doen is of als de git-binary maintenance niet kent. Een lock van // een push of clone laat git falen; de aanroeper slaat de repo over. func Maintain(ctx context.Context, gitBin, dir string) MaintResult { start := time.Now() res := MaintResult{Dir: dir} if gitBin == "" { gitBin = "git" } if dir == "" { res.Err = "leeg pad" res.Duration = time.Since(start) return res } var logs []string out, err := runNice(ctx, gitBin, append([]string{"-C", dir}, GCAutoArgs()...)...) if strings.TrimSpace(out) != "" { logs = append(logs, strings.TrimSpace(out)) } if err != nil { res.Err = err.Error() res.Output = strings.Join(logs, "\n") res.Duration = time.Since(start) return res } for _, args := range extraMaintTasks() { if ctx.Err() != nil { break } out, err = runNice(ctx, gitBin, append([]string{"-C", dir}, args...)...) if strings.TrimSpace(out) != "" { logs = append(logs, strings.TrimSpace(out)) } if err == nil || isSkippableMaint(err) { continue } // Een echte fout op een extra taak is geen reden de ronde te // laten mislukken: gc --auto is al gelukt. We loggen het wel. logs = append(logs, err.Error()) } res.Output = strings.Join(logs, "\n") res.Duration = time.Since(start) res.OK = true return res } func isSkippableMaint(err error) bool { if err == nil { return true } msg := strings.ToLower(err.Error()) return strings.Contains(msg, "is not a git command") || strings.Contains(msg, "unknown subcommand") || strings.Contains(msg, "unknown command") || strings.Contains(msg, "no pack files") || strings.Contains(msg, "nothing to repack") || strings.Contains(msg, "nothing to do") } func runNice(ctx context.Context, bin string, args ...string) (string, error) { var cmd *exec.Cmd if nice, err := exec.LookPath("nice"); err == nil { cmd = exec.CommandContext(ctx, nice, append([]string{"-n", "19", bin}, args...)...) } else { cmd = exec.CommandContext(ctx, bin, args...) } var stdout, stderr strings.Builder cmd.Stdout = &stdout cmd.Stderr = &stderr if err := cmd.Run(); err != nil { msg := strings.TrimSpace(stderr.String()) if msg == "" { msg = err.Error() } return stdout.String(), fmt.Errorf("%s", msg) } return stdout.String(), nil }