// Package gitrepo legt bare repositories op schijf en praat met de git-binary. package gitrepo import ( "bufio" "bytes" "context" "errors" "fmt" "io" "os" "os/exec" "path/filepath" "sort" "strconv" "strings" "gitlab.com/Timfa/bluegit/internal/access" "gitlab.com/Timfa/bluegit/internal/i18n" "gitlab.com/Timfa/bluegit/internal/names" ) // Dir is de bare repository op de datadisk. func Dir(storage, owner, name string) string { return filepath.Join(storage, "repos", owner, name+".git") } // Init maakt een lege bare repository en zet de pre-receive-hook. func Init(gitBin, dir, defaultBranch, hookBinary string) error { if err := os.MkdirAll(filepath.Dir(dir), 0o755); err != nil { return err } if _, err := run(context.Background(), gitBin, nil, "init", "--bare", "--initial-branch", defaultBranch, dir); err != nil { return err } for _, kv := range [][2]string{ {"http.receivepack", "true"}, {"http.uploadpack", "true"}, {"receive.denyCurrentBranch", "ignore"}, } { if _, err := run(context.Background(), gitBin, nil, "-C", dir, "config", kv[0], kv[1]); err != nil { return err } } return InstallHook(dir, hookBinary) } // InstallHook schrijft hooks/pre-receive. Die roept deze binary aan. func InstallHook(dir, hookBinary string) error { if hookBinary == "" { return fmt.Errorf("hook-binary ontbreekt") } path := filepath.Join(dir, "hooks", "pre-receive") body := "#!/bin/sh\nset -eu\nexec " + shellQuote(hookBinary) + " hook pre-receive\n" if err := os.WriteFile(path, []byte(body), 0o755); err != nil { return err } return nil } func shellQuote(s string) string { return "'" + strings.ReplaceAll(s, "'", `'\''`) + "'" } // PushEnv zijn de variabelen die de hook leest. Zonder deze variabelen // weigert de hook, zodat een push buiten BlueGit om niet slaagt. func PushEnv(role access.Role, patterns, tagPatterns []string) []string { return []string{ "BLUEGIT_ROLE=" + string(role), "BLUEGIT_PROTECTED=" + strings.Join(patterns, "\n"), "BLUEGIT_PROTECTED_TAGS=" + strings.Join(tagPatterns, "\n"), } } // ReadUpdates leest de regels van een pre-receive-hook. func ReadUpdates(r io.Reader) ([]access.RefUpdate, error) { sc := bufio.NewScanner(r) var out []access.RefUpdate for sc.Scan() { line := strings.TrimSpace(sc.Text()) if line == "" { continue } parts := strings.Fields(line) if len(parts) != 3 { return nil, fmt.Errorf("onverwachte hookregel %q", line) } out = append(out, access.RefUpdate{Old: parts[0], New: parts[1], Ref: parts[2]}) } return out, sc.Err() } // EvaluatePush is wat `bluegit hook pre-receive` doet. func EvaluatePush(role access.Role, patterns, tagPatterns []string, r io.Reader) error { if role == "" { return fmt.Errorf("push geweigerd: geen BlueGit-rol") } ups, err := ReadUpdates(r) if err != nil { return err } return access.AuthorizeUpdates(role, patterns, tagPatterns, ups) } // Commit is één commit voor de webinterface. type Commit struct { SHA string Short string Author string Email string Date string Unix int64 Subject string Body string } // Entry is een bestand of map in een tree. type Entry struct { Mode string Type string SHA string Name string } // Log geeft de nieuwste commits. func Log(ctx context.Context, gitBin, dir, rev string, limit int) ([]Commit, error) { return LogPage(ctx, gitBin, dir, rev, 0, limit) } // LogPage slaat de nieuwste skip commits over en leest daarna hooguit limit commits. func LogPage(ctx context.Context, gitBin, dir, rev string, skip, limit int) ([]Commit, error) { if rev == "" { rev = "HEAD" } if limit < 1 { limit = 1 } if skip < 0 { skip = 0 } 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)} if skip > 0 { args = append(args, fmt.Sprintf("--skip=%d", skip)) } args = append(args, rev) out, err := run(ctx, gitBin, nil, args...) if err != nil { if strings.Contains(err.Error(), "does not have any commits") || strings.Contains(err.Error(), "bad default revision") || strings.Contains(err.Error(), "ambiguous argument") { return nil, nil } return nil, err } return parseLog(out), nil } func parseLog(out string) []Commit { var commits []Commit for _, rec := range strings.Split(out, "\x1e") { rec = strings.TrimSpace(rec) if rec == "" { continue } parts := strings.Split(rec, "\x1f") if len(parts) < 6 { continue } c := Commit{SHA: parts[0], Author: parts[1], Email: parts[2], Date: parts[3], Subject: parts[5]} c.Unix, _ = strconv.ParseInt(parts[4], 10, 64) if len(c.SHA) >= 10 { c.Short = c.SHA[:10] } if len(parts) > 6 { c.Body = strings.TrimSpace(parts[6]) } commits = append(commits, c) } return commits } // Message is een commitbericht. Merge is waar bij twee of meer ouders. type Message struct { Subject string Body string Author string Email string Merge bool } // Messages leest hooguit limit berichten, oudste eerst. func Messages(ctx context.Context, gitBin, dir, rev string, limit int) ([]Message, error) { if rev == "" { rev = "HEAD" } if limit < 1 { limit = 1 } if limit > 100 { limit = 100 } 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) if err != nil { if strings.Contains(err.Error(), "does not have any commits") || strings.Contains(err.Error(), "bad default revision") || strings.Contains(err.Error(), "ambiguous argument") { return nil, nil } return nil, err } return parseMessages(out), nil } func parseMessages(out string) []Message { var msgs []Message for _, rec := range strings.Split(out, "\x1e") { rec = strings.TrimSpace(rec) if rec == "" { continue } parts := strings.Split(rec, "\x1f") if len(parts) < 4 { continue } m := Message{Author: parts[0], Email: parts[1], Subject: parts[3]} m.Merge = len(strings.Fields(parts[2])) > 1 if len(parts) > 4 { m.Body = strings.TrimSpace(parts[4]) } msgs = append(msgs, m) } return msgs } // Show leest één commit. func Show(ctx context.Context, gitBin, dir, sha string) (Commit, error) { list, err := Log(ctx, gitBin, dir, sha, 1) if err != nil { return Commit{}, err } if len(list) == 0 { return Commit{}, fmt.Errorf("commit niet gevonden") } return list[0], nil } // Tree leest een map. path is relatief en mag leeg zijn. func Tree(ctx context.Context, gitBin, dir, rev, rel string) ([]Entry, error) { spec := rev if rel != "" { spec = rev + ":" + rel } out, err := run(ctx, gitBin, nil, "-C", dir, "ls-tree", spec) if err != nil { return nil, err } var entries []Entry for _, line := range strings.Split(strings.TrimSpace(out), "\n") { if line == "" { continue } // mode type sha\tname tab := strings.SplitN(line, "\t", 2) if len(tab) != 2 { continue } head := strings.Fields(tab[0]) if len(head) != 3 { continue } entries = append(entries, Entry{Mode: head[0], Type: head[1], SHA: head[2], Name: tab[1]}) } return entries, nil } // Blob leest een tekstbestand, afgekapt op max bytes. binary is waar als // het bestand een NUL bevat. func Blob(ctx context.Context, gitBin, dir, rev, rel string, max int) (text string, binary bool, err error) { out, err := run(ctx, gitBin, nil, "-C", dir, "show", rev+":"+rel) if err != nil { return "", false, err } if strings.Contains(out, "\x00") { return "", true, nil } if len(out) > max { out = out[:max] + "\n… afgekapt" } return out, false, nil } // Branches geeft lokale branchnamen. func Branches(ctx context.Context, gitBin, dir string) ([]string, error) { out, err := run(ctx, gitBin, nil, "-C", dir, "for-each-ref", "--format=%(refname:short)", "refs/heads") if err != nil { return nil, err } var names []string for _, line := range strings.Split(strings.TrimSpace(out), "\n") { if line != "" { names = append(names, line) } } return names, nil } // SetHEAD zet de symbolische HEAD van een bare repository naar een bestaande branch. // Het verwijdert geen refs of objecten. func SetHEAD(ctx context.Context, gitBin, dir, branch string) error { if branch == "" { return fmt.Errorf("leeg branch") } _, err := run(ctx, gitBin, nil, "-C", dir, "symbolic-ref", "HEAD", "refs/heads/"+branch) return err } // HasBranch meldt of de named branch bestaat. func HasBranch(ctx context.Context, gitBin, dir, branch string) bool { if branch == "" { return false } _, err := run(ctx, gitBin, nil, "-C", dir, "show-ref", "--verify", "--quiet", "refs/heads/"+branch) return err == nil } // HasCommit meldt of sha een commit in deze repository is. func HasCommit(ctx context.Context, gitBin, dir, sha string) bool { out, err := run(ctx, gitBin, nil, "-C", dir, "cat-file", "-t", sha) return err == nil && strings.TrimSpace(out) == "commit" } // Refs geeft refnaam → sha. func Refs(ctx context.Context, gitBin, dir string) (map[string]string, error) { out, err := run(ctx, gitBin, nil, "-C", dir, "for-each-ref", "--format=%(objectname) %(refname)") if err != nil { return nil, err } m := map[string]string{} for _, line := range strings.Split(strings.TrimSpace(out), "\n") { if line == "" { continue } parts := strings.SplitN(line, " ", 2) if len(parts) == 2 { m[parts[1]] = parts[0] } } return m, nil } // Touch geeft per pad de nieuwste commit uit de recente geschiedenis. // Mappen erven de nieuwste commit van een bestand erin. func Touch(ctx context.Context, gitBin, dir, rev string) (map[string]Commit, error) { if rev == "" { rev = "HEAD" } out, err := run(ctx, gitBin, nil, "-C", dir, "log", "--format=%H%x1f%an%x1f%at%x1f%s", "--name-only", "-n", "400", rev) if err != nil { if emptyHistory(err) { return map[string]Commit{}, nil } return nil, err } m := map[string]Commit{} var cur Commit have := false for _, line := range strings.Split(out, "\n") { if strings.Contains(line, "\x1f") { parts := strings.Split(line, "\x1f") if len(parts) < 4 { continue } cur = Commit{SHA: parts[0], Author: parts[1], Subject: parts[3]} cur.Unix, _ = strconv.ParseInt(parts[2], 10, 64) if len(cur.SHA) >= 10 { cur.Short = cur.SHA[:10] } have = true continue } line = strings.TrimSpace(line) if line == "" || !have { continue } notePath(m, line, cur) } return m, nil } func notePath(m map[string]Commit, path string, c Commit) { for path != "" && path != "." { if _, ok := m[path]; !ok { m[path] = c } i := strings.LastIndex(path, "/") if i < 0 { return } path = path[:i] } } func emptyHistory(err error) bool { msg := err.Error() return strings.Contains(msg, "does not have any commits") || strings.Contains(msg, "bad default revision") || strings.Contains(msg, "ambiguous argument") } // Stats telt commits op rev, lokale branches en tags. func Stats(ctx context.Context, gitBin, dir, rev string) (commits, branches, tags int, err error) { if rev == "" { rev = "HEAD" } out, err := run(ctx, gitBin, nil, "-C", dir, "rev-list", "--count", rev) if err != nil { if emptyHistory(err) { return 0, 0, 0, nil } return 0, 0, 0, err } commits, _ = strconv.Atoi(strings.TrimSpace(out)) names, err := Branches(ctx, gitBin, dir) if err != nil { return commits, 0, 0, err } branches = len(names) out, err = run(ctx, gitBin, nil, "-C", dir, "for-each-ref", "--format=%(refname:short)", "refs/tags") if err != nil { return commits, branches, 0, err } for _, line := range strings.Split(strings.TrimSpace(out), "\n") { if line != "" { tags++ } } return commits, branches, tags, nil } // Tags geeft tagnamen. func Tags(ctx context.Context, gitBin, dir string) ([]string, error) { out, err := run(ctx, gitBin, nil, "-C", dir, "for-each-ref", "--format=%(refname:short)", "refs/tags") if err != nil { return nil, err } var names []string for _, line := range strings.Split(strings.TrimSpace(out), "\n") { if line != "" { names = append(names, line) } } return names, nil } // TagInfo is één git-tag voor de webinterface. type TagInfo struct { Name string Annotated bool Message string CommitSHA string CommitSubject string Unix int64 } // ListTags geeft alle tags, nieuwste eerst. func ListTags(ctx context.Context, gitBin, dir string) ([]TagInfo, error) { const format = "%(refname:short)\n%(objecttype)\n%(objectname)\n%(*objectname)\n%(creatordate:unix)\n%(subject)\n%(*subject)\nBLUEGIT-END" out, err := run(ctx, gitBin, nil, "-C", dir, "for-each-ref", "--sort=-creatordate", "--format="+format, "refs/tags") if err != nil { return nil, err } lines := strings.Split(out, "\n") if len(lines) > 0 && lines[len(lines)-1] == "" { lines = lines[:len(lines)-1] } var tags []TagInfo for i := 0; i+7 < len(lines); i += 8 { if lines[i+7] != "BLUEGIT-END" { continue } unix, _ := strconv.ParseInt(strings.TrimSpace(lines[i+4]), 10, 64) tag := TagInfo{Name: lines[i], Unix: unix} if lines[i+1] == "tag" { tag.Annotated = true tag.CommitSHA = lines[i+3] tag.CommitSubject = lines[i+6] if tag.CommitSHA == "" { tag.CommitSHA = lines[i+2] } if tag.CommitSubject == "" { tag.CommitSubject = lines[i+5] } msg, err := run(ctx, gitBin, nil, "-C", dir, "for-each-ref", "--format=%(contents)", "refs/tags/"+tag.Name) if err != nil { return nil, err } tag.Message = strings.TrimSpace(msg) } else { tag.CommitSHA = lines[i+2] tag.CommitSubject = lines[i+5] } if tag.Name != "" { tags = append(tags, tag) } } sort.SliceStable(tags, func(i, j int) bool { if tags[i].Unix != tags[j].Unix { return tags[i].Unix > tags[j].Unix } return tags[i].Name < tags[j].Name }) return tags, nil } // CreateTag zet een tag op een branch of commit. Een leeg bericht blijft licht. func CreateTag(ctx context.Context, gitBin, dir, name, rev, message, author, email string) error { if err := names.ValidTag(name); err != nil { return err } sha, err := resolveCommit(ctx, gitBin, dir, rev) if err != nil { return err } if HasTag(ctx, gitBin, dir, name) { return i18n.E("err.tagExists", name) } message = strings.TrimSpace(message) if len(message) > 5000 { return i18n.E("err.tagLong") } home, err := os.MkdirTemp(dir, "home-") if err != nil { return classifyGit(err) } defer os.RemoveAll(home) env := CommandEnv(author, email, home, home) if message == "" { _, err = run(ctx, gitBin, env, "-C", dir, "tag", name, sha) return err } _, err = run(ctx, gitBin, env, "-C", dir, "tag", "-a", name, sha, "-m", message) return err } // DeleteTag verwijdert een bestaande tag. func DeleteTag(ctx context.Context, gitBin, dir, name string) error { if err := usableTag(name); err != nil { return err } if !HasTag(ctx, gitBin, dir, name) { return i18n.E("err.tagMissing", name) } _, err := run(ctx, gitBin, nil, "-C", dir, "tag", "-d", "--", name) return err } // HasTag meldt of refs/tags/name bestaat. func HasTag(ctx context.Context, gitBin, dir, name string) bool { if err := usableTag(name); err != nil { return false } _, err := run(ctx, gitBin, nil, "-C", dir, "rev-parse", "-q", "--verify", "--end-of-options", "refs/tags/"+name) return err == nil } // Archive schrijft een zip of tar.gz van de tag naar w. func Archive(ctx context.Context, w io.Writer, gitBin, dir, prefix, name, format string) error { if err := usableTag(name); err != nil { return err } if !HasTag(ctx, gitBin, dir, name) { return i18n.E("err.tagMissing", name) } return ArchiveAt(ctx, w, gitBin, dir, prefix, name, format) } // ArchiveAt schrijft een zip of tar.gz van een bestaande revisie. // rev is een tagnaam of refs/heads/…. func ArchiveAt(ctx context.Context, w io.Writer, gitBin, dir, prefix, rev, format string) error { if format != "zip" && format != "tar.gz" { return i18n.E("err.notFound") } if rev == "" || strings.HasPrefix(rev, "-") || strings.Contains(rev, "..") || strings.ContainsAny(rev, " \t\r\n\\") { return i18n.E("err.notFound") } if gitBin == "" { gitBin = "git" } if prefix != "" && !strings.HasSuffix(prefix, "/") { prefix += "/" } cmd := exec.CommandContext(ctx, gitBin, "-C", dir, "archive", "--format="+format, "--prefix="+prefix, rev) cmd.Stdout = w var stderr bytes.Buffer cmd.Stderr = &stderr if err := cmd.Run(); err != nil { msg := strings.TrimSpace(stderr.String()) if msg == "" { msg = err.Error() } return fmt.Errorf("%s", msg) } return nil } func resolveCommit(ctx context.Context, gitBin, dir, rev string) (string, error) { rev = strings.TrimSpace(rev) if rev == "" || strings.HasPrefix(rev, "-") || strings.Contains(rev, "..") || strings.ContainsAny(rev, " \t\r\n\\") { return "", i18n.E("err.tagRef", rev) } out, err := run(ctx, gitBin, nil, "-C", dir, "rev-parse", "--verify", "--end-of-options", rev+"^{commit}") if err != nil { return "", i18n.E("err.tagRef", rev) } return strings.TrimSpace(out), nil } func usableTag(name string) error { 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\\~^:?*[") { return i18n.E("err.tag", name) } return nil } // TreeAll leest de hele boom. Name is het pad vanaf de root. func TreeAll(ctx context.Context, gitBin, dir, rev string) ([]Entry, error) { if rev == "" { rev = "HEAD" } out, err := run(ctx, gitBin, nil, "-C", dir, "ls-tree", "-r", "-t", rev) if err != nil { if emptyHistory(err) { return nil, nil } return nil, err } return parseTree(out), nil } func parseTree(out string) []Entry { var entries []Entry for _, line := range strings.Split(strings.TrimSpace(out), "\n") { if line == "" { continue } tab := strings.SplitN(line, "\t", 2) if len(tab) != 2 { continue } head := strings.Fields(tab[0]) if len(head) != 3 { continue } entries = append(entries, Entry{Mode: head[0], Type: head[1], SHA: head[2], Name: tab[1]}) } return entries } // LastCommit is de nieuwste commit die path heeft geraakt. Leeg pad is de tip. func LastCommit(ctx context.Context, gitBin, dir, rev, path string) (Commit, error) { if rev == "" { rev = "HEAD" } args := []string{"-C", dir, "log", "-1", "--format=%H%x1f%an%x1f%ae%x1f%at%x1f%s", rev} if path != "" { args = append(args, "--", path) } out, err := run(ctx, gitBin, nil, args...) if err != nil { if emptyHistory(err) { return Commit{}, nil } return Commit{}, err } line := strings.TrimSpace(out) parts := strings.Split(line, "\x1f") if len(parts) < 5 { return Commit{}, nil } c := Commit{SHA: parts[0], Author: parts[1], Email: parts[2], Subject: parts[4]} c.Unix, _ = strconv.ParseInt(parts[3], 10, 64) if len(c.SHA) >= 10 { c.Short = c.SHA[:10] } return c, nil } // BlobSize is de grootte in bytes. func BlobSize(ctx context.Context, gitBin, dir, rev, rel string) (int64, error) { out, err := run(ctx, gitBin, nil, "-C", dir, "cat-file", "-s", rev+":"+rel) if err != nil { return 0, err } return strconv.ParseInt(strings.TrimSpace(out), 10, 64) } // PushedCommit is een commit die met een push nieuw bereikbaar werd. type PushedCommit struct { SHA string Email string Name string Unix int64 } // CommitsSince geeft commits die newSHA bereikt en old niet. // Een lege of nul-old is de hele geschiedenis van newSHA. func CommitsSince(ctx context.Context, gitBin, dir, old, newSHA string) ([]PushedCommit, error) { if newSHA == "" || allZero(newSHA) { return nil, nil } args := []string{"-C", dir, "log", "--format=%H%x1f%ae%x1f%an%x1f%at", newSHA} if old != "" && !allZero(old) { args = append(args, "--not", old) } out, err := run(ctx, gitBin, nil, args...) if err != nil { if emptyHistory(err) { return nil, nil } return nil, err } var commits []PushedCommit for _, line := range strings.Split(out, "\n") { line = strings.TrimSpace(line) if line == "" || !strings.Contains(line, "\x1f") { continue } parts := strings.Split(line, "\x1f") if len(parts) < 4 { continue } c := PushedCommit{SHA: parts[0], Email: parts[1], Name: parts[2]} c.Unix, _ = strconv.ParseInt(parts[3], 10, 64) commits = append(commits, c) } return commits, nil } func allZero(sha string) bool { return strings.Trim(sha, "0") == "" } // RangeLog geeft de commits die newSHA bereikt en old niet, nieuwste eerst. // Een lege of nul-old is de geschiedenis van newSHA. func RangeLog(ctx context.Context, gitBin, dir, old, newSHA string) ([]Commit, error) { if newSHA == "" || allZero(newSHA) { return nil, nil } args := []string{"-C", dir, "log", "--format=%H%x1f%an%x1f%ae%x1f%ad%x1f%at%x1f%s%x1f%b%x1e", "--date=short", newSHA} if old != "" && !allZero(old) { args = append(args, "--not", old) } out, err := run(ctx, gitBin, nil, args...) if err != nil { if emptyHistory(err) { return nil, nil } return nil, err } return parseLog(out), nil } // BranchOfRef haalt de branch uit refs/heads/… . func BranchOfRef(ref string) (string, bool) { const p = "refs/heads/" if strings.HasPrefix(ref, p) && len(ref) > len(p) { return ref[len(p):], true } return "", false } // Merge voegt source samen in target en pusht het resultaat. // squash maakt één gewone commit met message in plaats van een merge-commit. // De push gaat door de hook, dus role en patterns moeten kloppen. func Merge(ctx context.Context, gitBin, bare, work, source, target, author, email, message string, squash bool, role access.Role, patterns []string) error { repo, env, err := prepareWork(work, author, email) if err != nil { return classifyGit(err) } if _, err := run(ctx, gitBin, env, "clone", bare, repo); err != nil { return classifyGit(err) } if _, err := run(ctx, gitBin, env, "-C", repo, "checkout", target); err != nil { return classifyGit(fmt.Errorf("doelbranch %s: %w", target, err)) } // De kloon heeft de bron alleen als origin/, niet als lokale branch. if squash { if _, err := run(ctx, gitBin, env, "-C", repo, "merge", "--squash", "origin/"+source); err != nil { return i18n.E("err.mergeConflict") } if _, err := run(ctx, gitBin, env, "-C", repo, "commit", "-m", message); err != nil { return classifyGit(err) } } else if _, err := run(ctx, gitBin, env, "-C", repo, "merge", "--no-ff", "--no-edit", "-m", message, "origin/"+source); err != nil { return i18n.E("err.mergeConflict") } pushEnv := append(append([]string{}, env...), PushEnv(role, patterns, nil)...) if _, err := run(ctx, gitBin, pushEnv, "-C", repo, "push", "origin", target); err != nil { return classifyGit(err) } return nil } // Tag zet een annotated tag op sha. // Tag maakt een geannoteerde tag. Een annotated tag heeft een tagger // nodig; de serviceaccount heeft geen git-identiteit, dus die komt mee. // Leeg valt terug op BlueGit . func Tag(ctx context.Context, gitBin, dir, tag, sha, message, author, email string) error { if strings.TrimSpace(author) == "" || strings.TrimSpace(email) == "" { author, email = FallbackName, FallbackEmail } home, err := os.MkdirTemp("", "bluegit-tag-") if err != nil { return err } defer os.RemoveAll(home) _, err = run(ctx, gitBin, CommandEnv(author, email, home, home), "-C", dir, "tag", "-a", tag, sha, "-m", message) return err } // FallbackName en FallbackEmail zijn de identiteit van BlueGit zelf. const ( FallbackName = "BlueGit" FallbackEmail = "noreply@git.timfalken.com" ) // DiffStat is een korte vergelijking tussen twee branches. func DiffStat(ctx context.Context, gitBin, dir, target, source string) (string, error) { out, err := run(ctx, gitBin, nil, "-C", dir, "log", "--oneline", target+".."+source) if err != nil { return "", err } return strings.TrimSpace(out), nil } func run(ctx context.Context, bin string, env []string, args ...string) (string, error) { if bin == "" { bin = "git" } cmd := exec.CommandContext(ctx, bin, args...) if env != nil { cmd.Env = env } var stdout, stderr bytes.Buffer cmd.Stdout = &stdout cmd.Stderr = &stderr if err := cmd.Run(); err != nil { msg := strings.TrimSpace(stderr.String()) if msg == "" { msg = err.Error() } return "", fmt.Errorf("%s", msg) } return stdout.String(), nil } // Fork maakt dir als bare kloon van src met alle branches en tags. Objecten // worden lokaal gehardlinkt (geen extra schijfruimte voor bestaande objecten). // Daarna dezelfde instellingen en hook als Init; de remote naar src gaat weg. func Fork(gitBin, src, dir, hookBinary string) error { if err := os.MkdirAll(filepath.Dir(dir), 0o755); err != nil { return err } if _, err := run(context.Background(), gitBin, nil, "clone", "--bare", "--quiet", src, dir); err != nil { return err } _, _ = run(context.Background(), gitBin, nil, "-C", dir, "remote", "remove", "origin") for _, kv := range [][2]string{ {"http.receivepack", "true"}, {"http.uploadpack", "true"}, {"receive.denyCurrentBranch", "ignore"}, } { if _, err := run(context.Background(), gitBin, nil, "-C", dir, "config", kv[0], kv[1]); err != nil { return err } } return InstallHook(dir, hookBinary) } // ErrNotFastForward: de branch in de fork is afgeweken van upstream. var ErrNotFastForward = errors.New("not fast-forward") // PushBranch zet branch uit src door naar dst, alleen fast-forward (geen // force). De pre-receive-hook van dst controleert rechten en bescherming. func PushBranch(ctx context.Context, gitBin, src, dst, branch string, env []string) error { out, err := run(ctx, gitBin, env, "-C", src, "push", dst, "refs/heads/"+branch+":refs/heads/"+branch) if err != nil { msg := out + " " + err.Error() if strings.Contains(msg, "non-fast-forward") || strings.Contains(msg, "fetch first") { return ErrNotFastForward } return classifyGit(err) } return nil } // FetchBranch haalt branch uit src op in dst als refs/heads/as (geforceerd: // de spiegel volgt de bron). Een fetch draait geen hooks in dst. func FetchBranch(ctx context.Context, gitBin, src, dst, branch, as string) error { _, err := run(ctx, gitBin, nil, "-C", dst, "fetch", "--quiet", "--no-tags", src, "+refs/heads/"+branch+":refs/heads/"+as) return err }