BlueGit

timfa bluegit

Files

bluegit / internal / backupserver / server / actions.go

actions.go

actions.go 15.0 KiB Download Raw
1package server
2
3import (
4 "context"
5 "crypto/subtle"
6 "encoding/json"
7 "errors"
8 "fmt"
9 "io"
10 "net/http"
11 "sort"
12 "strconv"
13 "strings"
14
15 "gitlab.com/Timfa/bluegit/internal/backupserver/archive"
16 "gitlab.com/Timfa/bluegit/internal/backupserver/config"
17 "gitlab.com/Timfa/bluegit/internal/backupserver/mirror"
18 "gitlab.com/Timfa/bluegit/internal/backupserver/protocol"
19)
20
21// Input is de invoer van een actie: JSON-velden, querystring, formulier of
22// padwaarden, allemaal als tekst.
23type Input map[string]string
24
25// Action is één beheerhandeling. De API, de webinterface en BlueGit lopen
26// allemaal via deze lijst, zodat ze precies hetzelfde kunnen.
27type Action struct {
28 // Name is de naam in de webinterface (/ui/act/<name>).
29 Name string `json:"name"`
30 Method string `json:"method"`
31 Path string `json:"path"`
32 // Title is de knoptekst of beschrijving.
33 Title string `json:"title"`
34 // Signed: ook de gekoppelde BlueGit mag dit (ondertekend verzoek).
35 Signed bool `json:"bluegit"`
36 // Params zijn de padwaarden, bijvoorbeeld {name}.
37 Params []string `json:"params,omitempty"`
38 // Fields zijn de invoervelden (documentatie en de lijst in /api/v1/admin/actions).
39 Fields []string `json:"fields,omitempty"`
40 Do func(ctx context.Context, in Input) (int, any) `json:"-"`
41}
42
43// fileResult laat de API een bestand sturen in plaats van JSON.
44type fileResult struct{ path, name string }
45
46func errBody(err error) map[string]string { return map[string]string{"error": err.Error()} }
47
48// Actions is de volledige lijst met beheerhandelingen.
49func (s *Server) Actions() []Action {
50 return []Action{
51 {Name: "status", Method: "GET", Path: "/api/v1/admin/status", Title: "Status", Signed: true,
52 Do: func(ctx context.Context, in Input) (int, any) { return 200, s.Status() }},
53 {Name: "actions", Method: "GET", Path: "/api/v1/admin/actions", Title: "Alle acties", Signed: true,
54 Do: func(ctx context.Context, in Input) (int, any) { return 200, map[string]any{"actions": s.Actions()} }},
55 {Name: "config", Method: "GET", Path: "/api/v1/admin/config", Title: "Instellingen", Signed: true,
56 Do: func(ctx context.Context, in Input) (int, any) { return 200, s.ConfigView() }},
57 {Name: "config.update", Method: "PUT", Path: "/api/v1/admin/config", Title: "Instellingen opslaan", Signed: true,
58 Fields: fieldKeys(), Do: s.actConfigUpdate},
59 {Name: "connect", Method: "POST", Path: "/api/v1/admin/connect", Title: "Koppelen",
60 Fields: []string{"url", "key", "on_conflict"}, Do: s.actConnect},
61 {Name: "disconnect", Method: "POST", Path: "/api/v1/admin/disconnect", Title: "Ontkoppelen", Signed: true,
62 Do: s.actDisconnect},
63 {Name: "sync", Method: "POST", Path: "/api/v1/admin/sync", Title: "Nu synchroniseren", Signed: true,
64 Fields: []string{"wait"}, Do: s.actSync},
65 {Name: "archive", Method: "POST", Path: "/api/v1/admin/archive", Title: "Nu archiveren", Signed: true,
66 Do: func(ctx context.Context, in Input) (int, any) {
67 a, err := s.ArchiveNow()
68 if err != nil {
69 return 409, errBody(err)
70 }
71 return 201, a
72 }},
73 {Name: "prune", Method: "POST", Path: "/api/v1/admin/prune", Title: "Nu opruimen", Signed: true,
74 Do: func(ctx context.Context, in Input) (int, any) {
75 removed, err := s.Prune()
76 if err != nil {
77 return 500, errBody(err)
78 }
79 if removed == nil {
80 removed = []string{}
81 }
82 return 200, map[string]any{"removed": removed}
83 }},
84 {Name: "archives", Method: "GET", Path: "/api/v1/admin/archives", Title: "Archieven", Signed: true,
85 Do: func(ctx context.Context, in Input) (int, any) {
86 list, err := s.archives.List()
87 if err != nil {
88 return 500, errBody(err)
89 }
90 return 200, map[string]any{"archives": list}
91 }},
92 {Name: "archive.download", Method: "GET", Path: "/api/v1/admin/archives/{name}/download", Title: "Downloaden",
93 Params: []string{"name"}, Do: func(ctx context.Context, in Input) (int, any) {
94 p, err := s.archives.Path(in["name"])
95 if err != nil {
96 return 404, errBody(err)
97 }
98 return 200, fileResult{path: p, name: in["name"]}
99 }},
100 {Name: "archive.delete", Method: "DELETE", Path: "/api/v1/admin/archives/{name}", Title: "Verwijderen", Signed: true,
101 Params: []string{"name"}, Do: s.actArchiveDelete},
102 {Name: "rollback", Method: "POST", Path: "/api/v1/admin/rollback", Title: "Rollback", Signed: true,
103 Fields: []string{"archive", "confirm"}, Do: s.actRollback},
104 }
105}
106
107func fieldKeys() []string {
108 out := make([]string, 0, len(config.Fields))
109 for _, f := range config.Fields {
110 out = append(out, f.Key)
111 }
112 return out
113}
114
115func (s *Server) action(name string) (Action, bool) {
116 for _, a := range s.Actions() {
117 if a.Name == name {
118 return a, true
119 }
120 }
121 return Action{}, false
122}
123
124// ConfigView is GET /api/v1/admin/config.
125type ConfigView struct {
126 Fields []ConfigField `json:"fields"`
127 DataDir string `json:"data_dir"`
128 // Restart: historisch; listen geldt nu meteen. Blijft in de API (altijd false).
129 Restart bool `json:"restart_pending"`
130 // Listening is het adres waarop de server nu luistert (leeg in tests
131 // die niet via ListenAndServe draaien).
132 Listening string `json:"listening,omitempty"`
133 // ListenNotice vertelt waar de server na een geslaagde omzetting luistert.
134 ListenNotice string `json:"listen_notice,omitempty"`
135}
136
137// ConfigField is een veld met zijn waarde.
138type ConfigField struct {
139 config.Field
140 Value string `json:"value"`
141}
142
143// ConfigView geeft alle instellingen met hun huidige waarde.
144func (s *Server) ConfigView() ConfigView {
145 s.mu.Lock()
146 defer s.mu.Unlock()
147 return s.configViewLocked()
148}
149
150func (s *Server) configViewLocked() ConfigView {
151 v := ConfigView{DataDir: s.Cfg.DataDir, Listening: s.BoundAddr()}
152 for _, f := range config.Fields {
153 v.Fields = append(v.Fields, ConfigField{Field: f, Value: s.Cfg.Get(f.Key)})
154 }
155 return v
156}
157
158// UpdateConfig past instellingen toe en bewaart ze in settings.yml.
159// Een nieuw listen-adres wordt meteen geprobeerd; lukt binden niet, dan
160// blijft alles zoals het was.
161func (s *Server) UpdateConfig(set map[string]string) (ConfigView, error) {
162 s.mu.Lock()
163 next := s.Cfg
164 if err := next.Apply(set); err != nil {
165 s.mu.Unlock()
166 return ConfigView{}, err
167 }
168 oldListen := s.Cfg.Listen
169 listenChanged := next.Listen != oldListen
170 if listenChanged && s.isServing() {
171 // Eerst binden, pas daarna bewaren: bij een fout blijft alles hetzelfde.
172 s.mu.Unlock()
173 if err := s.Relisten(next.Listen); err != nil {
174 return ConfigView{}, err
175 }
176 s.mu.Lock()
177 // Relisten is gelukt; als opslaan faalt, zetten we de listener terug.
178 }
179 merged := map[string]string{}
180 for k, v := range s.settings {
181 merged[k] = v
182 }
183 for k := range set {
184 if f, ok := config.FieldByKey(k); ok && f.Readonly {
185 s.mu.Unlock()
186 return ConfigView{}, fmt.Errorf("%s is niet instelbaar in de webinterface of API", k)
187 }
188 merged[k] = next.Get(k)
189 }
190 if err := config.SaveSettings(next.DataDir, merged); err != nil {
191 if listenChanged && s.isServing() {
192 s.mu.Unlock()
193 _ = s.Relisten(oldListen)
194 s.mu.Lock()
195 }
196 s.mu.Unlock()
197 return ConfigView{}, err
198 }
199 s.settings = merged
200 s.Cfg = next
201 s.restartPending = false
202 view := s.configViewLocked()
203 if listenChanged {
204 where := view.Listening
205 if where == "" {
206 where = next.Listen
207 }
208 view.ListenNotice = "De server luistert nu op " + where + "."
209 }
210 s.mu.Unlock()
211 s.limiter.SetRate(next.RateLimitKiB << 10)
212 keys := make([]string, 0, len(set))
213 for k := range set {
214 keys = append(keys, k)
215 }
216 sort.Strings(keys)
217 s.Log.Info("instellingen gewijzigd", "keys", strings.Join(keys, ","))
218 s.Kick()
219 return view, nil
220}
221
222func (s *Server) actConfigUpdate(ctx context.Context, in Input) (int, any) {
223 set := map[string]string{}
224 for k, v := range in {
225 set[k] = v
226 }
227 if len(set) == 0 {
228 return 400, errBody(errors.New("geen instellingen meegegeven"))
229 }
230 v, err := s.UpdateConfig(set)
231 if err != nil {
232 return 400, errBody(err)
233 }
234 return 200, v
235}
236
237func (s *Server) actConnect(ctx context.Context, in Input) (int, any) {
238 res, conflict, err := s.Connect(ctx, ConnectRequest{URL: in["url"], Key: in["key"], OnConflict: in["on_conflict"]})
239 if conflict != nil {
240 return http.StatusConflict, conflict
241 }
242 if err != nil {
243 var he *mirror.HTTPError
244 code := 502
245 if errors.As(err, &he) && he.Status == 401 {
246 code = 401
247 }
248 if errors.Is(err, errBadRequest) {
249 code = 400
250 }
251 return code, errBody(err)
252 }
253 return 200, res
254}
255
256// Disconnect vergeet de gekoppelde BlueGit. De kopie en de archieven blijven
257// staan; een volgende koppeling met een andere BlueGit vraagt dan weer om
258// wissen of herstellen.
259func (s *Server) Disconnect() error {
260 s.work.Lock()
261 defer s.work.Unlock()
262 st := s.getState()
263 keep := State{InstanceID: st.InstanceID, BlueGitURL: st.BlueGitURL}
264 if err := saveState(s.Cfg.DataDir, keep); err != nil {
265 return err
266 }
267 s.mu.Lock()
268 s.state = keep
269 s.bluegitKnown = false
270 s.mu.Unlock()
271 s.Log.Warn("ontkoppeld", "bluegit", st.BlueGitURL)
272 return nil
273}
274
275func (s *Server) actDisconnect(ctx context.Context, in Input) (int, any) {
276 if !s.getState().Connected() {
277 return 409, errBody(errors.New("er is geen BlueGit gekoppeld"))
278 }
279 if err := s.Disconnect(); err != nil {
280 return 500, errBody(err)
281 }
282 return 200, map[string]any{"connected": false}
283}
284
285func (s *Server) actSync(ctx context.Context, in Input) (int, any) {
286 if !s.getState().Connected() {
287 return 409, errBody(errors.New("geen BlueGit gekoppeld"))
288 }
289 if in["wait"] == "false" || in["wait"] == "0" {
290 s.Kick()
291 return 202, map[string]string{"state": "started"}
292 }
293 stats, err := s.SyncNow(ctx)
294 if errors.Is(err, ErrIncompatible) {
295 return http.StatusConflict, errBody(err)
296 }
297 if err != nil {
298 return 502, errBody(err)
299 }
300 return 200, stats
301}
302
303func (s *Server) actArchiveDelete(ctx context.Context, in Input) (int, any) {
304 name := in["name"]
305 if !archive.ValidName(name) {
306 return 400, errBody(errors.New("ongeldige archiefnaam"))
307 }
308 s.work.Lock()
309 err := s.archives.Delete(name)
310 s.work.Unlock()
311 if err != nil {
312 return 404, errBody(err)
313 }
314 s.Log.Info("archief verwijderd met de hand", "archive", name)
315 return 200, map[string]string{"deleted": name}
316}
317
318func (s *Server) actRollback(ctx context.Context, in Input) (int, any) {
319 name := in["archive"]
320 if !archive.ValidName(name) {
321 return 400, errBody(errors.New("ongeldige archiefnaam"))
322 }
323 if in["confirm"] != name {
324 return 400, errBody(errors.New("bevestig met de archiefnaam in confirm; een rollback kan niet ongedaan worden gemaakt"))
325 }
326 return s.startRollback(name)
327}
328
329// startRollback start een rollback op de achtergrond.
330func (s *Server) startRollback(name string) (int, any) {
331 if _, err := s.archives.Path(name); err != nil {
332 return 404, errBody(err)
333 }
334 if !s.getState().Connected() {
335 return 409, errBody(errors.New("geen BlueGit gekoppeld"))
336 }
337 if c, p := s.compat(); c != "" && c != protocol.CompatOK {
338 return 409, errBody(fmt.Errorf("%w: %s", ErrIncompatible, compatMessage(c, p)))
339 }
340 s.mu.Lock()
341 busy := s.rollback.State == "running"
342 if !busy {
343 s.rollback = RollbackStatus{State: "running", Archive: name, At: s.now().UTC()}
344 }
345 s.mu.Unlock()
346 if busy {
347 return 409, errBody(errors.New("er loopt al een rollback"))
348 }
349 s.Log.Warn("rollback gestart", "archive", name)
350 go func() {
351 if err := s.Rollback(context.Background(), name); err != nil {
352 s.Log.Error("rollback mislukt", "archive", name, "err", err)
353 }
354 }()
355 return http.StatusAccepted, map[string]string{"state": "running", "archive": name}
356}
357
358// ---------- HTTP ----------
359
360// Handler is de webinterface en de HTTP-API.
361func (s *Server) Handler() http.Handler {
362 mux := http.NewServeMux()
363 mux.HandleFunc("GET /healthz", func(w http.ResponseWriter, r *http.Request) { _, _ = w.Write([]byte("ok\n")) })
364 // Van BlueGit, ondertekend (vaste protocolroutes).
365 mux.HandleFunc("POST /api/v1/notify", s.signed(s.apiNotify))
366 mux.HandleFunc("GET /api/v1/archives", s.signed(s.apiArchives))
367 mux.HandleFunc("GET /api/v1/status", s.signed(s.apiStatus))
368 mux.HandleFunc("POST /api/v1/rollback", s.signed(s.apiRollback))
369 // Beheer: admin.token, een sessie van de webinterface, of BlueGit.
370 for _, a := range s.Actions() {
371 mux.HandleFunc(a.Method+" "+a.Path, s.apiAction(a))
372 }
373 s.mountUI(mux)
374 return securityHeaders(mux)
375}
376
377func securityHeaders(h http.Handler) http.Handler {
378 return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
379 protocol.SetOwnHeaders(w.Header(), Version)
380 w.Header().Set("X-Content-Type-Options", "nosniff")
381 w.Header().Set("Referrer-Policy", "same-origin")
382 h.ServeHTTP(w, r)
383 })
384}
385
386// apiAction voert een actie uit voor de API.
387func (s *Server) apiAction(a Action) http.HandlerFunc {
388 return func(w http.ResponseWriter, r *http.Request) {
389 body, err := io.ReadAll(io.LimitReader(r.Body, 1<<20))
390 if err != nil {
391 writeErr(w, 400, "body")
392 return
393 }
394 if code, msg := s.authorize(r, a, body); code != 0 {
395 writeErr(w, code, msg)
396 return
397 }
398 in, err := parseInput(r, body)
399 if err != nil {
400 writeErr(w, 400, err.Error())
401 return
402 }
403 for _, p := range a.Params {
404 in[p] = r.PathValue(p)
405 }
406 code, out := a.Do(r.Context(), in)
407 if f, ok := out.(fileResult); ok {
408 w.Header().Set("Content-Type", "application/gzip")
409 w.Header().Set("Content-Disposition", fmt.Sprintf("attachment; filename=%q", f.name))
410 http.ServeFile(w, r, f.path)
411 return
412 }
413 writeJSON(w, code, out)
414 }
415}
416
417// authorize: 0 is toegestaan, anders de foutcode.
418func (s *Server) authorize(r *http.Request, a Action, body []byte) (int, string) {
419 if tok, ok := strings.CutPrefix(r.Header.Get("Authorization"), "Bearer "); ok {
420 if subtle.ConstantTimeCompare([]byte(strings.TrimSpace(tok)), []byte(s.adminToken)) == 1 {
421 return 0, ""
422 }
423 return 401, "ongeldig token"
424 }
425 if r.Header.Get(protocol.HeaderSignature) != "" {
426 if !a.Signed {
427 return 403, "BlueGit mag dit niet"
428 }
429 st := s.getState()
430 if !st.Connected() {
431 return 401, "niet gekoppeld"
432 }
433 if r.Header.Get(protocol.HeaderInstance) != st.InstanceID {
434 return 401, "andere BlueGit-instantie"
435 }
436 if err := protocol.Verify(r, protocol.SigningSecret(st.Key), body, s.now()); err != nil {
437 return 401, err.Error()
438 }
439 p, _ := protocol.BlueGitFromHeader(r.Header)
440 s.setBlueGit(p)
441 return 0, ""
442 }
443 if sess, ok := s.session(r); ok {
444 if r.Method != http.MethodGet && r.Method != http.MethodHead {
445 if subtle.ConstantTimeCompare([]byte(r.Header.Get("X-CSRF-Token")), []byte(sess.csrf)) != 1 {
446 return 403, "X-CSRF-Token ontbreekt of klopt niet"
447 }
448 }
449 return 0, ""
450 }
451 return 401, "admin.token, sessie of BlueGit-handtekening nodig"
452}
453
454// parseInput leest de querystring en een JSON-object (waarden als tekst).
455func parseInput(r *http.Request, body []byte) (Input, error) {
456 in := Input{}
457 for k, v := range r.URL.Query() {
458 if len(v) > 0 {
459 in[k] = v[0]
460 }
461 }
462 if len(strings.TrimSpace(string(body))) == 0 {
463 return in, nil
464 }
465 var raw map[string]any
466 if err := json.Unmarshal(body, &raw); err != nil {
467 return nil, errors.New("ongeldige JSON: verwacht een object")
468 }
469 for k, v := range raw {
470 switch t := v.(type) {
471 case string:
472 in[k] = t
473 case float64:
474 in[k] = strconv.FormatFloat(t, 'f', -1, 64)
475 case bool:
476 in[k] = strconv.FormatBool(t)
477 case nil:
478 in[k] = ""
479 default:
480 return nil, fmt.Errorf("veld %s: verwacht tekst, getal of boolean", k)
481 }
482 }
483 return in, nil
484}