BlueGit

timfa bluegit

Files

bluegit / internal / backupserver / server / server.go

server.go

server.go 21.5 KiB Download Raw
1// Package server is de backup server: sync, archieven, de API voor BlueGit
2// en de lokale beheer-API.
3package server
4
5import (
6 "context"
7 "crypto/subtle"
8 "encoding/json"
9 "errors"
10 "fmt"
11 "io"
12 "log/slog"
13 "net/http"
14 "os"
15 "path/filepath"
16 "strings"
17 "sync"
18 "time"
19
20 "git.timfalken.com/timfa/bluegit-backup/internal/archive"
21 "git.timfalken.com/timfa/bluegit-backup/internal/config"
22 "git.timfalken.com/timfa/bluegit-backup/internal/mirror"
23 "git.timfalken.com/timfa/bluegit-backup/internal/protocol"
24 "git.timfalken.com/timfa/bluegit-backup/internal/throttle"
25)
26
27// Version wordt bij het bouwen gezet (-ldflags -X).
28var Version = "dev"
29
30// Server is één backup server voor één BlueGit.
31type Server struct {
32 Cfg config.Config
33 Log *slog.Logger
34 // Now is de klok (tests).
35 Now func() time.Time
36 // HTTP is de client richting BlueGit (tests).
37 HTTP *http.Client
38
39 adminToken string
40 serverID string
41 limiter *throttle.Limiter
42 mirror *mirror.Mirror
43 archives *archive.Store
44
45 // work beschermt de kopie: sync, archiveren, rollback en koppelen
46 // gebeuren nooit tegelijk.
47 work sync.Mutex
48
49 mu sync.Mutex
50 state State
51 lastSync time.Time
52 lastSyncErr string
53 lastStats mirror.Stats
54 syncs int
55 notifies int
56 lastArchive time.Time
57 archiveErr string
58 rollback RollbackStatus
59
60 kick chan struct{}
61}
62
63// RollbackStatus is de stand van de laatste rollback of restore.
64type RollbackStatus struct {
65 State string `json:"state"` // idle | running | done | failed
66 Archive string `json:"archive,omitempty"`
67 Error string `json:"error,omitempty"`
68 At time.Time `json:"at,omitempty"`
69}
70
71// New zet de mappen klaar en leest de koppeling.
72func New(cfg config.Config, log *slog.Logger) (*Server, error) {
73 if log == nil {
74 log = slog.New(slog.NewTextHandler(io.Discard, nil))
75 }
76 if err := os.MkdirAll(cfg.DataDir, 0o750); err != nil {
77 return nil, err
78 }
79 s := &Server{Cfg: cfg, Log: log, Now: time.Now, kick: make(chan struct{}, 1)}
80 var err error
81 if s.adminToken, err = secretFile(cfg.DataDir, "admin.token", "bba_"); err != nil {
82 return nil, err
83 }
84 if s.serverID, err = secretFile(cfg.DataDir, "server_id", ""); err != nil {
85 return nil, err
86 }
87 if s.state, err = loadState(cfg.DataDir); err != nil {
88 return nil, err
89 }
90 s.limiter = throttle.New(cfg.RateLimitKiB << 10)
91 s.mirror = &mirror.Mirror{Dir: filepath.Join(cfg.DataDir, "mirror"), Index: filepath.Join(cfg.DataDir, "mirror.index.json")}
92 s.archives = &archive.Store{Dir: filepath.Join(cfg.DataDir, "archives")}
93 _ = os.RemoveAll(filepath.Join(cfg.DataDir, "tmp"))
94 if list, _ := s.archives.List(); len(list) > 0 {
95 s.lastArchive = list[0].CreatedAt
96 }
97 s.rollback.State = "idle"
98 return s, nil
99}
100
101// SetFree vervangt de vrije-ruimtemeting (tests).
102func (s *Server) SetFree(f func(string) (uint64, error)) { s.archives.Free = f }
103
104// AdminToken is het lokale beheertoken.
105func (s *Server) AdminToken() string { return s.adminToken }
106
107func (s *Server) now() time.Time { return s.Now() }
108
109func (s *Server) remote(st State) *mirror.Remote {
110 return &mirror.Remote{URL: st.BlueGitURL, Key: st.Key, HTTP: s.HTTP, Limiter: s.limiter}
111}
112
113func (s *Server) getState() State {
114 s.mu.Lock()
115 defer s.mu.Unlock()
116 return s.state
117}
118
119// Run start de achtergrondtaken tot ctx klaar is.
120func (s *Server) Run(ctx context.Context) {
121 go s.syncLoop(ctx)
122 go s.archiveLoop(ctx)
123}
124
125// Kick vraagt om een sync (na een melding).
126func (s *Server) Kick() {
127 select {
128 case s.kick <- struct{}{}:
129 default:
130 }
131}
132
133func (s *Server) syncLoop(ctx context.Context) {
134 full := time.NewTicker(s.Cfg.FullSyncInterval.Duration)
135 defer full.Stop()
136 s.Kick() // meteen na de start
137 for {
138 select {
139 case <-ctx.Done():
140 return
141 case <-full.C:
142 case <-s.kick:
143 }
144 s.mu.Lock()
145 wait := s.Cfg.MinSyncInterval.Duration - s.now().Sub(s.lastSync)
146 s.mu.Unlock()
147 if wait > 0 {
148 select {
149 case <-ctx.Done():
150 return
151 case <-time.After(wait):
152 }
153 }
154 // Meldingen die in de tussentijd binnenkwamen, zitten in deze sync.
155 select {
156 case <-s.kick:
157 default:
158 }
159 _, _ = s.SyncNow(ctx)
160 }
161}
162
163// SyncNow synchroniseert één keer.
164func (s *Server) SyncNow(ctx context.Context) (mirror.Stats, error) {
165 st := s.getState()
166 if !st.Connected() {
167 return mirror.Stats{}, errors.New("geen BlueGit gekoppeld")
168 }
169 s.work.Lock()
170 defer s.work.Unlock()
171 st = s.getState()
172 if !st.Connected() {
173 return mirror.Stats{}, errors.New("geen BlueGit gekoppeld")
174 }
175 stats, err := s.mirror.Sync(ctx, s.remote(st))
176 s.mu.Lock()
177 s.lastSync = s.now()
178 s.syncs++
179 s.lastStats = stats
180 if err != nil {
181 s.lastSyncErr = err.Error()
182 } else {
183 s.lastSyncErr = ""
184 }
185 s.mu.Unlock()
186 if err != nil {
187 s.Log.Warn("sync mislukt", "err", err)
188 } else if stats.Downloaded > 0 || stats.Deleted > 0 {
189 s.Log.Info("sync", "files", stats.Files, "downloaded", stats.Downloaded, "bytes", stats.Bytes, "deleted", stats.Deleted)
190 }
191 return stats, err
192}
193
194func (s *Server) archiveLoop(ctx context.Context) {
195 t := time.NewTicker(s.tick())
196 defer t.Stop()
197 for {
198 select {
199 case <-ctx.Done():
200 return
201 case <-t.C:
202 }
203 s.mu.Lock()
204 due := s.now().Sub(s.lastArchive) >= s.Cfg.ArchiveInterval.Duration
205 synced := !s.lastSync.IsZero() && s.lastSyncErr == ""
206 s.mu.Unlock()
207 if due && synced {
208 if _, err := s.ArchiveNow(); err != nil {
209 s.Log.Warn("archief mislukt", "err", err)
210 }
211 }
212 if _, err := s.Prune(); err != nil {
213 s.Log.Warn("opruimen mislukt", "err", err)
214 }
215 }
216}
217
218// tick is hoe vaak de archieflus kijkt: een minuut, of korter bij een kort interval.
219func (s *Server) tick() time.Duration {
220 d := s.Cfg.ArchiveInterval.Duration / 4
221 if d > time.Minute {
222 d = time.Minute
223 }
224 if d < 100*time.Millisecond {
225 d = 100 * time.Millisecond
226 }
227 return d
228}
229
230// ArchiveNow comprimeert de hele kopie tot een nieuw archief.
231func (s *Server) ArchiveNow() (archive.Archive, error) {
232 s.work.Lock()
233 defer s.work.Unlock()
234 if s.mirror.Empty() {
235 return archive.Archive{}, errors.New("de kopie is nog leeg")
236 }
237 now := s.now()
238 a, removed, err := s.archives.Create(s.mirror.Dir, now, s.mirror.Size(), s.minFree())
239 s.mu.Lock()
240 if err != nil {
241 s.archiveErr = err.Error()
242 } else {
243 s.archiveErr = ""
244 s.lastArchive = now
245 }
246 s.mu.Unlock()
247 for _, r := range removed {
248 s.Log.Info("archief verwijderd: schijf vol", "archive", r)
249 }
250 if err != nil {
251 return a, err
252 }
253 s.Log.Info("archief gemaakt", "archive", a.Name, "bytes", a.Size)
254 if pr, err := s.archives.Prune(now, s.Cfg.RetentionDays, s.minFree()); err == nil {
255 for _, r := range pr {
256 s.Log.Info("archief verwijderd", "archive", r)
257 }
258 }
259 return a, nil
260}
261
262func (s *Server) minFree() uint64 { return uint64(s.Cfg.MinFreeMB) << 20 }
263
264// Prune past de bewaarregels toe.
265func (s *Server) Prune() ([]string, error) {
266 s.work.Lock()
267 defer s.work.Unlock()
268 removed, err := s.archives.Prune(s.now(), s.Cfg.RetentionDays, s.minFree())
269 for _, r := range removed {
270 s.Log.Info("archief verwijderd", "archive", r)
271 }
272 return removed, err
273}
274
275// ---------- HTTP ----------
276
277// Handler is de HTTP-API.
278func (s *Server) Handler() http.Handler {
279 mux := http.NewServeMux()
280 mux.HandleFunc("GET /healthz", func(w http.ResponseWriter, r *http.Request) { _, _ = w.Write([]byte("ok\n")) })
281 // Van BlueGit, ondertekend.
282 mux.HandleFunc("POST /api/v1/notify", s.signed(s.apiNotify))
283 mux.HandleFunc("GET /api/v1/archives", s.signed(s.apiArchives))
284 mux.HandleFunc("GET /api/v1/status", s.signed(s.apiStatus))
285 mux.HandleFunc("POST /api/v1/rollback", s.signed(s.apiRollback))
286 // Lokaal beheer, met admin.token.
287 mux.HandleFunc("GET /api/v1/admin/status", s.admin(s.apiStatus))
288 mux.HandleFunc("GET /api/v1/admin/archives", s.admin(s.apiArchives))
289 mux.HandleFunc("POST /api/v1/admin/connect", s.admin(s.apiConnect))
290 mux.HandleFunc("POST /api/v1/admin/sync", s.admin(s.apiSync))
291 mux.HandleFunc("POST /api/v1/admin/archive", s.admin(s.apiArchiveNow))
292 mux.HandleFunc("POST /api/v1/admin/prune", s.admin(s.apiPrune))
293 mux.HandleFunc("POST /api/v1/admin/self-update", s.selfUpdate)
294 return mux
295}
296
297func writeJSON(w http.ResponseWriter, code int, v any) {
298 w.Header().Set("Content-Type", "application/json")
299 w.Header().Set("Cache-Control", "no-store")
300 w.WriteHeader(code)
301 if v != nil {
302 _ = json.NewEncoder(w).Encode(v)
303 }
304}
305
306func writeErr(w http.ResponseWriter, code int, msg string) {
307 writeJSON(w, code, map[string]string{"error": msg})
308}
309
310type ctxBody struct{}
311
312// signed controleert de HMAC-handtekening van de gekoppelde BlueGit.
313func (s *Server) signed(h http.HandlerFunc) http.HandlerFunc {
314 return func(w http.ResponseWriter, r *http.Request) {
315 st := s.getState()
316 if !st.Connected() {
317 writeErr(w, http.StatusUnauthorized, "niet gekoppeld")
318 return
319 }
320 body, err := io.ReadAll(io.LimitReader(r.Body, 1<<20))
321 if err != nil {
322 writeErr(w, 400, "body")
323 return
324 }
325 if r.Header.Get(protocol.HeaderInstance) != st.InstanceID {
326 writeErr(w, http.StatusUnauthorized, "andere BlueGit-instantie")
327 return
328 }
329 if err := protocol.Verify(r, protocol.SigningSecret(st.Key), body, s.now()); err != nil {
330 writeErr(w, http.StatusUnauthorized, err.Error())
331 return
332 }
333 r = r.WithContext(context.WithValue(r.Context(), ctxBody{}, body))
334 h(w, r)
335 }
336}
337
338func bodyOf(r *http.Request) []byte {
339 if b, ok := r.Context().Value(ctxBody{}).([]byte); ok {
340 return b
341 }
342 b, _ := io.ReadAll(io.LimitReader(r.Body, 1<<20))
343 return b
344}
345
346func (s *Server) admin(h http.HandlerFunc) http.HandlerFunc {
347 return func(w http.ResponseWriter, r *http.Request) {
348 tok := strings.TrimSpace(strings.TrimPrefix(r.Header.Get("Authorization"), "Bearer "))
349 if subtle.ConstantTimeCompare([]byte(tok), []byte(s.adminToken)) != 1 {
350 writeErr(w, http.StatusUnauthorized, "admin.token nodig")
351 return
352 }
353 h(w, r)
354 }
355}
356
357func (s *Server) apiNotify(w http.ResponseWriter, r *http.Request) {
358 s.mu.Lock()
359 s.notifies++
360 s.mu.Unlock()
361 s.Kick()
362 w.WriteHeader(http.StatusNoContent)
363}
364
365func (s *Server) apiArchives(w http.ResponseWriter, r *http.Request) {
366 list, err := s.archives.List()
367 if err != nil {
368 writeErr(w, 500, err.Error())
369 return
370 }
371 writeJSON(w, 200, map[string]any{"archives": list})
372}
373
374// Status is wat GET /api/v1/status en de CLI tonen.
375type Status struct {
376 Version string `json:"version"`
377 ServerID string `json:"server_id"`
378 BlueGitURL string `json:"bluegit_url,omitempty"`
379 InstanceID string `json:"instance_id,omitempty"`
380 Connected bool `json:"connected"`
381 LastSync time.Time `json:"last_sync,omitempty"`
382 SyncError string `json:"sync_error,omitempty"`
383 LastStats mirror.Stats `json:"last_stats"`
384 Syncs int `json:"syncs"`
385 Notifies int `json:"notifies"`
386 MirrorBytes int64 `json:"mirror_bytes"`
387 Archives int `json:"archives"`
388 LastArchive time.Time `json:"last_archive,omitempty"`
389 ArchiveError string `json:"archive_error,omitempty"`
390 Interval string `json:"archive_interval"`
391 RetentionDays int `json:"retention_days"`
392 RateLimitKiB int64 `json:"rate_limit_kib"`
393 Rollback RollbackStatus `json:"rollback"`
394}
395
396// Status geeft de huidige stand.
397func (s *Server) Status() Status {
398 list, _ := s.archives.List()
399 s.mu.Lock()
400 defer s.mu.Unlock()
401 return Status{
402 Version: Version, ServerID: s.serverID, BlueGitURL: s.state.BlueGitURL, InstanceID: s.state.InstanceID,
403 Connected: s.state.Connected(), LastSync: s.lastSync, SyncError: s.lastSyncErr, LastStats: s.lastStats,
404 Syncs: s.syncs, Notifies: s.notifies, MirrorBytes: s.mirror.Size(), Archives: len(list),
405 LastArchive: s.lastArchive, ArchiveError: s.archiveErr, Interval: s.Cfg.ArchiveInterval.String(),
406 RetentionDays: s.Cfg.RetentionDays, RateLimitKiB: s.Cfg.RateLimitKiB, Rollback: s.rollback,
407 }
408}
409
410func (s *Server) apiStatus(w http.ResponseWriter, r *http.Request) { writeJSON(w, 200, s.Status()) }
411
412func (s *Server) apiSync(w http.ResponseWriter, r *http.Request) {
413 stats, err := s.SyncNow(r.Context())
414 if err != nil {
415 writeErr(w, 502, err.Error())
416 return
417 }
418 writeJSON(w, 200, stats)
419}
420
421func (s *Server) apiArchiveNow(w http.ResponseWriter, r *http.Request) {
422 a, err := s.ArchiveNow()
423 if err != nil {
424 writeErr(w, 409, err.Error())
425 return
426 }
427 writeJSON(w, 201, a)
428}
429
430func (s *Server) apiPrune(w http.ResponseWriter, r *http.Request) {
431 removed, err := s.Prune()
432 if err != nil {
433 writeErr(w, 500, err.Error())
434 return
435 }
436 if removed == nil {
437 removed = []string{}
438 }
439 writeJSON(w, 200, map[string]any{"removed": removed})
440}
441
442// ---------- koppelen ----------
443
444// ConnectRequest is POST /api/v1/admin/connect.
445type ConnectRequest struct {
446 URL string `json:"url"`
447 Key string `json:"key"`
448 // OnConflict is leeg, "wipe" of "restore". Leeg en een andere BlueGit
449 // dan de vorige: 409 met de keuzes.
450 OnConflict string `json:"on_conflict"`
451}
452
453// ConflictError is het 409-antwoord bij een andere BlueGit.
454type ConflictError struct {
455 Conflict bool `json:"conflict"`
456 Error string `json:"error"`
457 PreviousURL string `json:"previous_url"`
458 PreviousInstance string `json:"previous_instance"`
459 NewInstance string `json:"new_instance"`
460 Archives int `json:"archives"`
461 Choices []string `json:"choices"`
462}
463
464func (s *Server) apiConnect(w http.ResponseWriter, r *http.Request) {
465 var in ConnectRequest
466 if err := json.Unmarshal(bodyOf(r), &in); err != nil {
467 writeErr(w, 400, "ongeldige JSON")
468 return
469 }
470 res, conflict, err := s.Connect(r.Context(), in)
471 if conflict != nil {
472 writeJSON(w, http.StatusConflict, conflict)
473 return
474 }
475 if err != nil {
476 var he *mirror.HTTPError
477 code := 502
478 if errors.As(err, &he) && he.Status == 401 {
479 code = 401
480 }
481 if errors.Is(err, errBadRequest) {
482 code = 400
483 }
484 writeErr(w, code, err.Error())
485 return
486 }
487 writeJSON(w, 200, res)
488}
489
490var errBadRequest = errors.New("ongeldig verzoek")
491
492// Connect koppelt deze server aan een BlueGit. Er is er altijd hoogstens één.
493func (s *Server) Connect(ctx context.Context, in ConnectRequest) (map[string]any, *ConflictError, error) {
494 in.URL = strings.TrimRight(strings.TrimSpace(in.URL), "/")
495 in.Key = strings.TrimSpace(in.Key)
496 if !strings.HasPrefix(in.URL, "http://") && !strings.HasPrefix(in.URL, "https://") {
497 return nil, nil, fmt.Errorf("%w: url moet met http:// of https:// beginnen", errBadRequest)
498 }
499 if !strings.HasPrefix(in.Key, protocol.KeyPrefix) {
500 return nil, nil, fmt.Errorf("%w: de Backupserver-Key begint met %s", errBadRequest, protocol.KeyPrefix)
501 }
502 switch in.OnConflict {
503 case "", "wipe", "restore":
504 default:
505 return nil, nil, fmt.Errorf("%w: on_conflict moet wipe of restore zijn", errBadRequest)
506 }
507 if s.Cfg.PublicURL == "" {
508 return nil, nil, fmt.Errorf("%w: zet public_url in de configuratie; BlueGit moet deze server kunnen bereiken", errBadRequest)
509 }
510 s.work.Lock()
511 defer s.work.Unlock()
512 rem := &mirror.Remote{URL: in.URL, Key: in.Key, HTTP: s.HTTP, Limiter: s.limiter}
513 info, err := rem.Info(ctx)
514 if err != nil {
515 return nil, nil, err
516 }
517 old := s.getState()
518 list, _ := s.archives.List()
519 hasData := !s.mirror.Empty() || len(list) > 0
520 other := old.InstanceID != "" && old.InstanceID != info.InstanceID && hasData
521 mode := ""
522 if other {
523 if in.OnConflict == "" {
524 return nil, &ConflictError{
525 Conflict: true, Error: "deze backup server hoort bij een andere BlueGit",
526 PreviousURL: old.BlueGitURL, PreviousInstance: old.InstanceID, NewInstance: info.InstanceID,
527 Archives: len(list), Choices: []string{"wipe", "restore"},
528 }, nil
529 }
530 mode = in.OnConflict
531 }
532 if mode == "wipe" {
533 if err := s.mirror.Wipe(); err != nil {
534 return nil, nil, err
535 }
536 if err := s.archives.DeleteAll(); err != nil {
537 return nil, nil, err
538 }
539 s.mu.Lock()
540 s.lastArchive = time.Time{}
541 s.mu.Unlock()
542 s.Log.Warn("oude backups verwijderd voor een nieuwe BlueGit", "old", old.InstanceID, "new", info.InstanceID)
543 }
544 if mode == "restore" && s.mirror.Empty() {
545 return nil, nil, fmt.Errorf("%w: de kopie is leeg; er is niets om terug te zetten", errBadRequest)
546 }
547 if err := rem.Connect(ctx, s.Cfg.PublicURL, s.serverID); err != nil {
548 return nil, nil, err
549 }
550 st := State{BlueGitURL: in.URL, Key: in.Key, InstanceID: info.InstanceID, ConnectedAt: s.now().UTC()}
551 if err := saveState(s.Cfg.DataDir, st); err != nil {
552 return nil, nil, err
553 }
554 s.mu.Lock()
555 s.state = st
556 s.mu.Unlock()
557 s.Log.Info("gekoppeld", "bluegit", in.URL, "instance", info.InstanceID, "mode", mode)
558 out := map[string]any{"instance_id": info.InstanceID, "bluegit_url": in.URL, "mode": mode}
559 if mode == "restore" {
560 if err := s.sendMirror(ctx, rem, "restore"); err != nil {
561 return nil, nil, fmt.Errorf("terugzetten naar de nieuwe BlueGit mislukt: %w", err)
562 }
563 out["restored"] = true
564 }
565 s.Kick()
566 return out, nil, nil
567}
568
569// sendMirror stuurt de hele kopie als tar.gz naar BlueGit en wacht tot die
570// herstart is. Aanroepen met s.work vast.
571func (s *Server) sendMirror(ctx context.Context, rem *mirror.Remote, label string) error {
572 s.setRollback(RollbackStatus{State: "running", Archive: label, At: s.now().UTC()})
573 pr, pw := io.Pipe()
574 go func() { pw.CloseWithError(archive.WriteTarGz(pw, s.mirror.Dir)) }()
575 if err := rem.Restore(ctx, pr); err != nil {
576 pr.CloseWithError(err)
577 s.setRollback(RollbackStatus{State: "failed", Archive: label, Error: err.Error(), At: s.now().UTC()})
578 return err
579 }
580 if err := rem.WaitUp(ctx, 3*time.Minute); err != nil {
581 s.setRollback(RollbackStatus{State: "failed", Archive: label, Error: err.Error(), At: s.now().UTC()})
582 return err
583 }
584 s.setRollback(RollbackStatus{State: "done", Archive: label, At: s.now().UTC()})
585 return nil
586}
587
588func (s *Server) setRollback(r RollbackStatus) {
589 s.mu.Lock()
590 s.rollback = r
591 s.mu.Unlock()
592}
593
594// ---------- rollback ----------
595
596func (s *Server) apiRollback(w http.ResponseWriter, r *http.Request) {
597 var in struct {
598 Archive string `json:"archive"`
599 }
600 if err := json.Unmarshal(bodyOf(r), &in); err != nil || !archive.ValidName(in.Archive) {
601 writeErr(w, 400, "ongeldige archiefnaam")
602 return
603 }
604 if _, err := s.archives.Path(in.Archive); err != nil {
605 writeErr(w, 404, err.Error())
606 return
607 }
608 s.mu.Lock()
609 busy := s.rollback.State == "running"
610 if !busy {
611 s.rollback = RollbackStatus{State: "running", Archive: in.Archive, At: s.now().UTC()}
612 }
613 s.mu.Unlock()
614 if busy {
615 writeErr(w, 409, "er loopt al een rollback")
616 return
617 }
618 s.Log.Warn("rollback gestart", "archive", in.Archive)
619 go func() {
620 if err := s.Rollback(context.Background(), in.Archive); err != nil {
621 s.Log.Error("rollback mislukt", "archive", in.Archive, "err", err)
622 }
623 }()
624 writeJSON(w, http.StatusAccepted, map[string]string{"state": "running", "archive": in.Archive})
625}
626
627// Rollback pakt een archief uit, vervangt daarmee de draaiende kopie en
628// stuurt die naar BlueGit. Lukt het sturen niet, dan komt de oude kopie
629// terug, zodat kopie en BlueGit gelijk blijven.
630func (s *Server) Rollback(ctx context.Context, name string) error {
631 s.work.Lock()
632 defer s.work.Unlock()
633 fail := func(err error) error {
634 s.setRollback(RollbackStatus{State: "failed", Archive: name, Error: err.Error(), At: s.now().UTC()})
635 return err
636 }
637 st := s.getState()
638 if !st.Connected() {
639 return fail(errors.New("geen BlueGit gekoppeld"))
640 }
641 src, err := s.archives.Path(name)
642 if err != nil {
643 return fail(err)
644 }
645 fresh := filepath.Join(s.Cfg.DataDir, "mirror.rollback")
646 old := filepath.Join(s.Cfg.DataDir, "mirror.old")
647 _ = os.RemoveAll(fresh)
648 _ = os.RemoveAll(old)
649 if err := archive.Extract(src, fresh); err != nil {
650 _ = os.RemoveAll(fresh)
651 return fail(fmt.Errorf("uitpakken: %w", err))
652 }
653 oldIndex, _ := os.ReadFile(s.mirror.Index)
654 if err := os.Rename(s.mirror.Dir, old); err != nil && !errors.Is(err, os.ErrNotExist) {
655 return fail(err)
656 }
657 if err := os.Rename(fresh, s.mirror.Dir); err != nil {
658 _ = os.Rename(old, s.mirror.Dir)
659 return fail(err)
660 }
661 if err := s.mirror.RebuildIndex(); err != nil {
662 return fail(err)
663 }
664 if err := s.sendMirror(ctx, s.remote(st), name); err != nil {
665 // Terug naar de kopie van vóór de rollback.
666 _ = os.RemoveAll(s.mirror.Dir)
667 _ = os.Rename(old, s.mirror.Dir)
668 _ = os.WriteFile(s.mirror.Index, oldIndex, 0o600)
669 s.setRollback(RollbackStatus{State: "failed", Archive: name, Error: err.Error(), At: s.now().UTC()})
670 return err
671 }
672 _ = os.RemoveAll(old)
673 s.Log.Warn("rollback klaar", "archive", name)
674 s.Kick()
675 return nil
676}
677
678// ---------- self-update ----------
679
680// UpdateStarter start de update-unit (tests zetten een stub).
681var UpdateStarter = func(ctx context.Context, ref string) error {
682 return startUpdateUnit(ctx, ref)
683}
684
685var updateHits = struct {
686 sync.Mutex
687 at []time.Time
688}{}
689
690func (s *Server) selfUpdate(w http.ResponseWriter, r *http.Request) {
691 tok := os.Getenv("BLUEGIT_BACKUP_UPDATE_TOKEN")
692 if tok == "" {
693 http.NotFound(w, r)
694 return
695 }
696 updateHits.Lock()
697 cut := time.Now().Add(-time.Minute)
698 keep := updateHits.at[:0]
699 for _, t := range updateHits.at {
700 if t.After(cut) {
701 keep = append(keep, t)
702 }
703 }
704 updateHits.at = append(keep, time.Now())
705 n := len(updateHits.at)
706 updateHits.Unlock()
707 if n > 5 {
708 writeErr(w, http.StatusTooManyRequests, "te veel verzoeken")
709 return
710 }
711 got := strings.TrimSpace(strings.TrimPrefix(r.Header.Get("Authorization"), "Bearer "))
712 if subtle.ConstantTimeCompare([]byte(got), []byte(tok)) != 1 {
713 writeErr(w, http.StatusUnauthorized, "unauthorized")
714 return
715 }
716 var in struct {
717 Ref string `json:"ref"`
718 }
719 _ = json.NewDecoder(io.LimitReader(r.Body, 4096)).Decode(&in)
720 if !validRef(in.Ref) {
721 writeErr(w, 400, "ref moet een volledige sha zijn")
722 return
723 }
724 if err := UpdateStarter(r.Context(), in.Ref); err != nil {
725 writeErr(w, 500, err.Error())
726 return
727 }
728 writeJSON(w, http.StatusAccepted, map[string]string{"ref": in.Ref, "state": "started"})
729}
730
731func validRef(ref string) bool {
732 if len(ref) != 40 {
733 return false
734 }
735 for _, c := range ref {
736 if !(c >= '0' && c <= '9' || c >= 'a' && c <= 'f') {
737 return false
738 }
739 }
740 return true
741}