BlueGit

timfa bluegit

Files

bluegit / internal / backupserver / server / server.go

server.go

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