BlueGit

timfa bluegit

Files

bluegit / internal / gitrepo / refhold.go

refhold.go

refhold.go 8.8 KiB Download Raw
1package gitrepo
2
3import (
4 "bytes"
5 "context"
6 "errors"
7 "io"
8 "os"
9 "os/exec"
10 "strings"
11 "sync"
12 "syscall"
13 "time"
14
15 "gitlab.com/Timfa/bluegit/internal/names"
16)
17
18// Fouten bij het lezen of vasthouden van refs/tags/<naam>.
19// De tekst bevat geen pad en geen git-stderr; die staat apart in TagRefError.
20var (
21 ErrTagMissing = errors.New("tag missing")
22 ErrTagSymbolic = errors.New("symbolic tag")
23 ErrTagNotCommit = errors.New("tag is not a commit")
24 ErrTagMoved = errors.New("tag ref changed")
25 ErrTagBusy = errors.New("tag ref busy")
26 ErrTagLock = errors.New("tag ref lock failed")
27)
28
29// TagRefError is een lockfout. Detail is alleen voor het serverlog.
30type TagRefError struct {
31 Kind error
32 Detail string
33}
34
35func (e *TagRefError) Error() string {
36 if e == nil || e.Kind == nil {
37 return ""
38 }
39 return e.Kind.Error()
40}
41
42func (e *TagRefError) Unwrap() error {
43 if e == nil {
44 return nil
45 }
46 return e.Kind
47}
48
49// TagPoint is een directe tagref. ObjectOID is het object in de ref
50// (commit bij lightweight, tag-object bij annotated). CommitOID is gepeeld.
51type TagPoint struct {
52 Name string
53 Ref string
54 ObjectOID string
55 CommitOID string
56}
57
58// refHoldReplyTimeout begrenst één antwoord van git update-ref en het wachten
59// op een lock die een andere publicatie vasthoudt. Tests zetten hem lager.
60var refHoldReplyTimeout = 5 * time.Second
61
62// ResolveTag leest refs/tags/<name> zonder een ambigue revisie.
63// Een symbolic ref of een tag die niet naar een commit peelt wordt geweigerd.
64func ResolveTag(ctx context.Context, gitBin, dir, name string) (TagPoint, error) {
65 if err := names.ValidTag(name); err != nil {
66 return TagPoint{}, err
67 }
68 ref := "refs/tags/" + name
69 if gitBin == "" {
70 gitBin = "git"
71 }
72 sym := exec.CommandContext(ctx, gitBin, "-C", dir, "symbolic-ref", "-q", ref)
73 sym.Env = gitExecEnv()
74 if err := sym.Run(); err == nil {
75 return TagPoint{}, ErrTagSymbolic
76 }
77 if ctx.Err() != nil {
78 return TagPoint{}, ctx.Err()
79 }
80 object, err := gitLine(ctx, gitBin, dir, "rev-parse", "--verify", "--end-of-options", ref)
81 if err != nil {
82 if ctx.Err() != nil {
83 return TagPoint{}, ctx.Err()
84 }
85 return TagPoint{}, ErrTagMissing
86 }
87 object, ok := normalizeOID(object)
88 if !ok {
89 return TagPoint{}, ErrTagMissing
90 }
91 commit, err := gitLine(ctx, gitBin, dir, "rev-parse", "--verify", "--end-of-options", ref+"^{commit}")
92 if err != nil {
93 if ctx.Err() != nil {
94 return TagPoint{}, ctx.Err()
95 }
96 return TagPoint{}, ErrTagNotCommit
97 }
98 commit, ok = normalizeOID(commit)
99 if !ok {
100 return TagPoint{}, ErrTagNotCommit
101 }
102 return TagPoint{Name: name, Ref: ref, ObjectOID: object, CommitOID: commit}, nil
103}
104
105// RefHold houdt refs/tags/<naam> vast via git update-ref --stdin.
106// De transactie verifieert alleen. Release stuurt abort, zodat de tag
107// niet verandert en git zelf de lock vrijgeeft.
108type RefHold struct {
109 inner *refProc
110}
111
112// HoldTagRef neemt de ref-lock pas als git "prepare: ok" heeft geantwoord.
113// Een lock die een andere git-proces vasthoudt, wordt begrensd afgewacht.
114// Een andere OID is ErrTagMoved. Dit proces verwijdert nooit zelf een .lock-bestand.
115func HoldTagRef(ctx context.Context, gitBin, dir, name, objectOID string) (*RefHold, error) {
116 if err := names.ValidTag(name); err != nil {
117 return nil, err
118 }
119 objectOID, ok := normalizeOID(objectOID)
120 if !ok {
121 return nil, ErrTagLock
122 }
123 if gitBin == "" {
124 gitBin = "git"
125 }
126 deadline := time.Now().Add(refHoldReplyTimeout)
127 for {
128 if err := ctx.Err(); err != nil {
129 return nil, err
130 }
131 hold, err := acquireTagRef(ctx, gitBin, dir, "refs/tags/"+name, objectOID)
132 if err == nil {
133 return hold, nil
134 }
135 if !errors.Is(err, ErrTagBusy) || !time.Now().Before(deadline) {
136 if errors.Is(err, ErrTagBusy) {
137 return nil, &TagRefError{Kind: ErrTagLock, Detail: detailOf(err)}
138 }
139 return nil, err
140 }
141 timer := time.NewTimer(20 * time.Millisecond)
142 select {
143 case <-ctx.Done():
144 timer.Stop()
145 return nil, ctx.Err()
146 case <-timer.C:
147 }
148 }
149}
150
151// Release breekt de verify-transactie af. De tag blijft gelijk.
152// Een tweede aanroep doet niets. Bij een vastgelopen proces gaat er
153// SIGTERM heen. SIGKILL blijft achterwege: die laat een git-lockfile staan,
154// en die ruimen we niet zelf op.
155func (h *RefHold) Release() error {
156 if h == nil || h.inner == nil {
157 return nil
158 }
159 return h.inner.finish(true)
160}
161
162type refProc struct {
163 cmd *exec.Cmd
164 stdin io.WriteCloser
165 out *os.File
166 errBuf bytes.Buffer
167 wg sync.WaitGroup
168 finished bool
169 detail string
170 abortOK bool
171}
172
173func acquireTagRef(ctx context.Context, gitBin, dir, ref, objectOID string) (*RefHold, error) {
174 if err := ctx.Err(); err != nil {
175 return nil, err
176 }
177 cmd := exec.Command(gitBin, "-C", dir, "update-ref", "--stdin")
178 cmd.Env = gitExecEnv()
179 stdin, err := cmd.StdinPipe()
180 if err != nil {
181 return nil, err
182 }
183 stdout, err := cmd.StdoutPipe()
184 if err != nil {
185 _ = stdin.Close()
186 return nil, err
187 }
188 out, ok := stdout.(*os.File)
189 if !ok {
190 _ = stdin.Close()
191 _ = stdout.Close()
192 return nil, ErrTagLock
193 }
194 stderr, err := cmd.StderrPipe()
195 if err != nil {
196 _ = stdin.Close()
197 _ = stdout.Close()
198 return nil, err
199 }
200 if err := cmd.Start(); err != nil {
201 _ = stdin.Close()
202 _ = stdout.Close()
203 _ = stderr.Close()
204 return nil, err
205 }
206 p := &refProc{cmd: cmd, stdin: stdin, out: out}
207 p.wg.Add(1)
208 go func() {
209 defer p.wg.Done()
210 _, _ = io.Copy(&p.errBuf, stderr)
211 }()
212 fail := func(kind error) (*RefHold, error) {
213 _ = p.finish(false)
214 return nil, &TagRefError{Kind: kind, Detail: strings.TrimSpace(p.detail)}
215 }
216 if err := p.write("option no-deref"); err != nil {
217 return fail(ErrTagLock)
218 }
219 if err := p.write("start"); err != nil {
220 return fail(ErrTagLock)
221 }
222 line, err := p.readLine()
223 if err != nil || line != "start: ok" {
224 return fail(ErrTagLock)
225 }
226 if err := p.write("verify " + ref + " " + objectOID); err != nil {
227 return fail(ErrTagLock)
228 }
229 if err := p.write("prepare"); err != nil {
230 return fail(ErrTagLock)
231 }
232 line, err = p.readLine()
233 if err != nil || line != "prepare: ok" {
234 _ = p.finish(false)
235 return nil, classifyPrepare(strings.TrimSpace(p.detail))
236 }
237 return &RefHold{inner: p}, nil
238}
239
240func classifyPrepare(detail string) error {
241 low := strings.ToLower(detail)
242 kind := ErrTagMoved
243 if strings.Contains(low, "file exists") || strings.Contains(low, "unable to create") {
244 kind = ErrTagBusy
245 }
246 return &TagRefError{Kind: kind, Detail: detail}
247}
248
249func (p *refProc) write(line string) error {
250 if strings.ContainsAny(line, "\r\n") {
251 return ErrTagLock
252 }
253 _, err := io.WriteString(p.stdin, line+"\n")
254 return err
255}
256
257func (p *refProc) readLine() (string, error) {
258 _ = p.out.SetReadDeadline(time.Now().Add(refHoldReplyTimeout))
259 var b strings.Builder
260 tmp := make([]byte, 1)
261 for b.Len() <= 1024 {
262 n, err := p.out.Read(tmp)
263 if n == 1 {
264 if tmp[0] == '\n' {
265 return strings.TrimSpace(b.String()), nil
266 }
267 b.WriteByte(tmp[0])
268 continue
269 }
270 if err != nil {
271 return b.String(), err
272 }
273 }
274 return b.String(), ErrTagLock
275}
276
277func (p *refProc) finish(tryAbort bool) error {
278 if p == nil || p.finished {
279 return nil
280 }
281 p.finished = true
282 if tryAbort && p.cmd.Process != nil {
283 _ = p.write("abort")
284 line, err := p.readLine()
285 p.abortOK = err == nil && line == "abort: ok"
286 }
287 _ = p.stdin.Close()
288 err := p.reap()
289 p.detail = strings.TrimSpace(p.errBuf.String())
290 if p.abortOK {
291 return nil
292 }
293 return err
294}
295
296func (p *refProc) reap() error {
297 if p.cmd.Process == nil {
298 p.wg.Wait()
299 return nil
300 }
301 done := make(chan error, 1)
302 go func() { done <- p.cmd.Wait() }()
303 select {
304 case err := <-done:
305 p.wg.Wait()
306 return err
307 case <-time.After(refHoldReplyTimeout):
308 _ = p.cmd.Process.Signal(syscall.SIGTERM)
309 }
310 select {
311 case err := <-done:
312 p.wg.Wait()
313 return err
314 case <-time.After(refHoldReplyTimeout):
315 // Niet wg.Wait(): stderr kan open blijven als SIGTERM niets deed.
316 // Geen SIGKILL en geen Remove van *.lock: een stale lock is van git.
317 return ErrTagLock
318 }
319}
320
321func detailOf(err error) string {
322 var te *TagRefError
323 if errors.As(err, &te) {
324 return te.Detail
325 }
326 return ""
327}
328
329func gitLine(ctx context.Context, gitBin, dir string, args ...string) (string, error) {
330 cmd := exec.CommandContext(ctx, gitBin, append([]string{"-C", dir}, args...)...)
331 cmd.Env = gitExecEnv()
332 var stdout, stderr bytes.Buffer
333 cmd.Stdout = &stdout
334 cmd.Stderr = &stderr
335 if err := cmd.Run(); err != nil {
336 return "", err
337 }
338 return strings.TrimSpace(stdout.String()), nil
339}
340
341func gitExecEnv() []string {
342 env := []string{"LC_ALL=C", "GIT_TERMINAL_PROMPT=0"}
343 if path := os.Getenv("PATH"); path != "" {
344 env = append(env, "PATH="+path)
345 } else {
346 env = append(env, "PATH=/usr/bin:/bin")
347 }
348 if home := os.Getenv("HOME"); home != "" {
349 env = append(env, "HOME="+home)
350 }
351 return env
352}
353
354func normalizeOID(s string) (string, bool) {
355 if len(s) != 40 && len(s) != 64 {
356 return "", false
357 }
358 s = strings.ToLower(s)
359 for _, c := range s {
360 if (c < '0' || c > '9') && (c < 'a' || c > 'f') {
361 return "", false
362 }
363 }
364 return s, true
365}