BlueGit

timfa bluegit

Files

bluegit / internal / gitrepo / repo.go

repo.go

repo.go 25.2 KiB Download Raw
1// Package gitrepo legt bare repositories op schijf en praat met de git-binary.
2package gitrepo
3
4import (
5 "bufio"
6 "bytes"
7 "context"
8 "errors"
9 "fmt"
10 "io"
11 "os"
12 "os/exec"
13 "path/filepath"
14 "sort"
15 "strconv"
16 "strings"
17
18 "gitlab.com/Timfa/bluegit/internal/access"
19 "gitlab.com/Timfa/bluegit/internal/i18n"
20 "gitlab.com/Timfa/bluegit/internal/names"
21)
22
23// Dir is de bare repository op de datadisk.
24func Dir(storage, owner, name string) string {
25 return filepath.Join(storage, "repos", owner, name+".git")
26}
27
28// Init maakt een lege bare repository en zet de pre-receive-hook.
29func Init(gitBin, dir, defaultBranch, hookBinary string) error {
30 if err := os.MkdirAll(filepath.Dir(dir), 0o755); err != nil {
31 return err
32 }
33 if _, err := run(context.Background(), gitBin, nil, "init", "--bare", "--initial-branch", defaultBranch, dir); err != nil {
34 return err
35 }
36 for _, kv := range [][2]string{
37 {"http.receivepack", "true"},
38 {"http.uploadpack", "true"},
39 {"receive.denyCurrentBranch", "ignore"},
40 } {
41 if _, err := run(context.Background(), gitBin, nil, "-C", dir, "config", kv[0], kv[1]); err != nil {
42 return err
43 }
44 }
45 return InstallHook(dir, hookBinary)
46}
47
48// InstallHook schrijft hooks/pre-receive. Die roept deze binary aan.
49func InstallHook(dir, hookBinary string) error {
50 if hookBinary == "" {
51 return fmt.Errorf("hook-binary ontbreekt")
52 }
53 path := filepath.Join(dir, "hooks", "pre-receive")
54 body := "#!/bin/sh\nset -eu\nexec " + shellQuote(hookBinary) + " hook pre-receive\n"
55 if err := os.WriteFile(path, []byte(body), 0o755); err != nil {
56 return err
57 }
58 return nil
59}
60
61func shellQuote(s string) string {
62 return "'" + strings.ReplaceAll(s, "'", `'\''`) + "'"
63}
64
65// PushEnv zijn de variabelen die de hook leest. Zonder deze variabelen
66// weigert de hook, zodat een push buiten BlueGit om niet slaagt.
67func PushEnv(role access.Role, patterns, tagPatterns []string) []string {
68 return []string{
69 "BLUEGIT_ROLE=" + string(role),
70 "BLUEGIT_PROTECTED=" + strings.Join(patterns, "\n"),
71 "BLUEGIT_PROTECTED_TAGS=" + strings.Join(tagPatterns, "\n"),
72 }
73}
74
75// ReadUpdates leest de regels van een pre-receive-hook.
76func ReadUpdates(r io.Reader) ([]access.RefUpdate, error) {
77 sc := bufio.NewScanner(r)
78 var out []access.RefUpdate
79 for sc.Scan() {
80 line := strings.TrimSpace(sc.Text())
81 if line == "" {
82 continue
83 }
84 parts := strings.Fields(line)
85 if len(parts) != 3 {
86 return nil, fmt.Errorf("onverwachte hookregel %q", line)
87 }
88 out = append(out, access.RefUpdate{Old: parts[0], New: parts[1], Ref: parts[2]})
89 }
90 return out, sc.Err()
91}
92
93// EvaluatePush is wat `bluegit hook pre-receive` doet.
94func EvaluatePush(role access.Role, patterns, tagPatterns []string, r io.Reader) error {
95 if role == "" {
96 return fmt.Errorf("push geweigerd: geen BlueGit-rol")
97 }
98 ups, err := ReadUpdates(r)
99 if err != nil {
100 return err
101 }
102 return access.AuthorizeUpdates(role, patterns, tagPatterns, ups)
103}
104
105// Commit is één commit voor de webinterface.
106type Commit struct {
107 SHA string
108 Short string
109 Author string
110 Email string
111 Date string
112 Unix int64
113 Subject string
114 Body string
115}
116
117// Entry is een bestand of map in een tree.
118type Entry struct {
119 Mode string
120 Type string
121 SHA string
122 Name string
123}
124
125// Log geeft de nieuwste commits.
126func Log(ctx context.Context, gitBin, dir, rev string, limit int) ([]Commit, error) {
127 return LogPage(ctx, gitBin, dir, rev, 0, limit)
128}
129
130// LogPage slaat de nieuwste skip commits over en leest daarna hooguit limit commits.
131func LogPage(ctx context.Context, gitBin, dir, rev string, skip, limit int) ([]Commit, error) {
132 if rev == "" {
133 rev = "HEAD"
134 }
135 if limit < 1 {
136 limit = 1
137 }
138 if skip < 0 {
139 skip = 0
140 }
141 args := []string{"-C", dir, "log", "--format=%H%x1f%an%x1f%ae%x1f%ad%x1f%at%x1f%s%x1f%b%x1e", "--date=short", fmt.Sprintf("-n%d", limit)}
142 if skip > 0 {
143 args = append(args, fmt.Sprintf("--skip=%d", skip))
144 }
145 args = append(args, rev)
146 out, err := run(ctx, gitBin, nil, args...)
147 if err != nil {
148 if strings.Contains(err.Error(), "does not have any commits") || strings.Contains(err.Error(), "bad default revision") || strings.Contains(err.Error(), "ambiguous argument") {
149 return nil, nil
150 }
151 return nil, err
152 }
153 return parseLog(out), nil
154}
155
156func parseLog(out string) []Commit {
157 var commits []Commit
158 for _, rec := range strings.Split(out, "\x1e") {
159 rec = strings.TrimSpace(rec)
160 if rec == "" {
161 continue
162 }
163 parts := strings.Split(rec, "\x1f")
164 if len(parts) < 6 {
165 continue
166 }
167 c := Commit{SHA: parts[0], Author: parts[1], Email: parts[2], Date: parts[3], Subject: parts[5]}
168 c.Unix, _ = strconv.ParseInt(parts[4], 10, 64)
169 if len(c.SHA) >= 10 {
170 c.Short = c.SHA[:10]
171 }
172 if len(parts) > 6 {
173 c.Body = strings.TrimSpace(parts[6])
174 }
175 commits = append(commits, c)
176 }
177 return commits
178}
179
180// Message is een commitbericht. Merge is waar bij twee of meer ouders.
181type Message struct {
182 Subject string
183 Body string
184 Author string
185 Email string
186 Merge bool
187}
188
189// Messages leest hooguit limit berichten, oudste eerst.
190func Messages(ctx context.Context, gitBin, dir, rev string, limit int) ([]Message, error) {
191 if rev == "" {
192 rev = "HEAD"
193 }
194 if limit < 1 {
195 limit = 1
196 }
197 if limit > 100 {
198 limit = 100
199 }
200 out, err := run(ctx, gitBin, nil, "-C", dir, "log", "--reverse", "--format=%an%x1f%ae%x1f%P%x1f%s%x1f%b%x1e", "--date=short", fmt.Sprintf("-n%d", limit), rev)
201 if err != nil {
202 if strings.Contains(err.Error(), "does not have any commits") || strings.Contains(err.Error(), "bad default revision") || strings.Contains(err.Error(), "ambiguous argument") {
203 return nil, nil
204 }
205 return nil, err
206 }
207 return parseMessages(out), nil
208}
209
210func parseMessages(out string) []Message {
211 var msgs []Message
212 for _, rec := range strings.Split(out, "\x1e") {
213 rec = strings.TrimSpace(rec)
214 if rec == "" {
215 continue
216 }
217 parts := strings.Split(rec, "\x1f")
218 if len(parts) < 4 {
219 continue
220 }
221 m := Message{Author: parts[0], Email: parts[1], Subject: parts[3]}
222 m.Merge = len(strings.Fields(parts[2])) > 1
223 if len(parts) > 4 {
224 m.Body = strings.TrimSpace(parts[4])
225 }
226 msgs = append(msgs, m)
227 }
228 return msgs
229}
230
231// Show leest één commit.
232func Show(ctx context.Context, gitBin, dir, sha string) (Commit, error) {
233 list, err := Log(ctx, gitBin, dir, sha, 1)
234 if err != nil {
235 return Commit{}, err
236 }
237 if len(list) == 0 {
238 return Commit{}, fmt.Errorf("commit niet gevonden")
239 }
240 return list[0], nil
241}
242
243// Tree leest een map. path is relatief en mag leeg zijn.
244func Tree(ctx context.Context, gitBin, dir, rev, rel string) ([]Entry, error) {
245 spec := rev
246 if rel != "" {
247 spec = rev + ":" + rel
248 }
249 out, err := run(ctx, gitBin, nil, "-C", dir, "ls-tree", spec)
250 if err != nil {
251 return nil, err
252 }
253 var entries []Entry
254 for _, line := range strings.Split(strings.TrimSpace(out), "\n") {
255 if line == "" {
256 continue
257 }
258 // mode type sha\tname
259 tab := strings.SplitN(line, "\t", 2)
260 if len(tab) != 2 {
261 continue
262 }
263 head := strings.Fields(tab[0])
264 if len(head) != 3 {
265 continue
266 }
267 entries = append(entries, Entry{Mode: head[0], Type: head[1], SHA: head[2], Name: tab[1]})
268 }
269 return entries, nil
270}
271
272// Blob leest een tekstbestand, afgekapt op max bytes. binary is waar als
273// het bestand een NUL bevat.
274func Blob(ctx context.Context, gitBin, dir, rev, rel string, max int) (text string, binary bool, err error) {
275 out, err := run(ctx, gitBin, nil, "-C", dir, "show", rev+":"+rel)
276 if err != nil {
277 return "", false, err
278 }
279 if strings.Contains(out, "\x00") {
280 return "", true, nil
281 }
282 if len(out) > max {
283 out = out[:max] + "\n… afgekapt"
284 }
285 return out, false, nil
286}
287
288// Branches geeft lokale branchnamen.
289func Branches(ctx context.Context, gitBin, dir string) ([]string, error) {
290 out, err := run(ctx, gitBin, nil, "-C", dir, "for-each-ref", "--format=%(refname:short)", "refs/heads")
291 if err != nil {
292 return nil, err
293 }
294 var names []string
295 for _, line := range strings.Split(strings.TrimSpace(out), "\n") {
296 if line != "" {
297 names = append(names, line)
298 }
299 }
300 return names, nil
301}
302
303// HasCommit meldt of sha een commit in deze repository is.
304func HasCommit(ctx context.Context, gitBin, dir, sha string) bool {
305 out, err := run(ctx, gitBin, nil, "-C", dir, "cat-file", "-t", sha)
306 return err == nil && strings.TrimSpace(out) == "commit"
307}
308
309// Refs geeft refnaam → sha.
310func Refs(ctx context.Context, gitBin, dir string) (map[string]string, error) {
311 out, err := run(ctx, gitBin, nil, "-C", dir, "for-each-ref", "--format=%(objectname) %(refname)")
312 if err != nil {
313 return nil, err
314 }
315 m := map[string]string{}
316 for _, line := range strings.Split(strings.TrimSpace(out), "\n") {
317 if line == "" {
318 continue
319 }
320 parts := strings.SplitN(line, " ", 2)
321 if len(parts) == 2 {
322 m[parts[1]] = parts[0]
323 }
324 }
325 return m, nil
326}
327
328// Touch geeft per pad de nieuwste commit uit de recente geschiedenis.
329// Mappen erven de nieuwste commit van een bestand erin.
330func Touch(ctx context.Context, gitBin, dir, rev string) (map[string]Commit, error) {
331 if rev == "" {
332 rev = "HEAD"
333 }
334 out, err := run(ctx, gitBin, nil, "-C", dir, "log", "--format=%H%x1f%an%x1f%at%x1f%s", "--name-only", "-n", "400", rev)
335 if err != nil {
336 if emptyHistory(err) {
337 return map[string]Commit{}, nil
338 }
339 return nil, err
340 }
341 m := map[string]Commit{}
342 var cur Commit
343 have := false
344 for _, line := range strings.Split(out, "\n") {
345 if strings.Contains(line, "\x1f") {
346 parts := strings.Split(line, "\x1f")
347 if len(parts) < 4 {
348 continue
349 }
350 cur = Commit{SHA: parts[0], Author: parts[1], Subject: parts[3]}
351 cur.Unix, _ = strconv.ParseInt(parts[2], 10, 64)
352 if len(cur.SHA) >= 10 {
353 cur.Short = cur.SHA[:10]
354 }
355 have = true
356 continue
357 }
358 line = strings.TrimSpace(line)
359 if line == "" || !have {
360 continue
361 }
362 notePath(m, line, cur)
363 }
364 return m, nil
365}
366
367func notePath(m map[string]Commit, path string, c Commit) {
368 for path != "" && path != "." {
369 if _, ok := m[path]; !ok {
370 m[path] = c
371 }
372 i := strings.LastIndex(path, "/")
373 if i < 0 {
374 return
375 }
376 path = path[:i]
377 }
378}
379
380func emptyHistory(err error) bool {
381 msg := err.Error()
382 return strings.Contains(msg, "does not have any commits") || strings.Contains(msg, "bad default revision") || strings.Contains(msg, "ambiguous argument")
383}
384
385// Stats telt commits op rev, lokale branches en tags.
386func Stats(ctx context.Context, gitBin, dir, rev string) (commits, branches, tags int, err error) {
387 if rev == "" {
388 rev = "HEAD"
389 }
390 out, err := run(ctx, gitBin, nil, "-C", dir, "rev-list", "--count", rev)
391 if err != nil {
392 if emptyHistory(err) {
393 return 0, 0, 0, nil
394 }
395 return 0, 0, 0, err
396 }
397 commits, _ = strconv.Atoi(strings.TrimSpace(out))
398 names, err := Branches(ctx, gitBin, dir)
399 if err != nil {
400 return commits, 0, 0, err
401 }
402 branches = len(names)
403 out, err = run(ctx, gitBin, nil, "-C", dir, "for-each-ref", "--format=%(refname:short)", "refs/tags")
404 if err != nil {
405 return commits, branches, 0, err
406 }
407 for _, line := range strings.Split(strings.TrimSpace(out), "\n") {
408 if line != "" {
409 tags++
410 }
411 }
412 return commits, branches, tags, nil
413}
414
415// Tags geeft tagnamen.
416func Tags(ctx context.Context, gitBin, dir string) ([]string, error) {
417 out, err := run(ctx, gitBin, nil, "-C", dir, "for-each-ref", "--format=%(refname:short)", "refs/tags")
418 if err != nil {
419 return nil, err
420 }
421 var names []string
422 for _, line := range strings.Split(strings.TrimSpace(out), "\n") {
423 if line != "" {
424 names = append(names, line)
425 }
426 }
427 return names, nil
428}
429
430// TagInfo is één git-tag voor de webinterface.
431type TagInfo struct {
432 Name string
433 Annotated bool
434 Message string
435 CommitSHA string
436 CommitSubject string
437 Unix int64
438}
439
440// ListTags geeft alle tags, nieuwste eerst.
441func ListTags(ctx context.Context, gitBin, dir string) ([]TagInfo, error) {
442 const format = "%(refname:short)\n%(objecttype)\n%(objectname)\n%(*objectname)\n%(creatordate:unix)\n%(subject)\n%(*subject)\nBLUEGIT-END"
443 out, err := run(ctx, gitBin, nil, "-C", dir, "for-each-ref", "--sort=-creatordate", "--format="+format, "refs/tags")
444 if err != nil {
445 return nil, err
446 }
447 lines := strings.Split(out, "\n")
448 if len(lines) > 0 && lines[len(lines)-1] == "" {
449 lines = lines[:len(lines)-1]
450 }
451 var tags []TagInfo
452 for i := 0; i+7 < len(lines); i += 8 {
453 if lines[i+7] != "BLUEGIT-END" {
454 continue
455 }
456 unix, _ := strconv.ParseInt(strings.TrimSpace(lines[i+4]), 10, 64)
457 tag := TagInfo{Name: lines[i], Unix: unix}
458 if lines[i+1] == "tag" {
459 tag.Annotated = true
460 tag.CommitSHA = lines[i+3]
461 tag.CommitSubject = lines[i+6]
462 if tag.CommitSHA == "" {
463 tag.CommitSHA = lines[i+2]
464 }
465 if tag.CommitSubject == "" {
466 tag.CommitSubject = lines[i+5]
467 }
468 msg, err := run(ctx, gitBin, nil, "-C", dir, "for-each-ref", "--format=%(contents)", "refs/tags/"+tag.Name)
469 if err != nil {
470 return nil, err
471 }
472 tag.Message = strings.TrimSpace(msg)
473 } else {
474 tag.CommitSHA = lines[i+2]
475 tag.CommitSubject = lines[i+5]
476 }
477 if tag.Name != "" {
478 tags = append(tags, tag)
479 }
480 }
481 sort.SliceStable(tags, func(i, j int) bool {
482 if tags[i].Unix != tags[j].Unix {
483 return tags[i].Unix > tags[j].Unix
484 }
485 return tags[i].Name < tags[j].Name
486 })
487 return tags, nil
488}
489
490// CreateTag zet een tag op een branch of commit. Een leeg bericht blijft licht.
491func CreateTag(ctx context.Context, gitBin, dir, name, rev, message, author, email string) error {
492 if err := names.ValidTag(name); err != nil {
493 return err
494 }
495 sha, err := resolveCommit(ctx, gitBin, dir, rev)
496 if err != nil {
497 return err
498 }
499 if HasTag(ctx, gitBin, dir, name) {
500 return i18n.E("err.tagExists", name)
501 }
502 message = strings.TrimSpace(message)
503 if len(message) > 5000 {
504 return i18n.E("err.tagLong")
505 }
506 home, err := os.MkdirTemp(dir, "home-")
507 if err != nil {
508 return classifyGit(err)
509 }
510 defer os.RemoveAll(home)
511 env := CommandEnv(author, email, home, home)
512 if message == "" {
513 _, err = run(ctx, gitBin, env, "-C", dir, "tag", name, sha)
514 return err
515 }
516 _, err = run(ctx, gitBin, env, "-C", dir, "tag", "-a", name, sha, "-m", message)
517 return err
518}
519
520// DeleteTag verwijdert een bestaande tag.
521func DeleteTag(ctx context.Context, gitBin, dir, name string) error {
522 if err := usableTag(name); err != nil {
523 return err
524 }
525 if !HasTag(ctx, gitBin, dir, name) {
526 return i18n.E("err.tagMissing", name)
527 }
528 _, err := run(ctx, gitBin, nil, "-C", dir, "tag", "-d", "--", name)
529 return err
530}
531
532// HasTag meldt of refs/tags/name bestaat.
533func HasTag(ctx context.Context, gitBin, dir, name string) bool {
534 if err := usableTag(name); err != nil {
535 return false
536 }
537 _, err := run(ctx, gitBin, nil, "-C", dir, "rev-parse", "-q", "--verify", "--end-of-options", "refs/tags/"+name)
538 return err == nil
539}
540
541// Archive schrijft een zip of tar.gz van de tag naar w.
542func Archive(ctx context.Context, w io.Writer, gitBin, dir, prefix, name, format string) error {
543 if err := usableTag(name); err != nil {
544 return err
545 }
546 if !HasTag(ctx, gitBin, dir, name) {
547 return i18n.E("err.tagMissing", name)
548 }
549 return ArchiveAt(ctx, w, gitBin, dir, prefix, name, format)
550}
551
552// ArchiveAt schrijft een zip of tar.gz van een bestaande revisie.
553// rev is een tagnaam of refs/heads/….
554func ArchiveAt(ctx context.Context, w io.Writer, gitBin, dir, prefix, rev, format string) error {
555 if format != "zip" && format != "tar.gz" {
556 return i18n.E("err.notFound")
557 }
558 if rev == "" || strings.HasPrefix(rev, "-") || strings.Contains(rev, "..") || strings.ContainsAny(rev, " \t\r\n\\") {
559 return i18n.E("err.notFound")
560 }
561 if gitBin == "" {
562 gitBin = "git"
563 }
564 if prefix != "" && !strings.HasSuffix(prefix, "/") {
565 prefix += "/"
566 }
567 cmd := exec.CommandContext(ctx, gitBin, "-C", dir, "archive", "--format="+format, "--prefix="+prefix, rev)
568 cmd.Stdout = w
569 var stderr bytes.Buffer
570 cmd.Stderr = &stderr
571 if err := cmd.Run(); err != nil {
572 msg := strings.TrimSpace(stderr.String())
573 if msg == "" {
574 msg = err.Error()
575 }
576 return fmt.Errorf("%s", msg)
577 }
578 return nil
579}
580
581func resolveCommit(ctx context.Context, gitBin, dir, rev string) (string, error) {
582 rev = strings.TrimSpace(rev)
583 if rev == "" || strings.HasPrefix(rev, "-") || strings.Contains(rev, "..") || strings.ContainsAny(rev, " \t\r\n\\") {
584 return "", i18n.E("err.tagRef", rev)
585 }
586 out, err := run(ctx, gitBin, nil, "-C", dir, "rev-parse", "--verify", "--end-of-options", rev+"^{commit}")
587 if err != nil {
588 return "", i18n.E("err.tagRef", rev)
589 }
590 return strings.TrimSpace(out), nil
591}
592
593func usableTag(name string) error {
594 if name == "" || len(name) > 200 || strings.HasPrefix(name, "-") || strings.HasPrefix(name, "/") || strings.HasSuffix(name, "/") || strings.Contains(name, "..") || strings.Contains(name, "//") || strings.Contains(name, "@{") || strings.ContainsAny(name, " \t\r\n\\~^:?*[") {
595 return i18n.E("err.tag", name)
596 }
597 return nil
598}
599
600// TreeAll leest de hele boom. Name is het pad vanaf de root.
601func TreeAll(ctx context.Context, gitBin, dir, rev string) ([]Entry, error) {
602 if rev == "" {
603 rev = "HEAD"
604 }
605 out, err := run(ctx, gitBin, nil, "-C", dir, "ls-tree", "-r", "-t", rev)
606 if err != nil {
607 if emptyHistory(err) {
608 return nil, nil
609 }
610 return nil, err
611 }
612 return parseTree(out), nil
613}
614
615func parseTree(out string) []Entry {
616 var entries []Entry
617 for _, line := range strings.Split(strings.TrimSpace(out), "\n") {
618 if line == "" {
619 continue
620 }
621 tab := strings.SplitN(line, "\t", 2)
622 if len(tab) != 2 {
623 continue
624 }
625 head := strings.Fields(tab[0])
626 if len(head) != 3 {
627 continue
628 }
629 entries = append(entries, Entry{Mode: head[0], Type: head[1], SHA: head[2], Name: tab[1]})
630 }
631 return entries
632}
633
634// LastCommit is de nieuwste commit die path heeft geraakt. Leeg pad is de tip.
635func LastCommit(ctx context.Context, gitBin, dir, rev, path string) (Commit, error) {
636 if rev == "" {
637 rev = "HEAD"
638 }
639 args := []string{"-C", dir, "log", "-1", "--format=%H%x1f%an%x1f%ae%x1f%at%x1f%s", rev}
640 if path != "" {
641 args = append(args, "--", path)
642 }
643 out, err := run(ctx, gitBin, nil, args...)
644 if err != nil {
645 if emptyHistory(err) {
646 return Commit{}, nil
647 }
648 return Commit{}, err
649 }
650 line := strings.TrimSpace(out)
651 parts := strings.Split(line, "\x1f")
652 if len(parts) < 5 {
653 return Commit{}, nil
654 }
655 c := Commit{SHA: parts[0], Author: parts[1], Email: parts[2], Subject: parts[4]}
656 c.Unix, _ = strconv.ParseInt(parts[3], 10, 64)
657 if len(c.SHA) >= 10 {
658 c.Short = c.SHA[:10]
659 }
660 return c, nil
661}
662
663// BlobSize is de grootte in bytes.
664func BlobSize(ctx context.Context, gitBin, dir, rev, rel string) (int64, error) {
665 out, err := run(ctx, gitBin, nil, "-C", dir, "cat-file", "-s", rev+":"+rel)
666 if err != nil {
667 return 0, err
668 }
669 return strconv.ParseInt(strings.TrimSpace(out), 10, 64)
670}
671
672// PushedCommit is een commit die met een push nieuw bereikbaar werd.
673type PushedCommit struct {
674 SHA string
675 Email string
676 Name string
677 Unix int64
678}
679
680// CommitsSince geeft commits die newSHA bereikt en old niet.
681// Een lege of nul-old is de hele geschiedenis van newSHA.
682func CommitsSince(ctx context.Context, gitBin, dir, old, newSHA string) ([]PushedCommit, error) {
683 if newSHA == "" || allZero(newSHA) {
684 return nil, nil
685 }
686 args := []string{"-C", dir, "log", "--format=%H%x1f%ae%x1f%an%x1f%at", newSHA}
687 if old != "" && !allZero(old) {
688 args = append(args, "--not", old)
689 }
690 out, err := run(ctx, gitBin, nil, args...)
691 if err != nil {
692 if emptyHistory(err) {
693 return nil, nil
694 }
695 return nil, err
696 }
697 var commits []PushedCommit
698 for _, line := range strings.Split(out, "\n") {
699 line = strings.TrimSpace(line)
700 if line == "" || !strings.Contains(line, "\x1f") {
701 continue
702 }
703 parts := strings.Split(line, "\x1f")
704 if len(parts) < 4 {
705 continue
706 }
707 c := PushedCommit{SHA: parts[0], Email: parts[1], Name: parts[2]}
708 c.Unix, _ = strconv.ParseInt(parts[3], 10, 64)
709 commits = append(commits, c)
710 }
711 return commits, nil
712}
713
714func allZero(sha string) bool {
715 return strings.Trim(sha, "0") == ""
716}
717
718// RangeLog geeft de commits die newSHA bereikt en old niet, nieuwste eerst.
719// Een lege of nul-old is de geschiedenis van newSHA.
720func RangeLog(ctx context.Context, gitBin, dir, old, newSHA string) ([]Commit, error) {
721 if newSHA == "" || allZero(newSHA) {
722 return nil, nil
723 }
724 args := []string{"-C", dir, "log", "--format=%H%x1f%an%x1f%ae%x1f%ad%x1f%at%x1f%s%x1f%b%x1e", "--date=short", newSHA}
725 if old != "" && !allZero(old) {
726 args = append(args, "--not", old)
727 }
728 out, err := run(ctx, gitBin, nil, args...)
729 if err != nil {
730 if emptyHistory(err) {
731 return nil, nil
732 }
733 return nil, err
734 }
735 return parseLog(out), nil
736}
737
738// BranchOfRef haalt de branch uit refs/heads/… .
739func BranchOfRef(ref string) (string, bool) {
740 const p = "refs/heads/"
741 if strings.HasPrefix(ref, p) && len(ref) > len(p) {
742 return ref[len(p):], true
743 }
744 return "", false
745}
746
747// Merge voegt source samen in target en pusht het resultaat.
748// squash maakt één gewone commit met message in plaats van een merge-commit.
749// De push gaat door de hook, dus role en patterns moeten kloppen.
750func Merge(ctx context.Context, gitBin, bare, work, source, target, author, email, message string, squash bool, role access.Role, patterns []string) error {
751 repo, env, err := prepareWork(work, author, email)
752 if err != nil {
753 return classifyGit(err)
754 }
755 if _, err := run(ctx, gitBin, env, "clone", bare, repo); err != nil {
756 return classifyGit(err)
757 }
758 if _, err := run(ctx, gitBin, env, "-C", repo, "checkout", target); err != nil {
759 return classifyGit(fmt.Errorf("doelbranch %s: %w", target, err))
760 }
761 // De kloon heeft de bron alleen als origin/<branch>, niet als lokale branch.
762 if squash {
763 if _, err := run(ctx, gitBin, env, "-C", repo, "merge", "--squash", "origin/"+source); err != nil {
764 return i18n.E("err.mergeConflict")
765 }
766 if _, err := run(ctx, gitBin, env, "-C", repo, "commit", "-m", message); err != nil {
767 return classifyGit(err)
768 }
769 } else if _, err := run(ctx, gitBin, env, "-C", repo, "merge", "--no-ff", "--no-edit", "-m", message, "origin/"+source); err != nil {
770 return i18n.E("err.mergeConflict")
771 }
772 pushEnv := append(append([]string{}, env...), PushEnv(role, patterns, nil)...)
773 if _, err := run(ctx, gitBin, pushEnv, "-C", repo, "push", "origin", target); err != nil {
774 return classifyGit(err)
775 }
776 return nil
777}
778
779// Tag zet een annotated tag op sha.
780// Tag maakt een geannoteerde tag. Een annotated tag heeft een tagger
781// nodig; de serviceaccount heeft geen git-identiteit, dus die komt mee.
782// Leeg valt terug op BlueGit <noreply@git.timfalken.com>.
783func Tag(ctx context.Context, gitBin, dir, tag, sha, message, author, email string) error {
784 if strings.TrimSpace(author) == "" || strings.TrimSpace(email) == "" {
785 author, email = FallbackName, FallbackEmail
786 }
787 home, err := os.MkdirTemp("", "bluegit-tag-")
788 if err != nil {
789 return err
790 }
791 defer os.RemoveAll(home)
792 _, err = run(ctx, gitBin, CommandEnv(author, email, home, home), "-C", dir, "tag", "-a", tag, sha, "-m", message)
793 return err
794}
795
796// FallbackName en FallbackEmail zijn de identiteit van BlueGit zelf.
797const (
798 FallbackName = "BlueGit"
799 FallbackEmail = "noreply@git.timfalken.com"
800)
801
802// DiffStat is een korte vergelijking tussen twee branches.
803func DiffStat(ctx context.Context, gitBin, dir, target, source string) (string, error) {
804 out, err := run(ctx, gitBin, nil, "-C", dir, "log", "--oneline", target+".."+source)
805 if err != nil {
806 return "", err
807 }
808 return strings.TrimSpace(out), nil
809}
810
811func run(ctx context.Context, bin string, env []string, args ...string) (string, error) {
812 if bin == "" {
813 bin = "git"
814 }
815 cmd := exec.CommandContext(ctx, bin, args...)
816 if env != nil {
817 cmd.Env = env
818 }
819 var stdout, stderr bytes.Buffer
820 cmd.Stdout = &stdout
821 cmd.Stderr = &stderr
822 if err := cmd.Run(); err != nil {
823 msg := strings.TrimSpace(stderr.String())
824 if msg == "" {
825 msg = err.Error()
826 }
827 return "", fmt.Errorf("%s", msg)
828 }
829 return stdout.String(), nil
830}
831
832// Fork maakt dir als bare kloon van src met alle branches en tags. Objecten
833// worden lokaal gehardlinkt (geen extra schijfruimte voor bestaande objecten).
834// Daarna dezelfde instellingen en hook als Init; de remote naar src gaat weg.
835func Fork(gitBin, src, dir, hookBinary string) error {
836 if err := os.MkdirAll(filepath.Dir(dir), 0o755); err != nil {
837 return err
838 }
839 if _, err := run(context.Background(), gitBin, nil, "clone", "--bare", "--quiet", src, dir); err != nil {
840 return err
841 }
842 _, _ = run(context.Background(), gitBin, nil, "-C", dir, "remote", "remove", "origin")
843 for _, kv := range [][2]string{
844 {"http.receivepack", "true"},
845 {"http.uploadpack", "true"},
846 {"receive.denyCurrentBranch", "ignore"},
847 } {
848 if _, err := run(context.Background(), gitBin, nil, "-C", dir, "config", kv[0], kv[1]); err != nil {
849 return err
850 }
851 }
852 return InstallHook(dir, hookBinary)
853}
854
855// ErrNotFastForward: de branch in de fork is afgeweken van upstream.
856var ErrNotFastForward = errors.New("not fast-forward")
857
858// PushBranch zet branch uit src door naar dst, alleen fast-forward (geen
859// force). De pre-receive-hook van dst controleert rechten en bescherming.
860func PushBranch(ctx context.Context, gitBin, src, dst, branch string, env []string) error {
861 out, err := run(ctx, gitBin, env, "-C", src, "push", dst, "refs/heads/"+branch+":refs/heads/"+branch)
862 if err != nil {
863 msg := out + " " + err.Error()
864 if strings.Contains(msg, "non-fast-forward") || strings.Contains(msg, "fetch first") {
865 return ErrNotFastForward
866 }
867 return classifyGit(err)
868 }
869 return nil
870}
871
872// FetchBranch haalt branch uit src op in dst als refs/heads/as (geforceerd:
873// de spiegel volgt de bron). Een fetch draait geen hooks in dst.
874func FetchBranch(ctx context.Context, gitBin, src, dst, branch, as string) error {
875 _, err := run(ctx, gitBin, nil, "-C", dst, "fetch", "--quiet", "--no-tags", src, "+refs/heads/"+branch+":refs/heads/"+as)
876 return err
877}