BlueGit

timfa bluegit

Files

bluegit / internal / backupserver / server / server.go

server.go

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