| 1 | package server |
| 2 | |
| 3 | import ( |
| 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). |
| 28 | const maxRestoreBytes = 64 << 30 |
| 29 | |
| 30 | var ( |
| 31 | restoreBusy atomic.Bool |
| 32 | backupFails updateLimiter |
| 33 | ) |
| 34 | |
| 35 | // BackupView is de stand op Beheer > Backup. |
| 36 | type 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. |
| 46 | type BackupServerView struct { |
| 47 | Conn backup.Conn |
| 48 | Remote *backup.RemoteStatus |
| 49 | Archives []backup.Archive |
| 50 | Config *backup.RemoteConfig |
| 51 | RemoteErr string |
| 52 | } |
| 53 | |
| 54 | func (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 | |
| 62 | func (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). |
| 67 | func (s *Server) BackupManager() *backup.Manager { |
| 68 | s.backupInit() |
| 69 | return s.backupMgr |
| 70 | } |
| 71 | |
| 72 | // BackupChanged meldt een wijziging aan de gekoppelde backup server. |
| 73 | func (s *Server) BackupChanged() { |
| 74 | if s.StateDir == "" { |
| 75 | return |
| 76 | } |
| 77 | s.backupInit() |
| 78 | s.backupNote.Changed() |
| 79 | } |
| 80 | |
| 81 | func (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 | |
| 88 | func (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. |
| 106 | func (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 | |
| 125 | func 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. |
| 130 | func (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 | |
| 153 | type backupConnKey struct{} |
| 154 | |
| 155 | func backupConnOf(r *http.Request) backup.Conn { |
| 156 | c, _ := r.Context().Value(backupConnKey{}).(backup.Conn) |
| 157 | return c |
| 158 | } |
| 159 | |
| 160 | func (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 | |
| 173 | func (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 | |
| 199 | func (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 | |
| 213 | func (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. |
| 238 | func (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 | |
| 271 | func (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. |
| 281 | func (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 | |
| 308 | func (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 | |
| 318 | func (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 | |
| 327 | func backupPath(id string) string { return "/admin/backup/s/" + url.PathEscape(id) } |
| 328 | |
| 329 | func (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. |
| 350 | func (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 | |
| 357 | func (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 | |
| 363 | func (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 | |
| 379 | func (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 | |
| 389 | func (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 | |
| 408 | func (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. |
| 425 | func (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 | |
| 438 | func (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. |
| 456 | func (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 | |
| 528 | func (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 | |
| 575 | func 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 | |
| 587 | func (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 | |
| 596 | func (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 | |
| 607 | func (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 | |
| 619 | func (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 | |
| 643 | func (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 | |
| 664 | func (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 | |
| 684 | func (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 | |
| 701 | func (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 | |
| 713 | func (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 | |
| 735 | func 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 | } |