BlueGit

timfa bluegit

Files

bluegit / internal / update / update.go

update.go

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