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: een of meer losse backup servers (repo bluegit-backup) // halen elk met een eigen Backupserver-Key alle gegevens op, krijgen een // melding bij elke wijziging, en kunnen een archief terugsturen (rollback). // Vanuit BlueGit is elke backup server ook te bedienen: BlueGit stuurt // ondertekende verzoeken naar de beheer-API van de backup server. 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 { InstanceID string Servers []backup.Conn Max int // Current is de geopende backup server (detailpagina). Current *BackupServerView NewKey string } // BackupServerView is één backup server met wat hij zelf meldt. type BackupServerView struct { Conn backup.Conn Remote *backup.RemoteStatus Archives []backup.Archive Config *backup.RemoteConfig RemoteErr 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/servers", s.adminBackupAdd) mux.HandleFunc("GET /admin/backup/s/{id}", s.adminBackupServer) mux.HandleFunc("POST /admin/backup/s/{id}/key", s.adminBackupKey) mux.HandleFunc("POST /admin/backup/s/{id}/rename", s.adminBackupRename) mux.HandleFunc("POST /admin/backup/s/{id}/remove", s.adminBackupRemove) mux.HandleFunc("POST /admin/backup/s/{id}/act/{name}", s.adminBackupAct) } // 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() conn, ok := s.backupMgr.Check(bearer(r)) if !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(conn.ID) h(w, r.WithContext(context.WithValue(r.Context(), backupConnKey{}, conn))) } } type backupConnKey struct{} func backupConnOf(r *http.Request) backup.Conn { c, _ := r.Context().Value(backupConnKey{}).(backup.Conn) return c } 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 := backupConnOf(r) writeJSON(w, http.StatusOK, map[string]any{ "instance_id": id, "base_url": s.Cfg.BaseURL, "name": c.Name, "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(backupConnOf(r).ID, 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", "id", c.ID, "name", c.Name, "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, "id", backupConnOf(r).ID, "name", backupConnOf(r).Name) } 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) backupList() *BackupView { s.backupInit() bv := &BackupView{Max: backup.MaxServers} bv.Servers, _ = s.backupMgr.List() bv.InstanceID, _ = s.backupMgr.InstanceID() return bv } // backupServerView vraagt status, archieven en instellingen op bij de // backup server. func (s *Server) backupServerView(ctx context.Context, conn backup.Conn) *BackupServerView { v := &BackupServerView{Conn: conn} if !conn.Connected() { return v } ctx, cancel := context.WithTimeout(ctx, 8*time.Second) defer cancel() c := s.backupClient() st, err := c.Status(ctx, conn) if err != nil { v.RemoteErr = err.Error() return v } v.Remote = &st if arch, err := c.Archives(ctx, conn); err == nil { v.Archives = arch } else { v.RemoteErr = err.Error() } if cfg, err := c.Config(ctx, conn); err == nil { v.Config = &cfg } else if v.RemoteErr == "" { v.RemoteErr = err.Error() } return v } 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.backupList() s.render(w, "adminbackup", v) } func (s *Server) backupConnFromPath(w http.ResponseWriter, r *http.Request) (backup.Conn, bool) { s.backupInit() c, ok := s.backupMgr.Get(r.PathValue("id")) if !ok { http.NotFound(w, r) } return c, ok } func backupPath(id string) string { return "/admin/backup/s/" + url.PathEscape(id) } func (s *Server) adminBackupServer(w http.ResponseWriter, r *http.Request) { if ok, _ := s.adminOnly(w, r); !ok { return } conn, ok := s.backupConnFromPath(w, r) if !ok { return } v := s.view(w, r, "title.admin") v.Page = "adminbackupserver" v.Backup = s.backupList() v.Backup.Current = s.backupServerView(r.Context(), conn) 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: backupPath(conn.ID), MaxAge: -1}) } s.render(w, "adminbackup", v) } // showKeyOnce zet de nieuwe key in een kort, HttpOnly cookie dat alleen de // pagina van die backup server leest. func (s *Server) showKeyOnce(w http.ResponseWriter, id, key string) { http.SetCookie(w, &http.Cookie{ Name: "bluegit_backup_key", Value: key, Path: backupPath(id), MaxAge: 60, HttpOnly: true, SameSite: http.SameSiteStrictMode, Secure: strings.HasPrefix(s.Cfg.BaseURL, "https://"), }) } func (s *Server) backupAudit(action, by string, kv ...any) { if s.Log != nil { s.Log.Info("backup audit", append([]any{"action", action, "by", by}, kv...)...) } } func (s *Server) adminBackupAdd(w http.ResponseWriter, r *http.Request) { if ok, _ := s.adminOnly(w, r); !ok || !s.csrfOK(w, r) { return } s.backupInit() by := s.who(r).User.Username key, c, err := s.backupMgr.Add(r.FormValue("name"), by) if err != nil { s.redirect(w, r, "/admin/backup", "", s.backupErrText(r, err)) return } s.backupAudit("add", by, "id", c.ID, "name", c.Name) s.showKeyOnce(w, c.ID, key) s.redirect(w, r, backupPath(c.ID), s.tr(r, "backup.ok.key"), "") } func (s *Server) backupErrText(r *http.Request, err error) string { switch { case errors.Is(err, backup.ErrTooMany): return s.tr(r, "backup.err.tooMany", backup.MaxServers) case errors.Is(err, backup.ErrUnknown): return s.tr(r, "backup.err.unknown") } return s.trErr(r, unwrapFail(err)) } func (s *Server) adminBackupKey(w http.ResponseWriter, r *http.Request) { if ok, _ := s.adminOnly(w, r); !ok || !s.csrfOK(w, r) { return } conn, ok := s.backupConnFromPath(w, r) if !ok { return } by := s.who(r).User.Username key, _, err := s.backupMgr.RotateKey(conn.ID, by) if err != nil { s.redirect(w, r, backupPath(conn.ID), "", s.backupErrText(r, err)) return } s.backupAudit("new_key", by, "id", conn.ID, "name", conn.Name) s.showKeyOnce(w, conn.ID, key) s.redirect(w, r, backupPath(conn.ID), s.tr(r, "backup.ok.key"), "") } func (s *Server) adminBackupRename(w http.ResponseWriter, r *http.Request) { if ok, _ := s.adminOnly(w, r); !ok || !s.csrfOK(w, r) { return } conn, ok := s.backupConnFromPath(w, r) if !ok { return } if _, err := s.backupMgr.Rename(conn.ID, r.FormValue("name")); err != nil { s.redirect(w, r, backupPath(conn.ID), "", s.backupErrText(r, err)) return } s.redirect(w, r, backupPath(conn.ID), s.tr(r, "backup.ok.renamed"), "") } // removeBackupServer laat de backup server ontkoppelen (als hij bereikbaar // is) en vergeet hem daarna. func (s *Server) removeBackupServer(ctx context.Context, by string, conn backup.Conn) error { if conn.Connected() { ctx, cancel := context.WithTimeout(ctx, 5*time.Second) _, _, _ = s.backupClient().Call(ctx, conn, http.MethodPost, "/api/v1/admin/disconnect", map[string]any{}) cancel() } if err := s.backupMgr.Remove(conn.ID); err != nil { return err } s.backupAudit("remove", by, "id", conn.ID, "name", conn.Name) return nil } func (s *Server) adminBackupRemove(w http.ResponseWriter, r *http.Request) { if ok, _ := s.adminOnly(w, r); !ok || !s.csrfOK(w, r) { return } conn, ok := s.backupConnFromPath(w, r) if !ok { return } if err := s.removeBackupServer(r.Context(), s.who(r).User.Username, conn); err != nil { s.redirect(w, r, backupPath(conn.ID), "", s.backupErrText(r, err)) return } s.redirect(w, r, "/admin/backup", s.tr(r, "backup.ok.revoked"), "") } // backupAction voert een beheeractie van de backup server uit. BlueGit kent // de acties niet vooraf: de backup server noemt ze (GET /api/v1/admin/actions), // zodat alles wat zijn eigen webinterface kan, ook hier kan. func (s *Server) backupAction(ctx context.Context, by string, conn backup.Conn, name string, in map[string]any) (int, []byte, error) { if !conn.Connected() { return 0, nil, fail(409, i18n.E("backup.err.none")) } ctx, cancel := context.WithTimeout(ctx, 60*time.Second) defer cancel() c := s.backupClient() actions, err := c.Actions(ctx, conn) if err != nil { return 0, nil, fail(502, err) } var act *backup.RemoteAction for i := range actions { if actions[i].Name == name && actions[i].Signed { act = &actions[i] } } if act == nil { return 0, nil, fail(404, i18n.E("backup.err.action")) } str := func(k string) string { v, _ := in[k].(string) return strings.TrimSpace(v) } if name == "rollback" { if str("archive") == "" { return 0, nil, fail(400, i18n.E("backup.err.archive")) } if str("confirm") != str("archive") { return 0, nil, fail(400, i18n.E("backup.err.confirm")) } } if name == "sync" { if _, ok := in["wait"]; !ok { in["wait"] = "false" } } p := act.Path for _, param := range act.Params { v := str(param) if v == "" { return 0, nil, fail(400, i18n.E("backup.err.archive")) } p = strings.ReplaceAll(p, "{"+param+"}", url.PathEscape(v)) delete(in, param) } var body any if act.Method != http.MethodGet { body = in } hc := *s.backupHTTP hc.Timeout = 60 * time.Second cl := *c cl.HTTP = &hc code, raw, err := cl.Call(ctx, conn, act.Method, p, body) if err != nil { return 0, nil, fail(502, err) } if act.Method != http.MethodGet { kv := []any{"id", conn.ID, "name", conn.Name, "remote_action", name, "status", code} if a := str("archive"); a != "" { kv = append(kv, "archive", a) } if s.Log != nil && name == "rollback" { s.Log.Warn("backup audit", append([]any{"action", "rollback", "by", by}, kv...)...) } else { s.backupAudit("remote", by, kv...) } } return code, raw, nil } func (s *Server) adminBackupAct(w http.ResponseWriter, r *http.Request) { if ok, _ := s.adminOnly(w, r); !ok || !s.csrfOK(w, r) { return } conn, ok := s.backupConnFromPath(w, r) if !ok { return } back := backupPath(conn.ID) name := r.PathValue("name") if name == "rollback" && r.FormValue("understood") != "1" { s.redirect(w, r, back, "", s.tr(r, "backup.err.understood")) return } in := map[string]any{} _ = r.ParseForm() for k, v := range r.PostForm { if k == "csrf" || k == "understood" || len(v) == 0 { continue } in[k] = v[0] } code, raw, err := s.backupAction(r.Context(), s.who(r).User.Username, conn, name, in) if err != nil { s.redirect(w, r, back, "", s.backupErrText(r, err)) return } if code >= 300 { var e struct { Error string `json:"error"` } _ = json.Unmarshal(raw, &e) if e.Error == "" { e.Error = http.StatusText(code) } s.redirect(w, r, back, "", s.tr(r, "backup.err.remote", e.Error)) return } msg := s.tr(r, "backup.ok.action") if name == "rollback" { msg = s.tr(r, "backup.ok.rollback", in["archive"]) } s.redirect(w, r, back, msg, "") } // ---------- API voor beheerders ---------- func backupConnJSON(c backup.Conn) map[string]any { out := map[string]any{ "id": c.ID, "name": c.Name, "key_hint": c.KeyHint, "created_at": rfcTime(c.CreatedAt), "created_by": c.CreatedBy, "connected": c.Connected(), "server_url": c.ServerURL, "server_id": c.ServerID, } if c.Connected() { out["connected_at"] = rfcTime(c.ConnectedAt) out["last_seen"] = rfcTime(c.LastSeen) } return out } func (s *Server) apiBackupAdmin(w http.ResponseWriter, r *http.Request) bool { if !apiUser(r).InstanceAdmin { s.writeAPIErr(w, r, fail(403, i18n.E("err.forbidden"))) return false } s.backupInit() return true } func (s *Server) apiBackupConn(w http.ResponseWriter, r *http.Request) (backup.Conn, bool) { if !s.apiBackupAdmin(w, r) { return backup.Conn{}, false } c, ok := s.backupMgr.Get(r.PathValue("id")) if !ok { s.writeAPIErr(w, r, fail(404, i18n.E("backup.err.unknown"))) } return c, ok } func (s *Server) apiAdminBackup(w http.ResponseWriter, r *http.Request) { if !s.apiBackupAdmin(w, r) { return } bv := s.backupList() servers := make([]map[string]any, 0, len(bv.Servers)) for _, c := range bv.Servers { servers = append(servers, backupConnJSON(c)) } writeJSON(w, http.StatusOK, map[string]any{"instance_id": bv.InstanceID, "max_servers": bv.Max, "servers": servers}) } func (s *Server) apiAdminBackupAdd(w http.ResponseWriter, r *http.Request) { if !s.apiBackupAdmin(w, r) { return } var in struct { Name string `json:"name"` } _ = readJSON(r, &in) by := apiUser(r).Username key, c, err := s.backupMgr.Add(in.Name, by) if errors.Is(err, backup.ErrTooMany) { s.writeAPIErr(w, r, fail(409, err)) return } if err != nil { s.writeAPIErr(w, r, fail(500, err)) return } s.backupAudit("add", by, "id", c.ID, "name", c.Name) out := backupConnJSON(c) out["key"] = key writeJSON(w, http.StatusCreated, out) } func (s *Server) apiAdminBackupServer(w http.ResponseWriter, r *http.Request) { c, ok := s.apiBackupConn(w, r) if !ok { return } v := s.backupServerView(r.Context(), c) out := backupConnJSON(c) out["archives"] = v.Archives if v.Archives == nil { out["archives"] = []backup.Archive{} } if v.Remote != nil { out["remote"] = v.Remote } if v.Config != nil { out["config"] = v.Config } out["remote_error"] = v.RemoteErr writeJSON(w, http.StatusOK, out) } func (s *Server) apiAdminBackupRename(w http.ResponseWriter, r *http.Request) { c, ok := s.apiBackupConn(w, r) if !ok { return } var in struct { Name string `json:"name"` } if err := readJSON(r, &in); err != nil { s.writeAPIErr(w, r, fail(400, err)) return } c, err := s.backupMgr.Rename(c.ID, in.Name) if err != nil { s.writeAPIErr(w, r, fail(400, err)) return } writeJSON(w, http.StatusOK, backupConnJSON(c)) } func (s *Server) apiAdminBackupKey(w http.ResponseWriter, r *http.Request) { c, ok := s.apiBackupConn(w, r) if !ok { return } by := apiUser(r).Username key, c, err := s.backupMgr.RotateKey(c.ID, by) if err != nil { s.writeAPIErr(w, r, fail(500, err)) return } s.backupAudit("new_key", by, "id", c.ID, "name", c.Name) out := backupConnJSON(c) out["key"] = key writeJSON(w, http.StatusCreated, out) } func (s *Server) apiAdminBackupRemove(w http.ResponseWriter, r *http.Request) { c, ok := s.apiBackupConn(w, r) if !ok { return } if err := s.removeBackupServer(r.Context(), apiUser(r).Username, c); err != nil { s.writeAPIErr(w, r, fail(500, err)) return } writeJSON(w, http.StatusNoContent, nil) } func (s *Server) apiAdminBackupAction(w http.ResponseWriter, r *http.Request) { c, ok := s.apiBackupConn(w, r) if !ok { return } in := map[string]any{} if r.ContentLength != 0 { if err := readJSON(r, &in); err != nil { s.writeAPIErr(w, r, fail(400, err)) return } } code, raw, err := s.backupAction(r.Context(), apiUser(r).Username, c, r.PathValue("name"), in) if err != nil { s.writeAPIErr(w, r, err) return } w.Header().Set("Content-Type", "application/json") w.WriteHeader(code) _, _ = w.Write(raw) } func unwrapFail(err error) error { var oe interface{ Unwrap() error } if errors.As(err, &oe) && oe.Unwrap() != nil { return oe.Unwrap() } return err }