1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
|
package askcli
import (
"context"
"errors"
"fmt"
"io"
"os"
"path/filepath"
"strconv"
"strings"
"time"
"codeberg.org/snonux/hexai/internal/filelock"
)
const askRepoLockFile = "hexai-ask.lock"
var errAskLockReopen = errors.New("ask lock: reopen after stale file removal")
func lockProcessLabel() string {
if exe, err := os.Executable(); err == nil {
if b := filepath.Base(exe); b != "" && b != "." {
return b
}
}
if b := filepath.Base(os.Args[0]); b != "" {
return b
}
return "ask"
}
func readLockHolderPID(f *os.File) int {
if _, err := f.Seek(0, io.SeekStart); err != nil {
return 0
}
var buf [64]byte
n, err := f.Read(buf[:])
if err != nil && !errors.Is(err, io.EOF) {
return 0
}
line := strings.TrimSpace(string(buf[:n]))
if line == "" {
return 0
}
end := strings.IndexAny(line, "\n\r \t")
if end >= 0 {
line = line[:end]
}
pid, err := strconv.Atoi(line)
if err != nil || pid <= 0 {
return 0
}
return pid
}
func writeLockMetadata(f *os.File, pid int, comm string) error {
if _, err := f.Seek(0, io.SeekStart); err != nil {
return err
}
if err := f.Truncate(0); err != nil {
return err
}
_, err := fmt.Fprintf(f, "%d\n%s\n", pid, comm)
if err != nil {
return err
}
return f.Sync()
}
// waitOrAcquireAskLockFD tries to take an exclusive lock on f, or blocks until ctx ends.
// On success it writes lock metadata and returns an unlock function (which closes f).
// errAskLockReopen means the caller should open the lock path again after stale removal.
func waitOrAcquireAskLockFD(
ctx context.Context,
f *os.File,
lockPath string,
comm string,
retryTimer *time.Timer,
) (func() error, error) {
for {
err := filelock.TryExclusive(f)
if err == nil {
if werr := writeLockMetadata(f, os.Getpid(), comm); werr != nil {
_ = filelock.UnlockExclusive(f)
_ = f.Close()
return nil, fmt.Errorf("ask lock: write metadata: %w", werr)
}
return func() error {
uErr := filelock.UnlockExclusive(f)
cErr := f.Close()
return errors.Join(uErr, cErr)
}, nil
}
if !errors.Is(err, filelock.ErrWouldBlock) {
_ = f.Close()
return nil, fmt.Errorf("ask lock: %w", err)
}
pid := readLockHolderPID(f)
if pid > 0 && lockHolderIsStale(pid, comm) {
_ = f.Close()
if rerr := os.Remove(lockPath); rerr != nil && !errors.Is(rerr, os.ErrNotExist) {
return nil, fmt.Errorf("ask lock: remove stale %s: %w", lockPath, rerr)
}
return nil, errAskLockReopen
}
retryTimer.Reset(5 * time.Millisecond)
select {
case <-ctx.Done():
_ = f.Close()
return nil, ctx.Err()
case <-retryTimer.C:
}
}
}
// acquireAskRepoLock serializes ask CLI access for a git working copy. It uses an
// advisory lock under .git and records holder PID plus process name for stale detection.
func acquireAskRepoLock(ctx context.Context, gitRoot string) (func() error, error) {
lockPath := filepath.Join(gitRoot, ".git", askRepoLockFile)
if err := os.MkdirAll(filepath.Dir(lockPath), 0o755); err != nil {
return nil, fmt.Errorf("ask lock: mkdir: %w", err)
}
comm := lockProcessLabel()
retryTimer := time.NewTimer(5 * time.Millisecond)
defer retryTimer.Stop()
for removalAttempts := 0; removalAttempts < 16; removalAttempts++ {
f, err := os.OpenFile(lockPath, os.O_CREATE|os.O_RDWR, 0o600)
if err != nil {
return nil, fmt.Errorf("ask lock: open %s: %w", lockPath, err)
}
unlock, err := waitOrAcquireAskLockFD(ctx, f, lockPath, comm, retryTimer)
if err == nil {
return unlock, nil
}
if errors.Is(err, errAskLockReopen) {
continue
}
return nil, err
}
return nil, fmt.Errorf("ask lock: could not acquire %s after stale recovery attempts", lockPath)
}
|
