BlueGit

timfa bluegit

Files

bluegit / internal / server / backup.go

backup.go

backup.go 20.9 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(conn string) backup.Tree {
82 return backup.Tree{
83 StateDir: s.StateDir, DataDir: s.StoragePath(), Conn: conn,
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(backupConnOf(r).ID).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(backupConnOf(r).ID).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.backupTree(conn.ID).RemoveSnapshot()
435 s.backupAudit("remove", by, "id", conn.ID, "name", conn.Name)
436 return nil
437}
438
439func (s *Server) adminBackupRemove(w http.ResponseWriter, r *http.Request) {
440 if ok, _ := s.adminOnly(w, r); !ok || !s.csrfOK(w, r) {
441 return
442 }
443 conn, ok := s.backupConnFromPath(w, r)
444 if !ok {
445 return
446 }
447 if err := s.removeBackupServer(r.Context(), s.who(r).User.Username, conn); err != nil {
448 s.redirect(w, r, backupPath(conn.ID), "", s.backupErrText(r, err))
449 return
450 }
451 s.redirect(w, r, "/admin/backup", s.tr(r, "backup.ok.revoked"), "")
452}
453
454// backupAction voert een beheeractie van de backup server uit. BlueGit kent
455// de acties niet vooraf: de backup server noemt ze (GET /api/v1/admin/actions),
456// zodat alles wat zijn eigen webinterface kan, ook hier kan.
457func (s *Server) backupAction(ctx context.Context, by string, conn backup.Conn, name string, in map[string]any) (int, []byte, error) {
458 if !conn.Connected() {
459 return 0, nil, fail(409, i18n.E("backup.err.none"))
460 }
461 ctx, cancel := context.WithTimeout(ctx, 60*time.Second)
462 defer cancel()
463 c := s.backupClient()
464 actions, err := c.Actions(ctx, conn)
465 if err != nil {
466 return 0, nil, fail(502, err)
467 }
468 var act *backup.RemoteAction
469 for i := range actions {
470 if actions[i].Name == name && actions[i].Signed {
471 act = &actions[i]
472 }
473 }
474 if act == nil {
475 return 0, nil, fail(404, i18n.E("backup.err.action"))
476 }
477 str := func(k string) string {
478 v, _ := in[k].(string)
479 return strings.TrimSpace(v)
480 }
481 if name == "rollback" {
482 if str("archive") == "" {
483 return 0, nil, fail(400, i18n.E("backup.err.archive"))
484 }
485 if str("confirm") != str("archive") {
486 return 0, nil, fail(400, i18n.E("backup.err.confirm"))
487 }
488 }
489 if name == "sync" {
490 if _, ok := in["wait"]; !ok {
491 in["wait"] = "false"
492 }
493 }
494 p := act.Path
495 for _, param := range act.Params {
496 v := str(param)
497 if v == "" {
498 return 0, nil, fail(400, i18n.E("backup.err.archive"))
499 }
500 p = strings.ReplaceAll(p, "{"+param+"}", url.PathEscape(v))
501 delete(in, param)
502 }
503 var body any
504 if act.Method != http.MethodGet {
505 body = in
506 }
507 hc := *s.backupHTTP
508 hc.Timeout = 60 * time.Second
509 cl := *c
510 cl.HTTP = &hc
511 code, raw, err := cl.Call(ctx, conn, act.Method, p, body)
512 if err != nil {
513 return 0, nil, fail(502, err)
514 }
515 if act.Method != http.MethodGet {
516 kv := []any{"id", conn.ID, "name", conn.Name, "remote_action", name, "status", code}
517 if a := str("archive"); a != "" {
518 kv = append(kv, "archive", a)
519 }
520 if s.Log != nil && name == "rollback" {
521 s.Log.Warn("backup audit", append([]any{"action", "rollback", "by", by}, kv...)...)
522 } else {
523 s.backupAudit("remote", by, kv...)
524 }
525 }
526 return code, raw, nil
527}
528
529func (s *Server) adminBackupAct(w http.ResponseWriter, r *http.Request) {
530 if ok, _ := s.adminOnly(w, r); !ok || !s.csrfOK(w, r) {
531 return
532 }
533 conn, ok := s.backupConnFromPath(w, r)
534 if !ok {
535 return
536 }
537 back := backupPath(conn.ID)
538 name := r.PathValue("name")
539 if name == "rollback" && r.FormValue("understood") != "1" {
540 s.redirect(w, r, back, "", s.tr(r, "backup.err.understood"))
541 return
542 }
543 in := map[string]any{}
544 _ = r.ParseForm()
545 for k, v := range r.PostForm {
546 if k == "csrf" || k == "understood" || len(v) == 0 {
547 continue
548 }
549 in[k] = v[0]
550 }
551 code, raw, err := s.backupAction(r.Context(), s.who(r).User.Username, conn, name, in)
552 if err != nil {
553 s.redirect(w, r, back, "", s.backupErrText(r, err))
554 return
555 }
556 if code >= 300 {
557 var e struct {
558 Error string `json:"error"`
559 }
560 _ = json.Unmarshal(raw, &e)
561 if e.Error == "" {
562 e.Error = http.StatusText(code)
563 }
564 s.redirect(w, r, back, "", s.tr(r, "backup.err.remote", e.Error))
565 return
566 }
567 msg := s.tr(r, "backup.ok.action")
568 if name == "rollback" {
569 msg = s.tr(r, "backup.ok.rollback", in["archive"])
570 }
571 s.redirect(w, r, back, msg, "")
572}
573
574// ---------- API voor beheerders ----------
575
576func backupConnJSON(c backup.Conn) map[string]any {
577 out := map[string]any{
578 "id": c.ID, "name": c.Name, "key_hint": c.KeyHint, "created_at": rfcTime(c.CreatedAt), "created_by": c.CreatedBy,
579 "connected": c.Connected(), "server_url": c.ServerURL, "server_id": c.ServerID,
580 }
581 if c.Connected() {
582 out["connected_at"] = rfcTime(c.ConnectedAt)
583 out["last_seen"] = rfcTime(c.LastSeen)
584 }
585 return out
586}
587
588func (s *Server) apiBackupAdmin(w http.ResponseWriter, r *http.Request) bool {
589 if !apiUser(r).InstanceAdmin {
590 s.writeAPIErr(w, r, fail(403, i18n.E("err.forbidden")))
591 return false
592 }
593 s.backupInit()
594 return true
595}
596
597func (s *Server) apiBackupConn(w http.ResponseWriter, r *http.Request) (backup.Conn, bool) {
598 if !s.apiBackupAdmin(w, r) {
599 return backup.Conn{}, false
600 }
601 c, ok := s.backupMgr.Get(r.PathValue("id"))
602 if !ok {
603 s.writeAPIErr(w, r, fail(404, i18n.E("backup.err.unknown")))
604 }
605 return c, ok
606}
607
608func (s *Server) apiAdminBackup(w http.ResponseWriter, r *http.Request) {
609 if !s.apiBackupAdmin(w, r) {
610 return
611 }
612 bv := s.backupList()
613 servers := make([]map[string]any, 0, len(bv.Servers))
614 for _, c := range bv.Servers {
615 servers = append(servers, backupConnJSON(c))
616 }
617 writeJSON(w, http.StatusOK, map[string]any{"instance_id": bv.InstanceID, "max_servers": bv.Max, "servers": servers})
618}
619
620func (s *Server) apiAdminBackupAdd(w http.ResponseWriter, r *http.Request) {
621 if !s.apiBackupAdmin(w, r) {
622 return
623 }
624 var in struct {
625 Name string `json:"name"`
626 }
627 _ = readJSON(r, &in)
628 by := apiUser(r).Username
629 key, c, err := s.backupMgr.Add(in.Name, by)
630 if errors.Is(err, backup.ErrTooMany) {
631 s.writeAPIErr(w, r, fail(409, err))
632 return
633 }
634 if err != nil {
635 s.writeAPIErr(w, r, fail(500, err))
636 return
637 }
638 s.backupAudit("add", by, "id", c.ID, "name", c.Name)
639 out := backupConnJSON(c)
640 out["key"] = key
641 writeJSON(w, http.StatusCreated, out)
642}
643
644func (s *Server) apiAdminBackupServer(w http.ResponseWriter, r *http.Request) {
645 c, ok := s.apiBackupConn(w, r)
646 if !ok {
647 return
648 }
649 v := s.backupServerView(r.Context(), c)
650 out := backupConnJSON(c)
651 out["archives"] = v.Archives
652 if v.Archives == nil {
653 out["archives"] = []backup.Archive{}
654 }
655 if v.Remote != nil {
656 out["remote"] = v.Remote
657 }
658 if v.Config != nil {
659 out["config"] = v.Config
660 }
661 out["remote_error"] = v.RemoteErr
662 writeJSON(w, http.StatusOK, out)
663}
664
665func (s *Server) apiAdminBackupRename(w http.ResponseWriter, r *http.Request) {
666 c, ok := s.apiBackupConn(w, r)
667 if !ok {
668 return
669 }
670 var in struct {
671 Name string `json:"name"`
672 }
673 if err := readJSON(r, &in); err != nil {
674 s.writeAPIErr(w, r, fail(400, err))
675 return
676 }
677 c, err := s.backupMgr.Rename(c.ID, in.Name)
678 if err != nil {
679 s.writeAPIErr(w, r, fail(400, err))
680 return
681 }
682 writeJSON(w, http.StatusOK, backupConnJSON(c))
683}
684
685func (s *Server) apiAdminBackupKey(w http.ResponseWriter, r *http.Request) {
686 c, ok := s.apiBackupConn(w, r)
687 if !ok {
688 return
689 }
690 by := apiUser(r).Username
691 key, c, err := s.backupMgr.RotateKey(c.ID, by)
692 if err != nil {
693 s.writeAPIErr(w, r, fail(500, err))
694 return
695 }
696 s.backupAudit("new_key", by, "id", c.ID, "name", c.Name)
697 out := backupConnJSON(c)
698 out["key"] = key
699 writeJSON(w, http.StatusCreated, out)
700}
701
702func (s *Server) apiAdminBackupRemove(w http.ResponseWriter, r *http.Request) {
703 c, ok := s.apiBackupConn(w, r)
704 if !ok {
705 return
706 }
707 if err := s.removeBackupServer(r.Context(), apiUser(r).Username, c); err != nil {
708 s.writeAPIErr(w, r, fail(500, err))
709 return
710 }
711 writeJSON(w, http.StatusNoContent, nil)
712}
713
714func (s *Server) apiAdminBackupAction(w http.ResponseWriter, r *http.Request) {
715 c, ok := s.apiBackupConn(w, r)
716 if !ok {
717 return
718 }
719 in := map[string]any{}
720 if r.ContentLength != 0 {
721 if err := readJSON(r, &in); err != nil {
722 s.writeAPIErr(w, r, fail(400, err))
723 return
724 }
725 }
726 code, raw, err := s.backupAction(r.Context(), apiUser(r).Username, c, r.PathValue("name"), in)
727 if err != nil {
728 s.writeAPIErr(w, r, err)
729 return
730 }
731 w.Header().Set("Content-Type", "application/json")
732 w.WriteHeader(code)
733 _, _ = w.Write(raw)
734}
735
736func unwrapFail(err error) error {
737 var oe interface{ Unwrap() error }
738 if errors.As(err, &oe) && oe.Unwrap() != nil {
739 return oe.Unwrap()
740 }
741 return err
742}