BlueGit

timfa bluegit

Files

bluegit / internal / server / backup.go

backup.go

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