BlueGit

timfa bluegit

Files

bluegit / internal / update / update.go

update.go

fix: accepteer een checkout van een andere uid en toon het update-log
timfa project_87923614_bot_3aff574f6f98414b945a8799374f9092 · pushed by timfa · 3 weeks ago
71de6a16 History
update.go 6.3 KiB Download Raw
1// Package update is de self-update van een geïnstalleerde BlueGit.
2// Het HTTP-endpoint schrijft alleen een verzoek weg en start de unit.
3// Het script in packaging doet de bouw en de installatie.
4package update
5
6import (
7 "context"
8 "crypto/sha256"
9 "crypto/subtle"
10 "encoding/json"
11 "errors"
12 "fmt"
13 "io"
14 "os"
15 "os/exec"
16 "path/filepath"
17 "regexp"
18 "strings"
19 "time"
20)
21
22const (
23 // Unit is de enige systemd-unit die de bluegit-gebruiker mag starten.
24 Unit = "bluegit-update.service"
25 // TokenEnv is de sleutel. Zonder waarde is het endpoint uit.
26 TokenEnv = "BLUEGIT_UPDATE_TOKEN"
27 // RequestFile is één regel: leeg betekent HEAD, anders een sha of ref.
28 RequestFile = "update-request"
29 // StatusFile is de laatste poging, gelezen door de Info- en setup-pagina.
30 StatusFile = "update-status.json"
31 // LogFile is de uitvoer van de laatste run van het update-script.
32 LogFile = "update.log"
33 // LogTailLines is hoeveel regels GET /api/v1/admin/self-update teruggeeft.
34 LogTailLines = 200
35 logTailBytes = 256 * 1024
36)
37
38// Status is het resultaat dat het update-script en de webpagina delen.
39type Status struct {
40 Time string `json:"time"`
41 SHA string `json:"sha"`
42 Result string `json:"result"`
43 Error string `json:"error,omitempty"`
44}
45
46// Token is de geconfigureerde sleutel. Leeg betekent dat self-update uit staat.
47func Token() string {
48 return strings.TrimSpace(os.Getenv(TokenEnv))
49}
50
51// Enabled is false zolang er geen sleutel in de omgeving staat.
52func Enabled() bool { return Token() != "" }
53
54// Equal vergelijkt twee sleutels zonder de lengte of de inhoud te lekken
55// via een vroege return. Een lege verwachte sleutel past nooit.
56func Equal(secret, got string) bool {
57 if secret == "" || got == "" {
58 return false
59 }
60 sumS := sha256.Sum256([]byte(secret))
61 sumG := sha256.Sum256([]byte(got))
62 return subtle.ConstantTimeCompare(sumS[:], sumG[:]) == 1
63}
64
65var refPattern = regexp.MustCompile(`^[0-9A-Za-z][0-9A-Za-z._/-]{0,199}$`)
66
67// ValidRef staat een lege ref toe (HEAD van de bare repo), een sha, of een
68// branchnaam. Punt-punt en @{ zijn geen git-ref die we aan het script geven.
69func ValidRef(ref string) bool {
70 if ref == "" {
71 return true
72 }
73 if strings.Contains(ref, "..") || strings.Contains(ref, "@{") {
74 return false
75 }
76 return refPattern.MatchString(ref)
77}
78
79// WriteRequest zet de gevraagde ref klaar voor de unit.
80func WriteRequest(dir, ref string) error {
81 if dir == "" {
82 return errors.New("state-map ontbreekt")
83 }
84 if err := os.MkdirAll(dir, 0o750); err != nil {
85 return err
86 }
87 target := filepath.Join(dir, RequestFile)
88 tmp, err := os.CreateTemp(dir, RequestFile+".*")
89 if err != nil {
90 return err
91 }
92 tmpName := tmp.Name()
93 cleanup := true
94 defer func() {
95 if cleanup {
96 _ = os.Remove(tmpName)
97 }
98 }()
99 if _, err := tmp.WriteString(ref + "\n"); err != nil {
100 _ = tmp.Close()
101 return err
102 }
103 if err := tmp.Chmod(0o640); err != nil {
104 _ = tmp.Close()
105 return err
106 }
107 if err := tmp.Close(); err != nil {
108 return err
109 }
110 if err := os.Rename(tmpName, target); err != nil {
111 return err
112 }
113 cleanup = false
114 return nil
115}
116
117// ReadStatus leest de laatste update. Een ontbrekend bestand is geen fout.
118func ReadStatus(dir string) (Status, error) {
119 if dir == "" {
120 return Status{}, nil
121 }
122 raw, err := os.ReadFile(filepath.Join(dir, StatusFile))
123 if err != nil {
124 if errors.Is(err, os.ErrNotExist) {
125 return Status{}, nil
126 }
127 return Status{}, err
128 }
129 var st Status
130 if err := json.Unmarshal(raw, &st); err != nil {
131 return Status{}, nil
132 }
133 return st, nil
134}
135
136// WriteStatus is voor tests en voor een mislukte start vanuit het proces.
137func WriteStatus(dir string, st Status) error {
138 if dir == "" {
139 return errors.New("state-map ontbreekt")
140 }
141 if st.Time == "" {
142 st.Time = time.Now().UTC().Format(time.RFC3339)
143 }
144 raw, err := json.Marshal(st)
145 if err != nil {
146 return err
147 }
148 raw = append(raw, '\n')
149 if err := os.MkdirAll(dir, 0o750); err != nil {
150 return err
151 }
152 target := filepath.Join(dir, StatusFile)
153 tmp, err := os.CreateTemp(dir, StatusFile+".*")
154 if err != nil {
155 return err
156 }
157 tmpName := tmp.Name()
158 cleanup := true
159 defer func() {
160 if cleanup {
161 _ = os.Remove(tmpName)
162 }
163 }()
164 if _, err := tmp.Write(raw); err != nil {
165 _ = tmp.Close()
166 return err
167 }
168 if err := tmp.Chmod(0o644); err != nil {
169 _ = tmp.Close()
170 return err
171 }
172 if err := tmp.Close(); err != nil {
173 return err
174 }
175 if err := os.Rename(tmpName, target); err != nil {
176 return err
177 }
178 cleanup = false
179 return nil
180}
181
182// ReadLogTail leest de laatste regels van het update-log.
183// Een ontbrekend bestand is geen fout: de geïnstalleerde updater schrijft
184// het pas nadat deze versie geïnstalleerd is.
185func ReadLogTail(dir string, lines int) (string, error) {
186 if dir == "" || lines <= 0 {
187 return "", nil
188 }
189 f, err := os.Open(filepath.Join(dir, LogFile))
190 if err != nil {
191 if errors.Is(err, os.ErrNotExist) {
192 return "", nil
193 }
194 return "", err
195 }
196 defer f.Close()
197 info, err := f.Stat()
198 if err != nil {
199 return "", err
200 }
201 start := int64(0)
202 if info.Size() > logTailBytes {
203 start = info.Size() - logTailBytes
204 }
205 if _, err := f.Seek(start, io.SeekStart); err != nil {
206 return "", err
207 }
208 raw, err := io.ReadAll(io.LimitReader(f, logTailBytes+1))
209 if err != nil {
210 return "", err
211 }
212 text := string(raw)
213 if start > 0 {
214 if i := strings.IndexByte(text, '\n'); i >= 0 {
215 text = text[i+1:]
216 }
217 }
218 return lastLines(text, lines), nil
219}
220
221func lastLines(text string, n int) string {
222 text = strings.TrimRight(text, "\n")
223 if text == "" || n <= 0 {
224 return ""
225 }
226 parts := strings.Split(text, "\n")
227 if len(parts) > n {
228 parts = parts[len(parts)-n:]
229 }
230 return strings.Join(parts, "\n")
231}
232
233// FreshRunning is waar als een update nog bezig hoort te zijn.
234func FreshRunning(st Status, now time.Time, window time.Duration) bool {
235 if st.Result != "running" || st.Time == "" {
236 return false
237 }
238 t, err := time.Parse(time.RFC3339, st.Time)
239 if err != nil {
240 return false
241 }
242 return now.Sub(t) < window && now.Sub(t) > -time.Minute
243}
244
245// StartSystemd start de oneshot zonder erop te wachten. De aanroepende
246// CI-job moet kunnen eindigen, anders wacht de updater eeuwig op zichzelf.
247func StartSystemd(ctx context.Context) error {
248 cmd := exec.CommandContext(ctx, "systemctl", "start", "--no-block", Unit)
249 out, err := cmd.CombinedOutput()
250 if err != nil {
251 msg := strings.TrimSpace(string(out))
252 if len(msg) > 200 {
253 msg = msg[:200]
254 }
255 if msg == "" {
256 return err
257 }
258 return fmt.Errorf("systemctl: %s", msg)
259 }
260 return nil
261}