BlueGit

timfa bluegit

Files

bluegit / internal / server / backup.go

backup.go

backup.go 12.9 KiB Download Raw
1package server
2
3import (
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).
26const maxRestoreBytes = 64 << 30
27
28var (
29 restoreBusy atomic.Bool
30 backupFails updateLimiter
31)
32
33// BackupView is de stand op Beheer > Backup.
34type 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
43func (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
51func (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).
56func (s *Server) BackupManager() *backup.Manager {
57 s.backupInit()
58 return s.backupMgr
59}
60
61// BackupChanged meldt een wijziging aan de gekoppelde backup server.
62func (s *Server) BackupChanged() {
63 if s.StateDir == "" {
64 return
65 }
66 s.backupInit()
67 s.backupNote.Changed()
68}
69
70func (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
77func (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.
92func (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
111func 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.
116func (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
138func (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
151func (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
177func (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
191func (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.
216func (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
249func (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
270func (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
284func (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
305func (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
320func (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
342func (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
357func 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
367func (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
390func (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
407func (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
420func (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}