BlueGit

timfa bluegit

Files

bluegit / internal / backupserver / server / server.go

server.go

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