BlueGit

timfa bluegit

Files

bluegit / internal / server / backup.go

backup.go

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