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