BlueGit

timfa bluegit

Files

bluegit / internal / update / update.go

update.go

feat: self-update via een root-unit achter een token
timfa project_87923614_bot_3aff574f6f98414b945a8799374f9092 · pushed by timfa · 3 weeks ago
ad7bf26a History
update.go 5.0 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 "os"
14 "os/exec"
15 "path/filepath"
16 "regexp"
17 "strings"
18 "time"
19)
20
21const (
22 // Unit is de enige systemd-unit die de bluegit-gebruiker mag starten.
23 Unit = "bluegit-update.service"
24 // TokenEnv is de sleutel. Zonder waarde is het endpoint uit.
25 TokenEnv = "BLUEGIT_UPDATE_TOKEN"
26 // RequestFile is één regel: leeg betekent HEAD, anders een sha of ref.
27 RequestFile = "update-request"
28 // StatusFile is de laatste poging, gelezen door de Info- en setup-pagina.
29 StatusFile = "update-status.json"
30)
31
32// Status is het resultaat dat het update-script en de webpagina delen.
33type Status struct {
34 Time string `json:"time"`
35 SHA string `json:"sha"`
36 Result string `json:"result"`
37 Error string `json:"error,omitempty"`
38}
39
40// Token is de geconfigureerde sleutel. Leeg betekent dat self-update uit staat.
41func Token() string {
42 return strings.TrimSpace(os.Getenv(TokenEnv))
43}
44
45// Enabled is false zolang er geen sleutel in de omgeving staat.
46func Enabled() bool { return Token() != "" }
47
48// Equal vergelijkt twee sleutels zonder de lengte of de inhoud te lekken
49// via een vroege return. Een lege verwachte sleutel past nooit.
50func Equal(secret, got string) bool {
51 if secret == "" || got == "" {
52 return false
53 }
54 sumS := sha256.Sum256([]byte(secret))
55 sumG := sha256.Sum256([]byte(got))
56 return subtle.ConstantTimeCompare(sumS[:], sumG[:]) == 1
57}
58
59var refPattern = regexp.MustCompile(`^[0-9A-Za-z][0-9A-Za-z._/-]{0,199}$`)
60
61// ValidRef staat een lege ref toe (HEAD van de bare repo), een sha, of een
62// branchnaam. Punt-punt en @{ zijn geen git-ref die we aan het script geven.
63func ValidRef(ref string) bool {
64 if ref == "" {
65 return true
66 }
67 if strings.Contains(ref, "..") || strings.Contains(ref, "@{") {
68 return false
69 }
70 return refPattern.MatchString(ref)
71}
72
73// WriteRequest zet de gevraagde ref klaar voor de unit.
74func WriteRequest(dir, ref string) error {
75 if dir == "" {
76 return errors.New("state-map ontbreekt")
77 }
78 if err := os.MkdirAll(dir, 0o750); err != nil {
79 return err
80 }
81 target := filepath.Join(dir, RequestFile)
82 tmp, err := os.CreateTemp(dir, RequestFile+".*")
83 if err != nil {
84 return err
85 }
86 tmpName := tmp.Name()
87 cleanup := true
88 defer func() {
89 if cleanup {
90 _ = os.Remove(tmpName)
91 }
92 }()
93 if _, err := tmp.WriteString(ref + "\n"); err != nil {
94 _ = tmp.Close()
95 return err
96 }
97 if err := tmp.Chmod(0o640); err != nil {
98 _ = tmp.Close()
99 return err
100 }
101 if err := tmp.Close(); err != nil {
102 return err
103 }
104 if err := os.Rename(tmpName, target); err != nil {
105 return err
106 }
107 cleanup = false
108 return nil
109}
110
111// ReadStatus leest de laatste update. Een ontbrekend bestand is geen fout.
112func ReadStatus(dir string) (Status, error) {
113 if dir == "" {
114 return Status{}, nil
115 }
116 raw, err := os.ReadFile(filepath.Join(dir, StatusFile))
117 if err != nil {
118 if errors.Is(err, os.ErrNotExist) {
119 return Status{}, nil
120 }
121 return Status{}, err
122 }
123 var st Status
124 if err := json.Unmarshal(raw, &st); err != nil {
125 return Status{}, nil
126 }
127 return st, nil
128}
129
130// WriteStatus is voor tests en voor een mislukte start vanuit het proces.
131func WriteStatus(dir string, st Status) error {
132 if dir == "" {
133 return errors.New("state-map ontbreekt")
134 }
135 if st.Time == "" {
136 st.Time = time.Now().UTC().Format(time.RFC3339)
137 }
138 raw, err := json.Marshal(st)
139 if err != nil {
140 return err
141 }
142 raw = append(raw, '\n')
143 if err := os.MkdirAll(dir, 0o750); err != nil {
144 return err
145 }
146 target := filepath.Join(dir, StatusFile)
147 tmp, err := os.CreateTemp(dir, StatusFile+".*")
148 if err != nil {
149 return err
150 }
151 tmpName := tmp.Name()
152 cleanup := true
153 defer func() {
154 if cleanup {
155 _ = os.Remove(tmpName)
156 }
157 }()
158 if _, err := tmp.Write(raw); err != nil {
159 _ = tmp.Close()
160 return err
161 }
162 if err := tmp.Chmod(0o644); err != nil {
163 _ = tmp.Close()
164 return err
165 }
166 if err := tmp.Close(); err != nil {
167 return err
168 }
169 if err := os.Rename(tmpName, target); err != nil {
170 return err
171 }
172 cleanup = false
173 return nil
174}
175
176// FreshRunning is waar als een update nog bezig hoort te zijn.
177func FreshRunning(st Status, now time.Time, window time.Duration) bool {
178 if st.Result != "running" || st.Time == "" {
179 return false
180 }
181 t, err := time.Parse(time.RFC3339, st.Time)
182 if err != nil {
183 return false
184 }
185 return now.Sub(t) < window && now.Sub(t) > -time.Minute
186}
187
188// StartSystemd start de oneshot zonder erop te wachten. De aanroepende
189// CI-job moet kunnen eindigen, anders wacht de updater eeuwig op zichzelf.
190func StartSystemd(ctx context.Context) error {
191 cmd := exec.CommandContext(ctx, "systemctl", "start", "--no-block", Unit)
192 out, err := cmd.CombinedOutput()
193 if err != nil {
194 msg := strings.TrimSpace(string(out))
195 if len(msg) > 200 {
196 msg = msg[:200]
197 }
198 if msg == "" {
199 return err
200 }
201 return fmt.Errorf("systemctl: %s", msg)
202 }
203 return nil
204}