package server import ( "context" "encoding/json" "errors" "io" "net/http" "net/url" "os" "strconv" "strings" "sync/atomic" "time" "gitlab.com/Timfa/bluegit/internal/backup" "gitlab.com/Timfa/bluegit/internal/i18n" ) // Beheer > Backup: één losse backup server (repo bluegit-backup) haalt met // een Backupserver-Key alle gegevens op, krijgt een melding bij elke // wijziging, en kan een archief terugsturen (rollback). Het protocol staat // in docs/BACKUP.md. // maxRestoreBytes begrenst een terug te zetten archief (64 GiB). const maxRestoreBytes = 64 << 30 var ( restoreBusy atomic.Bool backupFails updateLimiter ) // BackupView is de stand op Beheer > Backup. type BackupView struct { Conn backup.Conn NewKey string Archives []backup.Archive Remote *backup.RemoteStatus RemoteErr string InstanceID string } func (s *Server) backupInit() { s.backupOnce.Do(func() { s.backupMgr = &backup.Manager{Dir: s.StateDir} s.backupHTTP = &http.Client{Timeout: 15 * time.Second} s.backupNote = &backup.Notifier{Client: s.backupClient()} }) } func (s *Server) backupClient() *backup.Client { return &backup.Client{Manager: s.backupMgr, HTTP: s.backupHTTP} } // BackupManager geeft de koppeling (ook voor tests). func (s *Server) BackupManager() *backup.Manager { s.backupInit() return s.backupMgr } // BackupChanged meldt een wijziging aan de gekoppelde backup server. func (s *Server) BackupChanged() { if s.StateDir == "" { return } s.backupInit() s.backupNote.Changed() } func (s *Server) backupTree() backup.Tree { return backup.Tree{ StateDir: s.StateDir, DataDir: s.StoragePath(), Snapshot: func(dst string) error { return s.Store.Snapshot(context.Background(), dst) }, } } func (s *Server) mountBackup(mux *http.ServeMux) { mux.HandleFunc("GET /api/v1/backup/info", s.backupKeyed(s.backupInfo)) mux.HandleFunc("POST /api/v1/backup/connect", s.backupKeyed(s.backupConnect)) mux.HandleFunc("GET /api/v1/backup/manifest", s.backupKeyed(s.backupManifest)) mux.HandleFunc("GET /api/v1/backup/file", s.backupKeyed(s.backupFile)) mux.HandleFunc("POST /api/v1/backup/restore", s.backupKeyed(s.backupRestore)) mux.HandleFunc("GET /admin/backup", s.adminBackup) mux.HandleFunc("POST /admin/backup/key", s.adminBackupKey) mux.HandleFunc("POST /admin/backup/revoke", s.adminBackupRevoke) mux.HandleFunc("POST /admin/backup/rollback", s.adminBackupRollback) } // backupWatch meldt na elk schrijvend verzoek een wijziging. De backup // server haalt daarna alleen op wat veranderd is; een melding te veel kost // dus weinig. Tijdens het terugzetten van een backup wordt niet geschreven. func (s *Server) backupWatch(next http.Handler) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { switch r.Method { case http.MethodGet, http.MethodHead, http.MethodOptions: next.ServeHTTP(w, r) return } if restoreBusy.Load() { http.Error(w, "backup wordt teruggezet; BlueGit herstart zo\n", http.StatusServiceUnavailable) return } next.ServeHTTP(w, r) if strings.HasPrefix(r.URL.Path, "/api/v1/backup/") || strings.HasSuffix(r.URL.Path, "/git-upload-pack") { return } s.BackupChanged() }) } func backupErr(w http.ResponseWriter, code int, msg string) { writeJSON(w, code, map[string]string{"error": msg}) } // backupKeyed eist de Backupserver-Key als bearer-token. func (s *Server) backupKeyed(h func(http.ResponseWriter, *http.Request)) http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { w.Header().Set("Cache-Control", "no-store") if s.StateDir == "" { backupErr(w, http.StatusNotFound, "backup niet beschikbaar") return } s.backupInit() if _, ok := s.backupMgr.Check(bearer(r)); !ok { // Alleen mislukte pogingen tellen: hoogstens 5 per minuut per IP. if !backupFails.allow(clientIP(r), time.Now()) { backupErr(w, http.StatusTooManyRequests, "te veel mislukte pogingen") return } backupErr(w, http.StatusUnauthorized, "ongeldige Backupserver-Key") return } s.backupMgr.Seen() h(w, r) } } func (s *Server) backupInfo(w http.ResponseWriter, r *http.Request) { id, err := s.backupMgr.InstanceID() if err != nil { backupErr(w, 500, err.Error()) return } c, _ := s.backupMgr.Load() writeJSON(w, http.StatusOK, map[string]any{ "instance_id": id, "base_url": s.Cfg.BaseURL, "server_url": c.ServerURL, "server_id": c.ServerID, "has_storage": s.StoragePath() != "", }) } func (s *Server) backupConnect(w http.ResponseWriter, r *http.Request) { var in struct { ServerURL string `json:"server_url"` ServerID string `json:"server_id"` } if err := json.NewDecoder(io.LimitReader(r.Body, 1<<16)).Decode(&in); err != nil { backupErr(w, 400, "ongeldige JSON") return } u, err := url.Parse(strings.TrimSpace(in.ServerURL)) if err != nil || (u.Scheme != "http" && u.Scheme != "https") || u.Host == "" { backupErr(w, 400, "server_url moet een http(s)-adres zijn") return } c, err := s.backupMgr.Connect(u.String(), strings.TrimSpace(in.ServerID)) if err != nil { backupErr(w, 500, err.Error()) return } id, _ := s.backupMgr.InstanceID() if s.Log != nil { s.Log.Info("backup audit", "action", "connect", "server", c.ServerURL, "server_id", c.ServerID) } writeJSON(w, http.StatusOK, map[string]any{"instance_id": id, "server_url": c.ServerURL}) } func (s *Server) backupManifest(w http.ResponseWriter, r *http.Request) { id, err := s.backupMgr.InstanceID() if err != nil { backupErr(w, 500, err.Error()) return } m, err := s.backupTree().Build(id) if err != nil { backupErr(w, 500, err.Error()) return } writeJSON(w, http.StatusOK, m) } func (s *Server) backupFile(w http.ResponseWriter, r *http.Request) { real, err := s.backupTree().Resolve(r.URL.Query().Get("path")) if err != nil { backupErr(w, http.StatusNotFound, "bestand niet gevonden") return } f, err := os.Open(real) if err != nil { backupErr(w, http.StatusNotFound, "bestand niet gevonden") return } defer f.Close() fi, err := f.Stat() if err != nil { backupErr(w, 500, err.Error()) return } w.Header().Set("Content-Type", "application/octet-stream") w.Header().Set("Content-Length", strconv.FormatInt(fi.Size(), 10)) w.Header().Set("X-Backup-Mtime", strconv.FormatInt(fi.ModTime().UnixMilli(), 10)) _, _ = io.Copy(w, f) } // backupRestore neemt een tar.gz aan, pakt het naast de live gegevens uit // en herstart BlueGit. Bij de start komt de backup op zijn plek. func (s *Server) backupRestore(w http.ResponseWriter, r *http.Request) { if !s.restoring.TryLock() { backupErr(w, http.StatusConflict, "er loopt al een restore") return } defer s.restoring.Unlock() restoreBusy.Store(true) n, err := s.backupTree().Stage(http.MaxBytesReader(w, r.Body, maxRestoreBytes)) if err != nil { restoreBusy.Store(false) if s.Log != nil { s.Log.Warn("backup audit", "action", "restore_failed", "err", err) } backupErr(w, http.StatusBadRequest, err.Error()) return } if s.Log != nil { s.Log.Warn("backup audit", "action", "restore_staged", "files", n) } writeJSON(w, http.StatusAccepted, map[string]any{"files": n, "restarting": s.RequestRestart != nil}) if f, ok := w.(http.Flusher); ok { f.Flush() } if s.RequestRestart != nil { go func() { time.Sleep(300 * time.Millisecond) s.RequestRestart() }() } } // ---------- Beheer > Backup ---------- func (s *Server) backupView(r *http.Request) *BackupView { s.backupInit() bv := &BackupView{} bv.Conn, _ = s.backupMgr.Load() bv.InstanceID, _ = s.backupMgr.InstanceID() if bv.Conn.Connected() { ctx, cancel := context.WithTimeout(r.Context(), 8*time.Second) defer cancel() arch, err := s.backupClient().Archives(ctx) if err != nil { bv.RemoteErr = err.Error() } else { bv.Archives = arch if st, err := s.backupClient().Status(ctx); err == nil { bv.Remote = &st } } } return bv } func (s *Server) adminBackup(w http.ResponseWriter, r *http.Request) { if ok, _ := s.adminOnly(w, r); !ok { return } v := s.view(w, r, "title.admin") v.Page = "adminbackup" v.Backup = s.backupView(r) if c, err := r.Cookie("bluegit_backup_key"); err == nil && c.Value != "" { v.Backup.NewKey = c.Value http.SetCookie(w, &http.Cookie{Name: "bluegit_backup_key", Value: "", Path: "/admin/backup", MaxAge: -1}) } s.render(w, "adminbackup", v) } func (s *Server) adminBackupKey(w http.ResponseWriter, r *http.Request) { if ok, _ := s.adminOnly(w, r); !ok || !s.csrfOK(w, r) { return } s.backupInit() key, _, err := s.backupMgr.NewKey(s.who(r).User.Username) if err != nil { s.redirect(w, r, "/admin/backup", "", err.Error()) return } if s.Log != nil { s.Log.Info("backup audit", "action", "new_key", "by", s.who(r).User.Username) } // Eenmalig tonen: kort, HttpOnly cookie alleen voor deze pagina. http.SetCookie(w, &http.Cookie{ Name: "bluegit_backup_key", Value: key, Path: "/admin/backup", MaxAge: 60, HttpOnly: true, SameSite: http.SameSiteStrictMode, Secure: strings.HasPrefix(s.Cfg.BaseURL, "https://"), }) s.redirect(w, r, "/admin/backup", s.tr(r, "backup.ok.key"), "") } func (s *Server) adminBackupRevoke(w http.ResponseWriter, r *http.Request) { if ok, _ := s.adminOnly(w, r); !ok || !s.csrfOK(w, r) { return } s.backupInit() if err := s.backupMgr.Revoke(); err != nil { s.redirect(w, r, "/admin/backup", "", err.Error()) return } if s.Log != nil { s.Log.Info("backup audit", "action", "revoke", "by", s.who(r).User.Username) } s.redirect(w, r, "/admin/backup", s.tr(r, "backup.ok.revoked"), "") } func (s *Server) startRollback(ctx context.Context, by, archive, confirm string) error { s.backupInit() archive = strings.TrimSpace(archive) if archive == "" { return fail(400, i18n.E("backup.err.archive")) } if strings.TrimSpace(confirm) != archive { return fail(400, i18n.E("backup.err.confirm")) } c, _ := s.backupMgr.Load() if !c.Connected() { return fail(409, i18n.E("backup.err.none")) } if err := s.backupClient().Rollback(ctx, archive); err != nil { return fail(502, err) } if s.Log != nil { s.Log.Warn("backup audit", "action", "rollback", "by", by, "archive", archive) } return nil } func (s *Server) adminBackupRollback(w http.ResponseWriter, r *http.Request) { if ok, _ := s.adminOnly(w, r); !ok || !s.csrfOK(w, r) { return } if r.FormValue("understood") != "1" { s.redirect(w, r, "/admin/backup", "", s.tr(r, "backup.err.understood")) return } if err := s.startRollback(r.Context(), s.who(r).User.Username, r.FormValue("archive"), r.FormValue("confirm")); err != nil { s.redirect(w, r, "/admin/backup", "", s.trErr(r, unwrapFail(err))) return } s.redirect(w, r, "/admin/backup", s.tr(r, "backup.ok.rollback", r.FormValue("archive")), "") } func unwrapFail(err error) error { var oe interface{ Unwrap() error } if errors.As(err, &oe) && oe.Unwrap() != nil { return oe.Unwrap() } return err } // ---------- API voor beheerders ---------- func (s *Server) apiAdminBackup(w http.ResponseWriter, r *http.Request) { if !apiUser(r).InstanceAdmin { s.writeAPIErr(w, r, fail(403, i18n.E("err.forbidden"))) return } bv := s.backupView(r) out := map[string]any{ "instance_id": bv.InstanceID, "has_key": bv.Conn.HasKey(), "key_hint": bv.Conn.KeyHint, "connected": bv.Conn.Connected(), "server_url": bv.Conn.ServerURL, "server_id": bv.Conn.ServerID, "archives": bv.Archives, "remote_error": bv.RemoteErr, } if bv.Conn.Connected() { out["last_seen"] = rfcTime(bv.Conn.LastSeen) } if bv.Archives == nil { out["archives"] = []backup.Archive{} } if bv.Remote != nil { out["remote"] = bv.Remote } writeJSON(w, http.StatusOK, out) } func (s *Server) apiAdminBackupKey(w http.ResponseWriter, r *http.Request) { if !apiUser(r).InstanceAdmin { s.writeAPIErr(w, r, fail(403, i18n.E("err.forbidden"))) return } s.backupInit() key, c, err := s.backupMgr.NewKey(apiUser(r).Username) if err != nil { s.writeAPIErr(w, r, fail(500, err)) return } if s.Log != nil { s.Log.Info("backup audit", "action", "new_key", "by", apiUser(r).Username) } writeJSON(w, http.StatusCreated, map[string]any{"key": key, "key_hint": c.KeyHint, "created_at": rfcTime(c.CreatedAt)}) } func (s *Server) apiAdminBackupRevoke(w http.ResponseWriter, r *http.Request) { if !apiUser(r).InstanceAdmin { s.writeAPIErr(w, r, fail(403, i18n.E("err.forbidden"))) return } s.backupInit() if err := s.backupMgr.Revoke(); err != nil { s.writeAPIErr(w, r, fail(500, err)) return } writeJSON(w, http.StatusNoContent, nil) } func (s *Server) apiAdminBackupRollback(w http.ResponseWriter, r *http.Request) { if !apiUser(r).InstanceAdmin { s.writeAPIErr(w, r, fail(403, i18n.E("err.forbidden"))) return } var in struct { Archive string `json:"archive"` Confirm string `json:"confirm"` } if err := readJSON(r, &in); err != nil { s.writeAPIErr(w, r, fail(400, i18n.E("backup.err.archive"))) return } if err := s.startRollback(r.Context(), apiUser(r).Username, in.Archive, in.Confirm); err != nil { s.writeAPIErr(w, r, err) return } writeJSON(w, http.StatusAccepted, map[string]any{"archive": in.Archive, "state": "started"}) }