package gitrepo import ( "bytes" "context" "errors" "io" "os" "os/exec" "strings" "sync" "syscall" "time" "gitlab.com/Timfa/bluegit/internal/names" ) // Fouten bij het lezen of vasthouden van refs/tags/. // De tekst bevat geen pad en geen git-stderr; die staat apart in TagRefError. var ( ErrTagMissing = errors.New("tag missing") ErrTagSymbolic = errors.New("symbolic tag") ErrTagNotCommit = errors.New("tag is not a commit") ErrTagMoved = errors.New("tag ref changed") ErrTagBusy = errors.New("tag ref busy") ErrTagLock = errors.New("tag ref lock failed") ) // TagRefError is een lockfout. Detail is alleen voor het serverlog. type TagRefError struct { Kind error Detail string } func (e *TagRefError) Error() string { if e == nil || e.Kind == nil { return "" } return e.Kind.Error() } func (e *TagRefError) Unwrap() error { if e == nil { return nil } return e.Kind } // TagPoint is een directe tagref. ObjectOID is het object in de ref // (commit bij lightweight, tag-object bij annotated). CommitOID is gepeeld. type TagPoint struct { Name string Ref string ObjectOID string CommitOID string } // refHoldReplyTimeout begrenst één antwoord van git update-ref en het wachten // op een lock die een andere publicatie vasthoudt. Tests zetten hem lager. var refHoldReplyTimeout = 5 * time.Second // ResolveTag leest refs/tags/ zonder een ambigue revisie. // Een symbolic ref of een tag die niet naar een commit peelt wordt geweigerd. func ResolveTag(ctx context.Context, gitBin, dir, name string) (TagPoint, error) { if err := names.ValidTag(name); err != nil { return TagPoint{}, err } ref := "refs/tags/" + name if gitBin == "" { gitBin = "git" } sym := exec.CommandContext(ctx, gitBin, "-C", dir, "symbolic-ref", "-q", ref) sym.Env = gitExecEnv() if err := sym.Run(); err == nil { return TagPoint{}, ErrTagSymbolic } if ctx.Err() != nil { return TagPoint{}, ctx.Err() } object, err := gitLine(ctx, gitBin, dir, "rev-parse", "--verify", "--end-of-options", ref) if err != nil { if ctx.Err() != nil { return TagPoint{}, ctx.Err() } return TagPoint{}, ErrTagMissing } object, ok := normalizeOID(object) if !ok { return TagPoint{}, ErrTagMissing } commit, err := gitLine(ctx, gitBin, dir, "rev-parse", "--verify", "--end-of-options", ref+"^{commit}") if err != nil { if ctx.Err() != nil { return TagPoint{}, ctx.Err() } return TagPoint{}, ErrTagNotCommit } commit, ok = normalizeOID(commit) if !ok { return TagPoint{}, ErrTagNotCommit } return TagPoint{Name: name, Ref: ref, ObjectOID: object, CommitOID: commit}, nil } // RefHold houdt refs/tags/ vast via git update-ref --stdin. // De transactie verifieert alleen. Release stuurt abort, zodat de tag // niet verandert en git zelf de lock vrijgeeft. type RefHold struct { inner *refProc } // HoldTagRef neemt de ref-lock pas als git "prepare: ok" heeft geantwoord. // Een lock die een andere git-proces vasthoudt, wordt begrensd afgewacht. // Een andere OID is ErrTagMoved. Dit proces verwijdert nooit zelf een .lock-bestand. func HoldTagRef(ctx context.Context, gitBin, dir, name, objectOID string) (*RefHold, error) { if err := names.ValidTag(name); err != nil { return nil, err } objectOID, ok := normalizeOID(objectOID) if !ok { return nil, ErrTagLock } if gitBin == "" { gitBin = "git" } deadline := time.Now().Add(refHoldReplyTimeout) for { if err := ctx.Err(); err != nil { return nil, err } hold, err := acquireTagRef(ctx, gitBin, dir, "refs/tags/"+name, objectOID) if err == nil { return hold, nil } if !errors.Is(err, ErrTagBusy) || !time.Now().Before(deadline) { if errors.Is(err, ErrTagBusy) { return nil, &TagRefError{Kind: ErrTagLock, Detail: detailOf(err)} } return nil, err } timer := time.NewTimer(20 * time.Millisecond) select { case <-ctx.Done(): timer.Stop() return nil, ctx.Err() case <-timer.C: } } } // Release breekt de verify-transactie af. De tag blijft gelijk. // Een tweede aanroep doet niets. Bij een vastgelopen proces gaat er // SIGTERM heen. SIGKILL blijft achterwege: die laat een git-lockfile staan, // en die ruimen we niet zelf op. func (h *RefHold) Release() error { if h == nil || h.inner == nil { return nil } return h.inner.finish(true) } type refProc struct { cmd *exec.Cmd stdin io.WriteCloser out *os.File errBuf bytes.Buffer wg sync.WaitGroup finished bool detail string abortOK bool } func acquireTagRef(ctx context.Context, gitBin, dir, ref, objectOID string) (*RefHold, error) { if err := ctx.Err(); err != nil { return nil, err } cmd := exec.Command(gitBin, "-C", dir, "update-ref", "--stdin") cmd.Env = gitExecEnv() stdin, err := cmd.StdinPipe() if err != nil { return nil, err } stdout, err := cmd.StdoutPipe() if err != nil { _ = stdin.Close() return nil, err } out, ok := stdout.(*os.File) if !ok { _ = stdin.Close() _ = stdout.Close() return nil, ErrTagLock } stderr, err := cmd.StderrPipe() if err != nil { _ = stdin.Close() _ = stdout.Close() return nil, err } if err := cmd.Start(); err != nil { _ = stdin.Close() _ = stdout.Close() _ = stderr.Close() return nil, err } p := &refProc{cmd: cmd, stdin: stdin, out: out} p.wg.Add(1) go func() { defer p.wg.Done() _, _ = io.Copy(&p.errBuf, stderr) }() fail := func(kind error) (*RefHold, error) { _ = p.finish(false) return nil, &TagRefError{Kind: kind, Detail: strings.TrimSpace(p.detail)} } if err := p.write("option no-deref"); err != nil { return fail(ErrTagLock) } if err := p.write("start"); err != nil { return fail(ErrTagLock) } line, err := p.readLine() if err != nil || line != "start: ok" { return fail(ErrTagLock) } if err := p.write("verify " + ref + " " + objectOID); err != nil { return fail(ErrTagLock) } if err := p.write("prepare"); err != nil { return fail(ErrTagLock) } line, err = p.readLine() if err != nil || line != "prepare: ok" { _ = p.finish(false) return nil, classifyPrepare(strings.TrimSpace(p.detail)) } return &RefHold{inner: p}, nil } func classifyPrepare(detail string) error { low := strings.ToLower(detail) kind := ErrTagMoved if strings.Contains(low, "file exists") || strings.Contains(low, "unable to create") { kind = ErrTagBusy } return &TagRefError{Kind: kind, Detail: detail} } func (p *refProc) write(line string) error { if strings.ContainsAny(line, "\r\n") { return ErrTagLock } _, err := io.WriteString(p.stdin, line+"\n") return err } func (p *refProc) readLine() (string, error) { _ = p.out.SetReadDeadline(time.Now().Add(refHoldReplyTimeout)) var b strings.Builder tmp := make([]byte, 1) for b.Len() <= 1024 { n, err := p.out.Read(tmp) if n == 1 { if tmp[0] == '\n' { return strings.TrimSpace(b.String()), nil } b.WriteByte(tmp[0]) continue } if err != nil { return b.String(), err } } return b.String(), ErrTagLock } func (p *refProc) finish(tryAbort bool) error { if p == nil || p.finished { return nil } p.finished = true if tryAbort && p.cmd.Process != nil { _ = p.write("abort") line, err := p.readLine() p.abortOK = err == nil && line == "abort: ok" } _ = p.stdin.Close() err := p.reap() p.detail = strings.TrimSpace(p.errBuf.String()) if p.abortOK { return nil } return err } func (p *refProc) reap() error { if p.cmd.Process == nil { p.wg.Wait() return nil } done := make(chan error, 1) go func() { done <- p.cmd.Wait() }() select { case err := <-done: p.wg.Wait() return err case <-time.After(refHoldReplyTimeout): _ = p.cmd.Process.Signal(syscall.SIGTERM) } select { case err := <-done: p.wg.Wait() return err case <-time.After(refHoldReplyTimeout): // Niet wg.Wait(): stderr kan open blijven als SIGTERM niets deed. // Geen SIGKILL en geen Remove van *.lock: een stale lock is van git. return ErrTagLock } } func detailOf(err error) string { var te *TagRefError if errors.As(err, &te) { return te.Detail } return "" } func gitLine(ctx context.Context, gitBin, dir string, args ...string) (string, error) { cmd := exec.CommandContext(ctx, gitBin, append([]string{"-C", dir}, args...)...) cmd.Env = gitExecEnv() var stdout, stderr bytes.Buffer cmd.Stdout = &stdout cmd.Stderr = &stderr if err := cmd.Run(); err != nil { return "", err } return strings.TrimSpace(stdout.String()), nil } func gitExecEnv() []string { env := []string{"LC_ALL=C", "GIT_TERMINAL_PROMPT=0"} if path := os.Getenv("PATH"); path != "" { env = append(env, "PATH="+path) } else { env = append(env, "PATH=/usr/bin:/bin") } if home := os.Getenv("HOME"); home != "" { env = append(env, "HOME="+home) } return env } func normalizeOID(s string) (string, bool) { if len(s) != 40 && len(s) != 64 { return "", false } s = strings.ToLower(s) for _, c := range s { if (c < '0' || c > '9') && (c < 'a' || c > 'f') { return "", false } } return s, true }