| 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: één losse backup server (repo bluegit-backup) haalt met |
| 21 | // een Backupserver-Key alle gegevens op, krijgt een melding bij elke |
| 22 | // wijziging, en kan een archief terugsturen (rollback). Het protocol staat |
| 23 | // in docs/BACKUP.md. |
| 24 | |
| 25 | // maxRestoreBytes begrenst een terug te zetten archief (64 GiB). |
| 26 | const maxRestoreBytes = 64 << 30 |
| 27 | |
| 28 | var ( |
| 29 | restoreBusy atomic.Bool |
| 30 | backupFails updateLimiter |
| 31 | ) |
| 32 | |
| 33 | // BackupView is de stand op Beheer > Backup. |
| 34 | type BackupView struct { |
| 35 | Conn backup.Conn |
| 36 | NewKey string |
| 37 | Archives []backup.Archive |
| 38 | Remote *backup.RemoteStatus |
| 39 | RemoteErr string |
| 40 | InstanceID string |
| 41 | } |
| 42 | |
| 43 | func (s *Server) backupInit() { |
| 44 | s.backupOnce.Do(func() { |
| 45 | s.backupMgr = &backup.Manager{Dir: s.StateDir} |
| 46 | s.backupHTTP = &http.Client{Timeout: 15 * time.Second} |
| 47 | s.backupNote = &backup.Notifier{Client: s.backupClient()} |
| 48 | }) |
| 49 | } |
| 50 | |
| 51 | func (s *Server) backupClient() *backup.Client { |
| 52 | return &backup.Client{Manager: s.backupMgr, HTTP: s.backupHTTP} |
| 53 | } |
| 54 | |
| 55 | // BackupManager geeft de koppeling (ook voor tests). |
| 56 | func (s *Server) BackupManager() *backup.Manager { |
| 57 | s.backupInit() |
| 58 | return s.backupMgr |
| 59 | } |
| 60 | |
| 61 | // BackupChanged meldt een wijziging aan de gekoppelde backup server. |
| 62 | func (s *Server) BackupChanged() { |
| 63 | if s.StateDir == "" { |
| 64 | return |
| 65 | } |
| 66 | s.backupInit() |
| 67 | s.backupNote.Changed() |
| 68 | } |
| 69 | |
| 70 | func (s *Server) backupTree() backup.Tree { |
| 71 | return backup.Tree{ |
| 72 | StateDir: s.StateDir, DataDir: s.StoragePath(), |
| 73 | Snapshot: func(dst string) error { return s.Store.Snapshot(context.Background(), dst) }, |
| 74 | } |
| 75 | } |
| 76 | |
| 77 | func (s *Server) mountBackup(mux *http.ServeMux) { |
| 78 | mux.HandleFunc("GET /api/v1/backup/info", s.backupKeyed(s.backupInfo)) |
| 79 | mux.HandleFunc("POST /api/v1/backup/connect", s.backupKeyed(s.backupConnect)) |
| 80 | mux.HandleFunc("GET /api/v1/backup/manifest", s.backupKeyed(s.backupManifest)) |
| 81 | mux.HandleFunc("GET /api/v1/backup/file", s.backupKeyed(s.backupFile)) |
| 82 | mux.HandleFunc("POST /api/v1/backup/restore", s.backupKeyed(s.backupRestore)) |
| 83 | mux.HandleFunc("GET /admin/backup", s.adminBackup) |
| 84 | mux.HandleFunc("POST /admin/backup/key", s.adminBackupKey) |
| 85 | mux.HandleFunc("POST /admin/backup/revoke", s.adminBackupRevoke) |
| 86 | mux.HandleFunc("POST /admin/backup/rollback", s.adminBackupRollback) |
| 87 | } |
| 88 | |
| 89 | // backupWatch meldt na elk schrijvend verzoek een wijziging. De backup |
| 90 | // server haalt daarna alleen op wat veranderd is; een melding te veel kost |
| 91 | // dus weinig. Tijdens het terugzetten van een backup wordt niet geschreven. |
| 92 | func (s *Server) backupWatch(next http.Handler) http.Handler { |
| 93 | return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { |
| 94 | switch r.Method { |
| 95 | case http.MethodGet, http.MethodHead, http.MethodOptions: |
| 96 | next.ServeHTTP(w, r) |
| 97 | return |
| 98 | } |
| 99 | if restoreBusy.Load() { |
| 100 | http.Error(w, "backup wordt teruggezet; BlueGit herstart zo\n", http.StatusServiceUnavailable) |
| 101 | return |
| 102 | } |
| 103 | next.ServeHTTP(w, r) |
| 104 | if strings.HasPrefix(r.URL.Path, "/api/v1/backup/") || strings.HasSuffix(r.URL.Path, "/git-upload-pack") { |
| 105 | return |
| 106 | } |
| 107 | s.BackupChanged() |
| 108 | }) |
| 109 | } |
| 110 | |
| 111 | func backupErr(w http.ResponseWriter, code int, msg string) { |
| 112 | writeJSON(w, code, map[string]string{"error": msg}) |
| 113 | } |
| 114 | |
| 115 | // backupKeyed eist de Backupserver-Key als bearer-token. |
| 116 | func (s *Server) backupKeyed(h func(http.ResponseWriter, *http.Request)) http.HandlerFunc { |
| 117 | return func(w http.ResponseWriter, r *http.Request) { |
| 118 | w.Header().Set("Cache-Control", "no-store") |
| 119 | if s.StateDir == "" { |
| 120 | backupErr(w, http.StatusNotFound, "backup niet beschikbaar") |
| 121 | return |
| 122 | } |
| 123 | s.backupInit() |
| 124 | if _, ok := s.backupMgr.Check(bearer(r)); !ok { |
| 125 | // Alleen mislukte pogingen tellen: hoogstens 5 per minuut per IP. |
| 126 | if !backupFails.allow(clientIP(r), time.Now()) { |
| 127 | backupErr(w, http.StatusTooManyRequests, "te veel mislukte pogingen") |
| 128 | return |
| 129 | } |
| 130 | backupErr(w, http.StatusUnauthorized, "ongeldige Backupserver-Key") |
| 131 | return |
| 132 | } |
| 133 | s.backupMgr.Seen() |
| 134 | h(w, r) |
| 135 | } |
| 136 | } |
| 137 | |
| 138 | func (s *Server) backupInfo(w http.ResponseWriter, r *http.Request) { |
| 139 | id, err := s.backupMgr.InstanceID() |
| 140 | if err != nil { |
| 141 | backupErr(w, 500, err.Error()) |
| 142 | return |
| 143 | } |
| 144 | c, _ := s.backupMgr.Load() |
| 145 | writeJSON(w, http.StatusOK, map[string]any{ |
| 146 | "instance_id": id, "base_url": s.Cfg.BaseURL, "server_url": c.ServerURL, "server_id": c.ServerID, |
| 147 | "has_storage": s.StoragePath() != "", |
| 148 | }) |
| 149 | } |
| 150 | |
| 151 | func (s *Server) backupConnect(w http.ResponseWriter, r *http.Request) { |
| 152 | var in struct { |
| 153 | ServerURL string `json:"server_url"` |
| 154 | ServerID string `json:"server_id"` |
| 155 | } |
| 156 | if err := json.NewDecoder(io.LimitReader(r.Body, 1<<16)).Decode(&in); err != nil { |
| 157 | backupErr(w, 400, "ongeldige JSON") |
| 158 | return |
| 159 | } |
| 160 | u, err := url.Parse(strings.TrimSpace(in.ServerURL)) |
| 161 | if err != nil || (u.Scheme != "http" && u.Scheme != "https") || u.Host == "" { |
| 162 | backupErr(w, 400, "server_url moet een http(s)-adres zijn") |
| 163 | return |
| 164 | } |
| 165 | c, err := s.backupMgr.Connect(u.String(), strings.TrimSpace(in.ServerID)) |
| 166 | if err != nil { |
| 167 | backupErr(w, 500, err.Error()) |
| 168 | return |
| 169 | } |
| 170 | id, _ := s.backupMgr.InstanceID() |
| 171 | if s.Log != nil { |
| 172 | s.Log.Info("backup audit", "action", "connect", "server", c.ServerURL, "server_id", c.ServerID) |
| 173 | } |
| 174 | writeJSON(w, http.StatusOK, map[string]any{"instance_id": id, "server_url": c.ServerURL}) |
| 175 | } |
| 176 | |
| 177 | func (s *Server) backupManifest(w http.ResponseWriter, r *http.Request) { |
| 178 | id, err := s.backupMgr.InstanceID() |
| 179 | if err != nil { |
| 180 | backupErr(w, 500, err.Error()) |
| 181 | return |
| 182 | } |
| 183 | m, err := s.backupTree().Build(id) |
| 184 | if err != nil { |
| 185 | backupErr(w, 500, err.Error()) |
| 186 | return |
| 187 | } |
| 188 | writeJSON(w, http.StatusOK, m) |
| 189 | } |
| 190 | |
| 191 | func (s *Server) backupFile(w http.ResponseWriter, r *http.Request) { |
| 192 | real, err := s.backupTree().Resolve(r.URL.Query().Get("path")) |
| 193 | if err != nil { |
| 194 | backupErr(w, http.StatusNotFound, "bestand niet gevonden") |
| 195 | return |
| 196 | } |
| 197 | f, err := os.Open(real) |
| 198 | if err != nil { |
| 199 | backupErr(w, http.StatusNotFound, "bestand niet gevonden") |
| 200 | return |
| 201 | } |
| 202 | defer f.Close() |
| 203 | fi, err := f.Stat() |
| 204 | if err != nil { |
| 205 | backupErr(w, 500, err.Error()) |
| 206 | return |
| 207 | } |
| 208 | w.Header().Set("Content-Type", "application/octet-stream") |
| 209 | w.Header().Set("Content-Length", strconv.FormatInt(fi.Size(), 10)) |
| 210 | w.Header().Set("X-Backup-Mtime", strconv.FormatInt(fi.ModTime().UnixMilli(), 10)) |
| 211 | _, _ = io.Copy(w, f) |
| 212 | } |
| 213 | |
| 214 | // backupRestore neemt een tar.gz aan, pakt het naast de live gegevens uit |
| 215 | // en herstart BlueGit. Bij de start komt de backup op zijn plek. |
| 216 | func (s *Server) backupRestore(w http.ResponseWriter, r *http.Request) { |
| 217 | if !s.restoring.TryLock() { |
| 218 | backupErr(w, http.StatusConflict, "er loopt al een restore") |
| 219 | return |
| 220 | } |
| 221 | defer s.restoring.Unlock() |
| 222 | restoreBusy.Store(true) |
| 223 | n, err := s.backupTree().Stage(http.MaxBytesReader(w, r.Body, maxRestoreBytes)) |
| 224 | if err != nil { |
| 225 | restoreBusy.Store(false) |
| 226 | if s.Log != nil { |
| 227 | s.Log.Warn("backup audit", "action", "restore_failed", "err", err) |
| 228 | } |
| 229 | backupErr(w, http.StatusBadRequest, err.Error()) |
| 230 | return |
| 231 | } |
| 232 | if s.Log != nil { |
| 233 | s.Log.Warn("backup audit", "action", "restore_staged", "files", n) |
| 234 | } |
| 235 | writeJSON(w, http.StatusAccepted, map[string]any{"files": n, "restarting": s.RequestRestart != nil}) |
| 236 | if f, ok := w.(http.Flusher); ok { |
| 237 | f.Flush() |
| 238 | } |
| 239 | if s.RequestRestart != nil { |
| 240 | go func() { |
| 241 | time.Sleep(300 * time.Millisecond) |
| 242 | s.RequestRestart() |
| 243 | }() |
| 244 | } |
| 245 | } |
| 246 | |
| 247 | // ---------- Beheer > Backup ---------- |
| 248 | |
| 249 | func (s *Server) backupView(r *http.Request) *BackupView { |
| 250 | s.backupInit() |
| 251 | bv := &BackupView{} |
| 252 | bv.Conn, _ = s.backupMgr.Load() |
| 253 | bv.InstanceID, _ = s.backupMgr.InstanceID() |
| 254 | if bv.Conn.Connected() { |
| 255 | ctx, cancel := context.WithTimeout(r.Context(), 8*time.Second) |
| 256 | defer cancel() |
| 257 | arch, err := s.backupClient().Archives(ctx) |
| 258 | if err != nil { |
| 259 | bv.RemoteErr = err.Error() |
| 260 | } else { |
| 261 | bv.Archives = arch |
| 262 | if st, err := s.backupClient().Status(ctx); err == nil { |
| 263 | bv.Remote = &st |
| 264 | } |
| 265 | } |
| 266 | } |
| 267 | return bv |
| 268 | } |
| 269 | |
| 270 | func (s *Server) adminBackup(w http.ResponseWriter, r *http.Request) { |
| 271 | if ok, _ := s.adminOnly(w, r); !ok { |
| 272 | return |
| 273 | } |
| 274 | v := s.view(w, r, "title.admin") |
| 275 | v.Page = "adminbackup" |
| 276 | v.Backup = s.backupView(r) |
| 277 | if c, err := r.Cookie("bluegit_backup_key"); err == nil && c.Value != "" { |
| 278 | v.Backup.NewKey = c.Value |
| 279 | http.SetCookie(w, &http.Cookie{Name: "bluegit_backup_key", Value: "", Path: "/admin/backup", MaxAge: -1}) |
| 280 | } |
| 281 | s.render(w, "adminbackup", v) |
| 282 | } |
| 283 | |
| 284 | func (s *Server) adminBackupKey(w http.ResponseWriter, r *http.Request) { |
| 285 | if ok, _ := s.adminOnly(w, r); !ok || !s.csrfOK(w, r) { |
| 286 | return |
| 287 | } |
| 288 | s.backupInit() |
| 289 | key, _, err := s.backupMgr.NewKey(s.who(r).User.Username) |
| 290 | if err != nil { |
| 291 | s.redirect(w, r, "/admin/backup", "", err.Error()) |
| 292 | return |
| 293 | } |
| 294 | if s.Log != nil { |
| 295 | s.Log.Info("backup audit", "action", "new_key", "by", s.who(r).User.Username) |
| 296 | } |
| 297 | // Eenmalig tonen: kort, HttpOnly cookie alleen voor deze pagina. |
| 298 | http.SetCookie(w, &http.Cookie{ |
| 299 | Name: "bluegit_backup_key", Value: key, Path: "/admin/backup", MaxAge: 60, HttpOnly: true, |
| 300 | SameSite: http.SameSiteStrictMode, Secure: strings.HasPrefix(s.Cfg.BaseURL, "https://"), |
| 301 | }) |
| 302 | s.redirect(w, r, "/admin/backup", s.tr(r, "backup.ok.key"), "") |
| 303 | } |
| 304 | |
| 305 | func (s *Server) adminBackupRevoke(w http.ResponseWriter, r *http.Request) { |
| 306 | if ok, _ := s.adminOnly(w, r); !ok || !s.csrfOK(w, r) { |
| 307 | return |
| 308 | } |
| 309 | s.backupInit() |
| 310 | if err := s.backupMgr.Revoke(); err != nil { |
| 311 | s.redirect(w, r, "/admin/backup", "", err.Error()) |
| 312 | return |
| 313 | } |
| 314 | if s.Log != nil { |
| 315 | s.Log.Info("backup audit", "action", "revoke", "by", s.who(r).User.Username) |
| 316 | } |
| 317 | s.redirect(w, r, "/admin/backup", s.tr(r, "backup.ok.revoked"), "") |
| 318 | } |
| 319 | |
| 320 | func (s *Server) startRollback(ctx context.Context, by, archive, confirm string) error { |
| 321 | s.backupInit() |
| 322 | archive = strings.TrimSpace(archive) |
| 323 | if archive == "" { |
| 324 | return fail(400, i18n.E("backup.err.archive")) |
| 325 | } |
| 326 | if strings.TrimSpace(confirm) != archive { |
| 327 | return fail(400, i18n.E("backup.err.confirm")) |
| 328 | } |
| 329 | c, _ := s.backupMgr.Load() |
| 330 | if !c.Connected() { |
| 331 | return fail(409, i18n.E("backup.err.none")) |
| 332 | } |
| 333 | if err := s.backupClient().Rollback(ctx, archive); err != nil { |
| 334 | return fail(502, err) |
| 335 | } |
| 336 | if s.Log != nil { |
| 337 | s.Log.Warn("backup audit", "action", "rollback", "by", by, "archive", archive) |
| 338 | } |
| 339 | return nil |
| 340 | } |
| 341 | |
| 342 | func (s *Server) adminBackupRollback(w http.ResponseWriter, r *http.Request) { |
| 343 | if ok, _ := s.adminOnly(w, r); !ok || !s.csrfOK(w, r) { |
| 344 | return |
| 345 | } |
| 346 | if r.FormValue("understood") != "1" { |
| 347 | s.redirect(w, r, "/admin/backup", "", s.tr(r, "backup.err.understood")) |
| 348 | return |
| 349 | } |
| 350 | if err := s.startRollback(r.Context(), s.who(r).User.Username, r.FormValue("archive"), r.FormValue("confirm")); err != nil { |
| 351 | s.redirect(w, r, "/admin/backup", "", s.trErr(r, unwrapFail(err))) |
| 352 | return |
| 353 | } |
| 354 | s.redirect(w, r, "/admin/backup", s.tr(r, "backup.ok.rollback", r.FormValue("archive")), "") |
| 355 | } |
| 356 | |
| 357 | func unwrapFail(err error) error { |
| 358 | var oe interface{ Unwrap() error } |
| 359 | if errors.As(err, &oe) && oe.Unwrap() != nil { |
| 360 | return oe.Unwrap() |
| 361 | } |
| 362 | return err |
| 363 | } |
| 364 | |
| 365 | // ---------- API voor beheerders ---------- |
| 366 | |
| 367 | func (s *Server) apiAdminBackup(w http.ResponseWriter, r *http.Request) { |
| 368 | if !apiUser(r).InstanceAdmin { |
| 369 | s.writeAPIErr(w, r, fail(403, i18n.E("err.forbidden"))) |
| 370 | return |
| 371 | } |
| 372 | bv := s.backupView(r) |
| 373 | out := map[string]any{ |
| 374 | "instance_id": bv.InstanceID, "has_key": bv.Conn.HasKey(), "key_hint": bv.Conn.KeyHint, |
| 375 | "connected": bv.Conn.Connected(), "server_url": bv.Conn.ServerURL, "server_id": bv.Conn.ServerID, |
| 376 | "archives": bv.Archives, "remote_error": bv.RemoteErr, |
| 377 | } |
| 378 | if bv.Conn.Connected() { |
| 379 | out["last_seen"] = rfcTime(bv.Conn.LastSeen) |
| 380 | } |
| 381 | if bv.Archives == nil { |
| 382 | out["archives"] = []backup.Archive{} |
| 383 | } |
| 384 | if bv.Remote != nil { |
| 385 | out["remote"] = bv.Remote |
| 386 | } |
| 387 | writeJSON(w, http.StatusOK, out) |
| 388 | } |
| 389 | |
| 390 | func (s *Server) apiAdminBackupKey(w http.ResponseWriter, r *http.Request) { |
| 391 | if !apiUser(r).InstanceAdmin { |
| 392 | s.writeAPIErr(w, r, fail(403, i18n.E("err.forbidden"))) |
| 393 | return |
| 394 | } |
| 395 | s.backupInit() |
| 396 | key, c, err := s.backupMgr.NewKey(apiUser(r).Username) |
| 397 | if err != nil { |
| 398 | s.writeAPIErr(w, r, fail(500, err)) |
| 399 | return |
| 400 | } |
| 401 | if s.Log != nil { |
| 402 | s.Log.Info("backup audit", "action", "new_key", "by", apiUser(r).Username) |
| 403 | } |
| 404 | writeJSON(w, http.StatusCreated, map[string]any{"key": key, "key_hint": c.KeyHint, "created_at": rfcTime(c.CreatedAt)}) |
| 405 | } |
| 406 | |
| 407 | func (s *Server) apiAdminBackupRevoke(w http.ResponseWriter, r *http.Request) { |
| 408 | if !apiUser(r).InstanceAdmin { |
| 409 | s.writeAPIErr(w, r, fail(403, i18n.E("err.forbidden"))) |
| 410 | return |
| 411 | } |
| 412 | s.backupInit() |
| 413 | if err := s.backupMgr.Revoke(); err != nil { |
| 414 | s.writeAPIErr(w, r, fail(500, err)) |
| 415 | return |
| 416 | } |
| 417 | writeJSON(w, http.StatusNoContent, nil) |
| 418 | } |
| 419 | |
| 420 | func (s *Server) apiAdminBackupRollback(w http.ResponseWriter, r *http.Request) { |
| 421 | if !apiUser(r).InstanceAdmin { |
| 422 | s.writeAPIErr(w, r, fail(403, i18n.E("err.forbidden"))) |
| 423 | return |
| 424 | } |
| 425 | var in struct { |
| 426 | Archive string `json:"archive"` |
| 427 | Confirm string `json:"confirm"` |
| 428 | } |
| 429 | if err := readJSON(r, &in); err != nil { |
| 430 | s.writeAPIErr(w, r, fail(400, i18n.E("backup.err.archive"))) |
| 431 | return |
| 432 | } |
| 433 | if err := s.startRollback(r.Context(), apiUser(r).Username, in.Archive, in.Confirm); err != nil { |
| 434 | s.writeAPIErr(w, r, err) |
| 435 | return |
| 436 | } |
| 437 | writeJSON(w, http.StatusAccepted, map[string]any{"archive": in.Archive, "state": "started"}) |
| 438 | } |