BlueGit

timfa bluegit

Files

bluegit / internal / server / backup.go

backup.go

backup.go 23.7 KiB Download Raw
1package server
2
3import (
4 "context"
5 "encoding/json"
6 "errors"
7 "io"
8 "net/http"
9 "net/url"
10 "os"
11 "strconv"
12 "strings"
13 "sync/atomic"
14 "time"
15
16 "gitlab.com/Timfa/bluegit/internal/backup"
17 "gitlab.com/Timfa/bluegit/internal/i18n"
18)
19
20// Beheer > Backup: een of meer losse backup servers (repo bluegit-backup)
21// halen elk met een eigen Backupserver-Key alle gegevens op, krijgen een
22// melding bij elke wijziging, en kunnen een archief terugsturen (rollback).
23// Vanuit BlueGit is elke backup server ook te bedienen: BlueGit stuurt
24// ondertekende verzoeken naar de beheer-API van de backup server. Het
25// protocol staat in docs/BACKUP.md.
26
27// maxRestoreBytes begrenst een terug te zetten archief (64 GiB).
28const maxRestoreBytes = 64 << 30
29
30var (
31 restoreBusy atomic.Bool
32 backupFails updateLimiter
33)
34
35// BackupView is de stand op Beheer > Backup.
36type BackupView struct {
37 InstanceID string
38 Servers []backup.Conn
39 Max int
40 // Current is de geopende backup server (detailpagina).
41 Current *BackupServerView
42 NewKey string
43}
44
45// BackupServerView is één backup server met wat hij zelf meldt.
46type BackupServerView struct {
47 Conn backup.Conn
48 Remote *backup.RemoteStatus
49 Archives []backup.Archive
50 Config *backup.RemoteConfig
51 RemoteErr string
52}
53
54// BackupCompatIssue is een backup server die niet bij deze BlueGit past.
55// Beheerders zien hem als banner bovenaan elke pagina.
56type BackupCompatIssue struct {
57 ID, Name string
58 // BlueGitTooOld: BlueGit moet geüpdatet worden; anders de backup server.
59 BlueGitTooOld bool
60 // Protocol en Min van BlueGit en van de backup server.
61 Protocol, Min, PeerProtocol, PeerMin int
62 PeerVersion string
63}
64
65// backupCompatIssues leest backup.json (geen netwerk).
66func (s *Server) backupCompatIssues() []BackupCompatIssue {
67 if s.StateDir == "" {
68 return nil
69 }
70 s.backupInit()
71 list, err := s.backupMgr.List()
72 if err != nil {
73 return nil
74 }
75 var out []BackupCompatIssue
76 for _, c := range list {
77 if !c.Incompatible() {
78 continue
79 }
80 min := c.PeerMinProtocol
81 if min == 0 {
82 min = 1
83 }
84 out = append(out, BackupCompatIssue{
85 ID: c.ID, Name: c.Name, BlueGitTooOld: c.Compat() == backup.CompatBlueGitTooOld,
86 Protocol: backup.Protocol(), Min: backup.MinProtocol(), PeerProtocol: c.PeerProtocol, PeerMin: min, PeerVersion: c.PeerVersion,
87 })
88 }
89 return out
90}
91
92func (s *Server) backupInit() {
93 s.backupOnce.Do(func() {
94 s.backupMgr = &backup.Manager{Dir: s.StateDir}
95 s.backupHTTP = &http.Client{Timeout: 15 * time.Second}
96 s.backupNote = &backup.Notifier{Client: s.backupClient()}
97 })
98}
99
100func (s *Server) backupClient() *backup.Client {
101 return &backup.Client{Manager: s.backupMgr, HTTP: s.backupHTTP}
102}
103
104// BackupManager geeft de koppeling (ook voor tests).
105func (s *Server) BackupManager() *backup.Manager {
106 s.backupInit()
107 return s.backupMgr
108}
109
110// BackupChanged meldt een wijziging aan de gekoppelde backup server.
111func (s *Server) BackupChanged() {
112 if s.StateDir == "" {
113 return
114 }
115 s.backupInit()
116 s.backupNote.Changed()
117}
118
119func (s *Server) backupTree(conn string) backup.Tree {
120 return backup.Tree{
121 StateDir: s.StateDir, DataDir: s.StoragePath(), Conn: conn,
122 Snapshot: func(dst string) error { return s.Store.Snapshot(context.Background(), dst) },
123 }
124}
125
126func (s *Server) mountBackup(mux *http.ServeMux) {
127 mux.HandleFunc("GET /api/v1/backup/info", s.backupKeyed(s.backupInfo))
128 mux.HandleFunc("POST /api/v1/backup/connect", s.backupKeyed(s.backupConnect))
129 mux.HandleFunc("GET /api/v1/backup/manifest", s.backupKeyed(s.backupCompatible(s.backupManifest)))
130 mux.HandleFunc("GET /api/v1/backup/file", s.backupKeyed(s.backupCompatible(s.backupFile)))
131 mux.HandleFunc("POST /api/v1/backup/restore", s.backupKeyed(s.backupCompatible(s.backupRestore)))
132 mux.HandleFunc("GET /admin/backup", s.adminBackup)
133 mux.HandleFunc("POST /admin/backup/servers", s.adminBackupAdd)
134 mux.HandleFunc("GET /admin/backup/s/{id}", s.adminBackupServer)
135 mux.HandleFunc("POST /admin/backup/s/{id}/key", s.adminBackupKey)
136 mux.HandleFunc("POST /admin/backup/s/{id}/rename", s.adminBackupRename)
137 mux.HandleFunc("POST /admin/backup/s/{id}/remove", s.adminBackupRemove)
138 mux.HandleFunc("POST /admin/backup/s/{id}/act/{name}", s.adminBackupAct)
139}
140
141// backupWatch meldt na elk schrijvend verzoek een wijziging. De backup
142// server haalt daarna alleen op wat veranderd is; een melding te veel kost
143// dus weinig. Tijdens het terugzetten van een backup wordt niet geschreven.
144func (s *Server) backupWatch(next http.Handler) http.Handler {
145 return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
146 switch r.Method {
147 case http.MethodGet, http.MethodHead, http.MethodOptions:
148 next.ServeHTTP(w, r)
149 return
150 }
151 if restoreBusy.Load() {
152 http.Error(w, "backup wordt teruggezet; BlueGit herstart zo\n", http.StatusServiceUnavailable)
153 return
154 }
155 next.ServeHTTP(w, r)
156 if strings.HasPrefix(r.URL.Path, "/api/v1/backup/") || strings.HasSuffix(r.URL.Path, "/git-upload-pack") {
157 return
158 }
159 s.BackupChanged()
160 })
161}
162
163func backupErr(w http.ResponseWriter, code int, msg string) {
164 writeJSON(w, code, map[string]string{"error": msg})
165}
166
167// backupKeyed eist de Backupserver-Key als bearer-token.
168func (s *Server) backupKeyed(h func(http.ResponseWriter, *http.Request)) http.HandlerFunc {
169 return func(w http.ResponseWriter, r *http.Request) {
170 w.Header().Set("Cache-Control", "no-store")
171 backup.SetOwnHeaders(w.Header())
172 if s.StateDir == "" {
173 backupErr(w, http.StatusNotFound, "backup niet beschikbaar")
174 return
175 }
176 s.backupInit()
177 conn, ok := s.backupMgr.Check(bearer(r))
178 if !ok {
179 // Alleen mislukte pogingen tellen: hoogstens 5 per minuut per IP.
180 if !backupFails.allow(clientIP(r), time.Now()) {
181 backupErr(w, http.StatusTooManyRequests, "te veel mislukte pogingen")
182 return
183 }
184 backupErr(w, http.StatusUnauthorized, "ongeldige Backupserver-Key")
185 return
186 }
187 s.backupMgr.Seen(conn.ID)
188 // Zonder koppen is het een backup server van vóór de
189 // protocolversie: protocol 1.
190 peer, _ := backup.PeerFromHeader(r.Header)
191 s.backupMgr.SetPeer(conn.ID, peer)
192 if c, ok := s.backupMgr.Get(conn.ID); ok {
193 conn = c
194 }
195 h(w, r.WithContext(context.WithValue(r.Context(), backupConnKey{}, conn)))
196 }
197}
198
199// backupCompatible weigert gegevens uit te wisselen met een backup server
200// die niet bij deze BlueGit past (426, met wie er geüpdatet moet worden).
201// info en connect blijven werken, zodat beide kanten het kunnen melden.
202func (s *Server) backupCompatible(h func(http.ResponseWriter, *http.Request)) func(http.ResponseWriter, *http.Request) {
203 return func(w http.ResponseWriter, r *http.Request) {
204 c := backupConnOf(r)
205 if res := c.Compat(); res == backup.CompatBlueGitTooOld || res == backup.CompatBackupTooOld {
206 msg := "backup server te oud voor deze BlueGit; update de backup server"
207 if res == backup.CompatBlueGitTooOld {
208 msg = "BlueGit te oud voor deze backup server; update BlueGit"
209 }
210 writeJSON(w, http.StatusUpgradeRequired, map[string]any{
211 "error": msg, "compat": res, "protocol": backup.Protocol(), "min_protocol": backup.MinProtocol(),
212 })
213 return
214 }
215 h(w, r)
216 }
217}
218
219type backupConnKey struct{}
220
221func backupConnOf(r *http.Request) backup.Conn {
222 c, _ := r.Context().Value(backupConnKey{}).(backup.Conn)
223 return c
224}
225
226func (s *Server) backupInfo(w http.ResponseWriter, r *http.Request) {
227 id, err := s.backupMgr.InstanceID()
228 if err != nil {
229 backupErr(w, 500, err.Error())
230 return
231 }
232 c := backupConnOf(r)
233 writeJSON(w, http.StatusOK, map[string]any{
234 "instance_id": id, "base_url": s.Cfg.BaseURL, "name": c.Name, "server_url": c.ServerURL, "server_id": c.ServerID,
235 "has_storage": s.StoragePath() != "",
236 "protocol": backup.Protocol(), "min_protocol": backup.MinProtocol(), "version": backup.Version(),
237 "compat": c.Compat(),
238 })
239}
240
241func (s *Server) backupConnect(w http.ResponseWriter, r *http.Request) {
242 var in struct {
243 ServerURL string `json:"server_url"`
244 ServerID string `json:"server_id"`
245 }
246 if err := json.NewDecoder(io.LimitReader(r.Body, 1<<16)).Decode(&in); err != nil {
247 backupErr(w, 400, "ongeldige JSON")
248 return
249 }
250 u, err := url.Parse(strings.TrimSpace(in.ServerURL))
251 if err != nil || (u.Scheme != "http" && u.Scheme != "https") || u.Host == "" {
252 backupErr(w, 400, "server_url moet een http(s)-adres zijn")
253 return
254 }
255 c, err := s.backupMgr.Connect(backupConnOf(r).ID, u.String(), strings.TrimSpace(in.ServerID))
256 if err != nil {
257 backupErr(w, 500, err.Error())
258 return
259 }
260 id, _ := s.backupMgr.InstanceID()
261 if s.Log != nil {
262 s.Log.Info("backup audit", "action", "connect", "id", c.ID, "name", c.Name, "server", c.ServerURL, "server_id", c.ServerID)
263 }
264 writeJSON(w, http.StatusOK, map[string]any{"instance_id": id, "server_url": c.ServerURL})
265}
266
267func (s *Server) backupManifest(w http.ResponseWriter, r *http.Request) {
268 id, err := s.backupMgr.InstanceID()
269 if err != nil {
270 backupErr(w, 500, err.Error())
271 return
272 }
273 m, err := s.backupTree(backupConnOf(r).ID).Build(id)
274 if err != nil {
275 backupErr(w, 500, err.Error())
276 return
277 }
278 writeJSON(w, http.StatusOK, m)
279}
280
281func (s *Server) backupFile(w http.ResponseWriter, r *http.Request) {
282 real, err := s.backupTree(backupConnOf(r).ID).Resolve(r.URL.Query().Get("path"))
283 if err != nil {
284 backupErr(w, http.StatusNotFound, "bestand niet gevonden")
285 return
286 }
287 f, err := os.Open(real)
288 if err != nil {
289 backupErr(w, http.StatusNotFound, "bestand niet gevonden")
290 return
291 }
292 defer f.Close()
293 fi, err := f.Stat()
294 if err != nil {
295 backupErr(w, 500, err.Error())
296 return
297 }
298 w.Header().Set("Content-Type", "application/octet-stream")
299 w.Header().Set("Content-Length", strconv.FormatInt(fi.Size(), 10))
300 w.Header().Set("X-Backup-Mtime", strconv.FormatInt(fi.ModTime().UnixMilli(), 10))
301 _, _ = io.Copy(w, f)
302}
303
304// backupRestore neemt een tar.gz aan, pakt het naast de live gegevens uit
305// en herstart BlueGit. Bij de start komt de backup op zijn plek.
306func (s *Server) backupRestore(w http.ResponseWriter, r *http.Request) {
307 if !s.restoring.TryLock() {
308 backupErr(w, http.StatusConflict, "er loopt al een restore")
309 return
310 }
311 defer s.restoring.Unlock()
312 restoreBusy.Store(true)
313 n, err := s.backupTree("").Stage(http.MaxBytesReader(w, r.Body, maxRestoreBytes))
314 if err != nil {
315 restoreBusy.Store(false)
316 if s.Log != nil {
317 s.Log.Warn("backup audit", "action", "restore_failed", "err", err)
318 }
319 backupErr(w, http.StatusBadRequest, err.Error())
320 return
321 }
322 if s.Log != nil {
323 s.Log.Warn("backup audit", "action", "restore_staged", "files", n, "id", backupConnOf(r).ID, "name", backupConnOf(r).Name)
324 }
325 writeJSON(w, http.StatusAccepted, map[string]any{"files": n, "restarting": s.RequestRestart != nil})
326 if f, ok := w.(http.Flusher); ok {
327 f.Flush()
328 }
329 if s.RequestRestart != nil {
330 go func() {
331 time.Sleep(300 * time.Millisecond)
332 s.RequestRestart()
333 }()
334 }
335}
336
337// ---------- Beheer > Backup ----------
338
339func (s *Server) backupList() *BackupView {
340 s.backupInit()
341 bv := &BackupView{Max: backup.MaxServers}
342 bv.Servers, _ = s.backupMgr.List()
343 bv.InstanceID, _ = s.backupMgr.InstanceID()
344 return bv
345}
346
347// backupServerView vraagt status, archieven en instellingen op bij de
348// backup server.
349func (s *Server) backupServerView(ctx context.Context, conn backup.Conn) *BackupServerView {
350 v := &BackupServerView{Conn: conn}
351 if !conn.Connected() {
352 return v
353 }
354 ctx, cancel := context.WithTimeout(ctx, 8*time.Second)
355 defer cancel()
356 // De antwoorden kunnen een nieuw protocol gemeld hebben.
357 defer func() {
358 if fresh, ok := s.backupMgr.Get(conn.ID); ok {
359 v.Conn = fresh
360 }
361 }()
362 c := s.backupClient()
363 st, err := c.Status(ctx, conn)
364 if err != nil {
365 v.RemoteErr = err.Error()
366 return v
367 }
368 v.Remote = &st
369 if arch, err := c.Archives(ctx, conn); err == nil {
370 v.Archives = arch
371 } else {
372 v.RemoteErr = err.Error()
373 }
374 if cfg, err := c.Config(ctx, conn); err == nil {
375 v.Config = &cfg
376 } else if v.RemoteErr == "" {
377 v.RemoteErr = err.Error()
378 }
379 return v
380}
381
382func (s *Server) adminBackup(w http.ResponseWriter, r *http.Request) {
383 if ok, _ := s.adminOnly(w, r); !ok {
384 return
385 }
386 v := s.view(w, r, "title.admin")
387 v.Page = "adminbackup"
388 v.Backup = s.backupList()
389 s.render(w, "adminbackup", v)
390}
391
392func (s *Server) backupConnFromPath(w http.ResponseWriter, r *http.Request) (backup.Conn, bool) {
393 s.backupInit()
394 c, ok := s.backupMgr.Get(r.PathValue("id"))
395 if !ok {
396 http.NotFound(w, r)
397 }
398 return c, ok
399}
400
401func backupPath(id string) string { return "/admin/backup/s/" + url.PathEscape(id) }
402
403func (s *Server) adminBackupServer(w http.ResponseWriter, r *http.Request) {
404 if ok, _ := s.adminOnly(w, r); !ok {
405 return
406 }
407 conn, ok := s.backupConnFromPath(w, r)
408 if !ok {
409 return
410 }
411 v := s.view(w, r, "title.admin")
412 v.Page = "adminbackupserver"
413 v.Backup = s.backupList()
414 v.Backup.Current = s.backupServerView(r.Context(), conn)
415 if c, err := r.Cookie("bluegit_backup_key"); err == nil && c.Value != "" {
416 v.Backup.NewKey = c.Value
417 http.SetCookie(w, &http.Cookie{Name: "bluegit_backup_key", Value: "", Path: backupPath(conn.ID), MaxAge: -1})
418 }
419 s.render(w, "adminbackup", v)
420}
421
422// showKeyOnce zet de nieuwe key in een kort, HttpOnly cookie dat alleen de
423// pagina van die backup server leest.
424func (s *Server) showKeyOnce(w http.ResponseWriter, id, key string) {
425 http.SetCookie(w, &http.Cookie{
426 Name: "bluegit_backup_key", Value: key, Path: backupPath(id), MaxAge: 60, HttpOnly: true,
427 SameSite: http.SameSiteStrictMode, Secure: strings.HasPrefix(s.Cfg.BaseURL, "https://"),
428 })
429}
430
431func (s *Server) backupAudit(action, by string, kv ...any) {
432 if s.Log != nil {
433 s.Log.Info("backup audit", append([]any{"action", action, "by", by}, kv...)...)
434 }
435}
436
437func (s *Server) adminBackupAdd(w http.ResponseWriter, r *http.Request) {
438 if ok, _ := s.adminOnly(w, r); !ok || !s.csrfOK(w, r) {
439 return
440 }
441 s.backupInit()
442 by := s.who(r).User.Username
443 key, c, err := s.backupMgr.Add(r.FormValue("name"), by)
444 if err != nil {
445 s.redirect(w, r, "/admin/backup", "", s.backupErrText(r, err))
446 return
447 }
448 s.backupAudit("add", by, "id", c.ID, "name", c.Name)
449 s.showKeyOnce(w, c.ID, key)
450 s.redirect(w, r, backupPath(c.ID), s.tr(r, "backup.ok.key"), "")
451}
452
453func (s *Server) backupErrText(r *http.Request, err error) string {
454 switch {
455 case errors.Is(err, backup.ErrTooMany):
456 return s.tr(r, "backup.err.tooMany", backup.MaxServers)
457 case errors.Is(err, backup.ErrUnknown):
458 return s.tr(r, "backup.err.unknown")
459 }
460 return s.trErr(r, unwrapFail(err))
461}
462
463func (s *Server) adminBackupKey(w http.ResponseWriter, r *http.Request) {
464 if ok, _ := s.adminOnly(w, r); !ok || !s.csrfOK(w, r) {
465 return
466 }
467 conn, ok := s.backupConnFromPath(w, r)
468 if !ok {
469 return
470 }
471 by := s.who(r).User.Username
472 key, _, err := s.backupMgr.RotateKey(conn.ID, by)
473 if err != nil {
474 s.redirect(w, r, backupPath(conn.ID), "", s.backupErrText(r, err))
475 return
476 }
477 s.backupAudit("new_key", by, "id", conn.ID, "name", conn.Name)
478 s.showKeyOnce(w, conn.ID, key)
479 s.redirect(w, r, backupPath(conn.ID), s.tr(r, "backup.ok.key"), "")
480}
481
482func (s *Server) adminBackupRename(w http.ResponseWriter, r *http.Request) {
483 if ok, _ := s.adminOnly(w, r); !ok || !s.csrfOK(w, r) {
484 return
485 }
486 conn, ok := s.backupConnFromPath(w, r)
487 if !ok {
488 return
489 }
490 if _, err := s.backupMgr.Rename(conn.ID, r.FormValue("name")); err != nil {
491 s.redirect(w, r, backupPath(conn.ID), "", s.backupErrText(r, err))
492 return
493 }
494 s.redirect(w, r, backupPath(conn.ID), s.tr(r, "backup.ok.renamed"), "")
495}
496
497// removeBackupServer laat de backup server ontkoppelen (als hij bereikbaar
498// is) en vergeet hem daarna.
499func (s *Server) removeBackupServer(ctx context.Context, by string, conn backup.Conn) error {
500 if conn.Connected() {
501 ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
502 _, _, _ = s.backupClient().Call(ctx, conn, http.MethodPost, "/api/v1/admin/disconnect", map[string]any{})
503 cancel()
504 }
505 if err := s.backupMgr.Remove(conn.ID); err != nil {
506 return err
507 }
508 s.backupTree(conn.ID).RemoveSnapshot()
509 s.backupAudit("remove", by, "id", conn.ID, "name", conn.Name)
510 return nil
511}
512
513func (s *Server) adminBackupRemove(w http.ResponseWriter, r *http.Request) {
514 if ok, _ := s.adminOnly(w, r); !ok || !s.csrfOK(w, r) {
515 return
516 }
517 conn, ok := s.backupConnFromPath(w, r)
518 if !ok {
519 return
520 }
521 if err := s.removeBackupServer(r.Context(), s.who(r).User.Username, conn); err != nil {
522 s.redirect(w, r, backupPath(conn.ID), "", s.backupErrText(r, err))
523 return
524 }
525 s.redirect(w, r, "/admin/backup", s.tr(r, "backup.ok.revoked"), "")
526}
527
528// backupAction voert een beheeractie van de backup server uit. BlueGit kent
529// de acties niet vooraf: de backup server noemt ze (GET /api/v1/admin/actions),
530// zodat alles wat zijn eigen webinterface kan, ook hier kan.
531func (s *Server) backupAction(ctx context.Context, by string, conn backup.Conn, name string, in map[string]any) (int, []byte, error) {
532 if !conn.Connected() {
533 return 0, nil, fail(409, i18n.E("backup.err.none"))
534 }
535 ctx, cancel := context.WithTimeout(ctx, 60*time.Second)
536 defer cancel()
537 c := s.backupClient()
538 actions, err := c.Actions(ctx, conn)
539 if err != nil {
540 return 0, nil, fail(502, err)
541 }
542 var act *backup.RemoteAction
543 for i := range actions {
544 if actions[i].Name == name && actions[i].Signed {
545 act = &actions[i]
546 }
547 }
548 if act == nil {
549 return 0, nil, fail(404, i18n.E("backup.err.action"))
550 }
551 str := func(k string) string {
552 v, _ := in[k].(string)
553 return strings.TrimSpace(v)
554 }
555 if name == "rollback" {
556 if str("archive") == "" {
557 return 0, nil, fail(400, i18n.E("backup.err.archive"))
558 }
559 if str("confirm") != str("archive") {
560 return 0, nil, fail(400, i18n.E("backup.err.confirm"))
561 }
562 }
563 if name == "sync" {
564 if _, ok := in["wait"]; !ok {
565 in["wait"] = "false"
566 }
567 }
568 p := act.Path
569 for _, param := range act.Params {
570 v := str(param)
571 if v == "" {
572 return 0, nil, fail(400, i18n.E("backup.err.archive"))
573 }
574 p = strings.ReplaceAll(p, "{"+param+"}", url.PathEscape(v))
575 delete(in, param)
576 }
577 var body any
578 if act.Method != http.MethodGet {
579 body = in
580 }
581 hc := *s.backupHTTP
582 hc.Timeout = 60 * time.Second
583 cl := *c
584 cl.HTTP = &hc
585 code, raw, err := cl.Call(ctx, conn, act.Method, p, body)
586 if err != nil {
587 return 0, nil, fail(502, err)
588 }
589 if act.Method != http.MethodGet {
590 kv := []any{"id", conn.ID, "name", conn.Name, "remote_action", name, "status", code}
591 if a := str("archive"); a != "" {
592 kv = append(kv, "archive", a)
593 }
594 if s.Log != nil && name == "rollback" {
595 s.Log.Warn("backup audit", append([]any{"action", "rollback", "by", by}, kv...)...)
596 } else {
597 s.backupAudit("remote", by, kv...)
598 }
599 }
600 return code, raw, nil
601}
602
603func (s *Server) adminBackupAct(w http.ResponseWriter, r *http.Request) {
604 if ok, _ := s.adminOnly(w, r); !ok || !s.csrfOK(w, r) {
605 return
606 }
607 conn, ok := s.backupConnFromPath(w, r)
608 if !ok {
609 return
610 }
611 back := backupPath(conn.ID)
612 name := r.PathValue("name")
613 if name == "rollback" && r.FormValue("understood") != "1" {
614 s.redirect(w, r, back, "", s.tr(r, "backup.err.understood"))
615 return
616 }
617 in := map[string]any{}
618 _ = r.ParseForm()
619 for k, v := range r.PostForm {
620 if k == "csrf" || k == "understood" || len(v) == 0 {
621 continue
622 }
623 in[k] = v[0]
624 }
625 code, raw, err := s.backupAction(r.Context(), s.who(r).User.Username, conn, name, in)
626 if err != nil {
627 s.redirect(w, r, back, "", s.backupErrText(r, err))
628 return
629 }
630 if code >= 300 {
631 var e struct {
632 Error string `json:"error"`
633 }
634 _ = json.Unmarshal(raw, &e)
635 if e.Error == "" {
636 e.Error = http.StatusText(code)
637 }
638 s.redirect(w, r, back, "", s.tr(r, "backup.err.remote", e.Error))
639 return
640 }
641 msg := s.tr(r, "backup.ok.action")
642 if name == "rollback" {
643 msg = s.tr(r, "backup.ok.rollback", in["archive"])
644 }
645 s.redirect(w, r, back, msg, "")
646}
647
648// ---------- API voor beheerders ----------
649
650func backupConnJSON(c backup.Conn) map[string]any {
651 out := map[string]any{
652 "id": c.ID, "name": c.Name, "key_hint": c.KeyHint, "created_at": rfcTime(c.CreatedAt), "created_by": c.CreatedBy,
653 "connected": c.Connected(), "server_url": c.ServerURL, "server_id": c.ServerID,
654 }
655 if c.Connected() {
656 out["connected_at"] = rfcTime(c.ConnectedAt)
657 out["last_seen"] = rfcTime(c.LastSeen)
658 }
659 // compat: "" (nog onbekend), ok, bluegit_too_old of backup_too_old.
660 out["compat"] = c.Compat()
661 out["protocol"] = map[string]any{
662 "bluegit": backup.Protocol(), "bluegit_min": backup.MinProtocol(),
663 "backup": c.PeerProtocol, "backup_min": c.PeerMinProtocol, "backup_version": c.PeerVersion,
664 }
665 return out
666}
667
668func (s *Server) apiBackupAdmin(w http.ResponseWriter, r *http.Request) bool {
669 if !apiUser(r).InstanceAdmin {
670 s.writeAPIErr(w, r, fail(403, i18n.E("err.forbidden")))
671 return false
672 }
673 s.backupInit()
674 return true
675}
676
677func (s *Server) apiBackupConn(w http.ResponseWriter, r *http.Request) (backup.Conn, bool) {
678 if !s.apiBackupAdmin(w, r) {
679 return backup.Conn{}, false
680 }
681 c, ok := s.backupMgr.Get(r.PathValue("id"))
682 if !ok {
683 s.writeAPIErr(w, r, fail(404, i18n.E("backup.err.unknown")))
684 }
685 return c, ok
686}
687
688func (s *Server) apiAdminBackup(w http.ResponseWriter, r *http.Request) {
689 if !s.apiBackupAdmin(w, r) {
690 return
691 }
692 bv := s.backupList()
693 servers := make([]map[string]any, 0, len(bv.Servers))
694 for _, c := range bv.Servers {
695 servers = append(servers, backupConnJSON(c))
696 }
697 writeJSON(w, http.StatusOK, map[string]any{"instance_id": bv.InstanceID, "max_servers": bv.Max, "servers": servers})
698}
699
700func (s *Server) apiAdminBackupAdd(w http.ResponseWriter, r *http.Request) {
701 if !s.apiBackupAdmin(w, r) {
702 return
703 }
704 var in struct {
705 Name string `json:"name"`
706 }
707 _ = readJSON(r, &in)
708 by := apiUser(r).Username
709 key, c, err := s.backupMgr.Add(in.Name, by)
710 if errors.Is(err, backup.ErrTooMany) {
711 s.writeAPIErr(w, r, fail(409, err))
712 return
713 }
714 if err != nil {
715 s.writeAPIErr(w, r, fail(500, err))
716 return
717 }
718 s.backupAudit("add", by, "id", c.ID, "name", c.Name)
719 out := backupConnJSON(c)
720 out["key"] = key
721 writeJSON(w, http.StatusCreated, out)
722}
723
724func (s *Server) apiAdminBackupServer(w http.ResponseWriter, r *http.Request) {
725 c, ok := s.apiBackupConn(w, r)
726 if !ok {
727 return
728 }
729 v := s.backupServerView(r.Context(), c)
730 out := backupConnJSON(v.Conn)
731 out["archives"] = v.Archives
732 if v.Archives == nil {
733 out["archives"] = []backup.Archive{}
734 }
735 if v.Remote != nil {
736 out["remote"] = v.Remote
737 }
738 if v.Config != nil {
739 out["config"] = v.Config
740 }
741 out["remote_error"] = v.RemoteErr
742 writeJSON(w, http.StatusOK, out)
743}
744
745func (s *Server) apiAdminBackupRename(w http.ResponseWriter, r *http.Request) {
746 c, ok := s.apiBackupConn(w, r)
747 if !ok {
748 return
749 }
750 var in struct {
751 Name string `json:"name"`
752 }
753 if err := readJSON(r, &in); err != nil {
754 s.writeAPIErr(w, r, fail(400, err))
755 return
756 }
757 c, err := s.backupMgr.Rename(c.ID, in.Name)
758 if err != nil {
759 s.writeAPIErr(w, r, fail(400, err))
760 return
761 }
762 writeJSON(w, http.StatusOK, backupConnJSON(c))
763}
764
765func (s *Server) apiAdminBackupKey(w http.ResponseWriter, r *http.Request) {
766 c, ok := s.apiBackupConn(w, r)
767 if !ok {
768 return
769 }
770 by := apiUser(r).Username
771 key, c, err := s.backupMgr.RotateKey(c.ID, by)
772 if err != nil {
773 s.writeAPIErr(w, r, fail(500, err))
774 return
775 }
776 s.backupAudit("new_key", by, "id", c.ID, "name", c.Name)
777 out := backupConnJSON(c)
778 out["key"] = key
779 writeJSON(w, http.StatusCreated, out)
780}
781
782func (s *Server) apiAdminBackupRemove(w http.ResponseWriter, r *http.Request) {
783 c, ok := s.apiBackupConn(w, r)
784 if !ok {
785 return
786 }
787 if err := s.removeBackupServer(r.Context(), apiUser(r).Username, c); err != nil {
788 s.writeAPIErr(w, r, fail(500, err))
789 return
790 }
791 writeJSON(w, http.StatusNoContent, nil)
792}
793
794func (s *Server) apiAdminBackupAction(w http.ResponseWriter, r *http.Request) {
795 c, ok := s.apiBackupConn(w, r)
796 if !ok {
797 return
798 }
799 in := map[string]any{}
800 if r.ContentLength != 0 {
801 if err := readJSON(r, &in); err != nil {
802 s.writeAPIErr(w, r, fail(400, err))
803 return
804 }
805 }
806 code, raw, err := s.backupAction(r.Context(), apiUser(r).Username, c, r.PathValue("name"), in)
807 if err != nil {
808 s.writeAPIErr(w, r, err)
809 return
810 }
811 w.Header().Set("Content-Type", "application/json")
812 w.WriteHeader(code)
813 _, _ = w.Write(raw)
814}
815
816func unwrapFail(err error) error {
817 var oe interface{ Unwrap() error }
818 if errors.As(err, &oe) && oe.Unwrap() != nil {
819 return oe.Unwrap()
820 }
821 return err
822}