// Package server is de backup server: sync, archieven, de API voor BlueGit // en de lokale beheer-API. package server import ( "context" "encoding/json" "errors" "fmt" "io" "log/slog" "net/http" "os" "path/filepath" "strings" "sync" "time" "git.timfalken.com/timfa/bluegit-backup/internal/archive" "git.timfalken.com/timfa/bluegit-backup/internal/config" "git.timfalken.com/timfa/bluegit-backup/internal/mirror" "git.timfalken.com/timfa/bluegit-backup/internal/protocol" "git.timfalken.com/timfa/bluegit-backup/internal/throttle" ) // Version wordt bij het bouwen gezet (-ldflags -X). var Version = "dev" // Server is één backup server voor één BlueGit. type Server struct { Cfg config.Config Log *slog.Logger // Now is de klok (tests). Now func() time.Time // HTTP is de client richting BlueGit (tests). HTTP *http.Client adminToken string serverID string limiter *throttle.Limiter mirror *mirror.Mirror archives *archive.Store // work beschermt de kopie: sync, archiveren, rollback en koppelen // gebeuren nooit tegelijk. work sync.Mutex mu sync.Mutex state State lastSync time.Time lastSyncErr string lastStats mirror.Stats syncs int notifies int lastArchive time.Time archiveErr string rollback RollbackStatus // bluegit is het protocol dat de gekoppelde BlueGit het laatst meldde. bluegit protocol.Peer bluegitKnown bool kick chan struct{} // settings is wat via webinterface, API of BlueGit is ingesteld. settings map[string]string restartPending bool sessions map[string]session loginFails map[string][]time.Time } // cfg is de huidige configuratie (instellingen kunnen tijdens het draaien // veranderen). func (s *Server) cfg() config.Config { s.mu.Lock() defer s.mu.Unlock() return s.Cfg } // RollbackStatus is de stand van de laatste rollback of restore. type RollbackStatus struct { State string `json:"state"` // idle | running | done | failed Archive string `json:"archive,omitempty"` Error string `json:"error,omitempty"` At time.Time `json:"at,omitempty"` } // New zet de mappen klaar en leest de koppeling. func New(cfg config.Config, log *slog.Logger) (*Server, error) { if log == nil { log = slog.New(slog.NewTextHandler(io.Discard, nil)) } if err := os.MkdirAll(cfg.DataDir, 0o750); err != nil { return nil, err } set, err := config.LoadSettings(cfg.DataDir) if err != nil { return nil, err } if err := cfg.Apply(set); err != nil { return nil, fmt.Errorf("%s: %w", config.SettingsFile, err) } s := &Server{Cfg: cfg, Log: log, Now: time.Now, kick: make(chan struct{}, 1), settings: set, sessions: map[string]session{}} if s.adminToken, err = secretFile(cfg.DataDir, "admin.token", "bba_"); err != nil { return nil, err } if s.serverID, err = secretFile(cfg.DataDir, "server_id", ""); err != nil { return nil, err } if s.state, err = loadState(cfg.DataDir); err != nil { return nil, err } s.limiter = throttle.New(cfg.RateLimitKiB << 10) s.mirror = &mirror.Mirror{Dir: filepath.Join(cfg.DataDir, "mirror"), Index: filepath.Join(cfg.DataDir, "mirror.index.json")} s.archives = &archive.Store{Dir: filepath.Join(cfg.DataDir, "archives")} _ = os.RemoveAll(filepath.Join(cfg.DataDir, "tmp")) if list, _ := s.archives.List(); len(list) > 0 { s.lastArchive = list[0].CreatedAt } s.rollback.State = "idle" return s, nil } // SetFree vervangt de vrije-ruimtemeting (tests). func (s *Server) SetFree(f func(string) (uint64, error)) { s.archives.Free = f } // AdminToken is het lokale beheertoken. func (s *Server) AdminToken() string { return s.adminToken } func (s *Server) now() time.Time { return s.Now() } func (s *Server) remote(st State) *mirror.Remote { return &mirror.Remote{URL: st.BlueGitURL, Key: st.Key, HTTP: s.HTTP, Limiter: s.limiter, Version: Version, OnPeer: s.setBlueGit} } // setBlueGit legt het protocol van BlueGit vast. func (s *Server) setBlueGit(p protocol.Peer) { s.mu.Lock() changed := !s.bluegitKnown || s.bluegit != p s.bluegit, s.bluegitKnown = p, true s.mu.Unlock() if changed && p.Compat() != protocol.CompatOK { s.Log.Warn("niet compatibel met BlueGit", "compat", p.Compat(), "bluegit_protocol", p.Protocol, "bluegit_min", p.MinProtocol, "protocol", protocol.Protocol(), "min", protocol.MinProtocol()) } } // compat is "" (nog onbekend), ok, bluegit_too_old of backup_too_old. func (s *Server) compat() (string, protocol.Peer) { s.mu.Lock() defer s.mu.Unlock() if !s.bluegitKnown { return "", s.bluegit } return s.bluegit.Compat(), s.bluegit } // compatMessage zegt wie er geüpdatet moet worden (leeg als alles past). func compatMessage(c string, p protocol.Peer) string { switch c { case protocol.CompatBlueGitTooOld: return fmt.Sprintf("niet compatibel: 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()) case protocol.CompatBackupTooOld: return fmt.Sprintf("niet compatibel: 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) } return "" } // ErrIncompatible: BlueGit en deze backup server passen niet bij elkaar. var ErrIncompatible = errors.New("niet compatibel") // checkCompat vraagt info op bij BlueGit en weigert als de protocollen niet // passen. Aanroepen vóór elke sync, rollback of restore. func (s *Server) checkCompat(ctx context.Context, rem *mirror.Remote) error { info, err := rem.Info(ctx) if err != nil { return err } s.setBlueGit(info.Peer()) if c, p := s.compat(); c != protocol.CompatOK { return fmt.Errorf("%w: %s", ErrIncompatible, compatMessage(c, p)) } return nil } func (s *Server) getState() State { s.mu.Lock() defer s.mu.Unlock() return s.state } // Run start de achtergrondtaken tot ctx klaar is. func (s *Server) Run(ctx context.Context) { go s.syncLoop(ctx) go s.archiveLoop(ctx) } // Kick vraagt om een sync (na een melding). func (s *Server) Kick() { select { case s.kick <- struct{}{}: default: } } func (s *Server) syncLoop(ctx context.Context) { s.Kick() // meteen na de start for { s.mu.Lock() next := s.Cfg.FullSyncInterval.Duration - s.now().Sub(s.lastSync) s.mu.Unlock() if next < 0 { next = 0 } full := time.NewTimer(next) select { case <-ctx.Done(): full.Stop() return case <-full.C: case <-s.kick: full.Stop() } s.mu.Lock() wait := s.Cfg.MinSyncInterval.Duration - s.now().Sub(s.lastSync) s.mu.Unlock() if wait > 0 { select { case <-ctx.Done(): return case <-time.After(wait): } } // Meldingen die in de tussentijd binnenkwamen, zitten in deze sync. select { case <-s.kick: default: } _, _ = s.SyncNow(ctx) } } // SyncNow synchroniseert één keer. func (s *Server) SyncNow(ctx context.Context) (mirror.Stats, error) { st := s.getState() if !st.Connected() { return mirror.Stats{}, errors.New("geen BlueGit gekoppeld") } s.work.Lock() defer s.work.Unlock() st = s.getState() if !st.Connected() { return mirror.Stats{}, errors.New("geen BlueGit gekoppeld") } rem := s.remote(st) var stats mirror.Stats err := s.checkCompat(ctx, rem) if err == nil { stats, err = s.mirror.Sync(ctx, rem) } s.mu.Lock() s.lastSync = s.now() s.syncs++ s.lastStats = stats if err != nil { s.lastSyncErr = err.Error() } else { s.lastSyncErr = "" } s.mu.Unlock() if err != nil { s.Log.Warn("sync mislukt", "err", err) } else if stats.Downloaded > 0 || stats.Deleted > 0 { s.Log.Info("sync", "files", stats.Files, "downloaded", stats.Downloaded, "bytes", stats.Bytes, "deleted", stats.Deleted) } return stats, err } func (s *Server) archiveLoop(ctx context.Context) { for { select { case <-ctx.Done(): return case <-time.After(s.tick()): } s.mu.Lock() due := s.now().Sub(s.lastArchive) >= s.Cfg.ArchiveInterval.Duration synced := !s.lastSync.IsZero() && s.lastSyncErr == "" s.mu.Unlock() if due && synced { if _, err := s.ArchiveNow(); err != nil { s.Log.Warn("archief mislukt", "err", err) } } if _, err := s.Prune(); err != nil { s.Log.Warn("opruimen mislukt", "err", err) } } } // tick is hoe vaak de archieflus kijkt: een minuut, of korter bij een kort interval. func (s *Server) tick() time.Duration { d := s.cfg().ArchiveInterval.Duration / 4 if d > time.Minute { d = time.Minute } if d < 100*time.Millisecond { d = 100 * time.Millisecond } return d } // ArchiveNow comprimeert de hele kopie tot een nieuw archief. func (s *Server) ArchiveNow() (archive.Archive, error) { s.work.Lock() defer s.work.Unlock() if s.mirror.Empty() { return archive.Archive{}, errors.New("de kopie is nog leeg") } now := s.now() a, removed, err := s.archives.Create(s.mirror.Dir, now, s.mirror.Size(), s.minFree()) s.mu.Lock() if err != nil { s.archiveErr = err.Error() } else { s.archiveErr = "" s.lastArchive = now } s.mu.Unlock() for _, r := range removed { s.Log.Info("archief verwijderd: schijf vol", "archive", r) } if err != nil { return a, err } s.Log.Info("archief gemaakt", "archive", a.Name, "bytes", a.Size) if pr, err := s.archives.Prune(now, s.cfg().RetentionDays, s.minFree()); err == nil { for _, r := range pr { s.Log.Info("archief verwijderd", "archive", r) } } return a, nil } func (s *Server) minFree() uint64 { return uint64(s.cfg().MinFreeMB) << 20 } // Prune past de bewaarregels toe. func (s *Server) Prune() ([]string, error) { s.work.Lock() defer s.work.Unlock() removed, err := s.archives.Prune(s.now(), s.cfg().RetentionDays, s.minFree()) for _, r := range removed { s.Log.Info("archief verwijderd", "archive", r) } return removed, err } func writeJSON(w http.ResponseWriter, code int, v any) { w.Header().Set("Content-Type", "application/json") w.Header().Set("Cache-Control", "no-store") w.WriteHeader(code) if v != nil { _ = json.NewEncoder(w).Encode(v) } } func writeErr(w http.ResponseWriter, code int, msg string) { writeJSON(w, code, map[string]string{"error": msg}) } type ctxBody struct{} // signed controleert de HMAC-handtekening van de gekoppelde BlueGit. func (s *Server) signed(h http.HandlerFunc) http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { st := s.getState() if !st.Connected() { writeErr(w, http.StatusUnauthorized, "niet gekoppeld") return } body, err := io.ReadAll(io.LimitReader(r.Body, 1<<20)) if err != nil { writeErr(w, 400, "body") return } if r.Header.Get(protocol.HeaderInstance) != st.InstanceID { writeErr(w, http.StatusUnauthorized, "andere BlueGit-instantie") return } if err := protocol.Verify(r, protocol.SigningSecret(st.Key), body, s.now()); err != nil { writeErr(w, http.StatusUnauthorized, err.Error()) return } // Zonder koppen is het een BlueGit van vóór de protocolversie. p, _ := protocol.BlueGitFromHeader(r.Header) s.setBlueGit(p) r = r.WithContext(context.WithValue(r.Context(), ctxBody{}, body)) h(w, r) } } func bodyOf(r *http.Request) []byte { if b, ok := r.Context().Value(ctxBody{}).([]byte); ok { return b } b, _ := io.ReadAll(io.LimitReader(r.Body, 1<<20)) return b } func (s *Server) apiNotify(w http.ResponseWriter, r *http.Request) { s.mu.Lock() s.notifies++ s.mu.Unlock() s.Kick() w.WriteHeader(http.StatusNoContent) } func (s *Server) apiArchives(w http.ResponseWriter, r *http.Request) { list, err := s.archives.List() if err != nil { writeErr(w, 500, err.Error()) return } writeJSON(w, 200, map[string]any{"archives": list}) } // Status is wat GET /api/v1/status en de CLI tonen. type Status struct { Version string `json:"version"` ServerID string `json:"server_id"` BlueGitURL string `json:"bluegit_url,omitempty"` InstanceID string `json:"instance_id,omitempty"` Connected bool `json:"connected"` LastSync time.Time `json:"last_sync,omitempty"` SyncError string `json:"sync_error,omitempty"` LastStats mirror.Stats `json:"last_stats"` Syncs int `json:"syncs"` Notifies int `json:"notifies"` MirrorBytes int64 `json:"mirror_bytes"` Archives int `json:"archives"` LastArchive time.Time `json:"last_archive,omitempty"` ArchiveError string `json:"archive_error,omitempty"` Interval string `json:"archive_interval"` RetentionDays int `json:"retention_days"` RateLimitKiB int64 `json:"rate_limit_kib"` Rollback RollbackStatus `json:"rollback"` // Protocol van deze server en van BlueGit; Compat is "" (nog // onbekend), ok, bluegit_too_old of backup_too_old. Protocol int `json:"protocol"` MinProtocol int `json:"min_protocol"` BlueGitProtocol int `json:"bluegit_protocol,omitempty"` BlueGitMinProtocol int `json:"bluegit_min_protocol,omitempty"` BlueGitVersion string `json:"bluegit_version,omitempty"` Compat string `json:"compat"` CompatMessage string `json:"compat_message,omitempty"` } // Status geeft de huidige stand. func (s *Server) Status() Status { list, _ := s.archives.List() compat, peer := s.compat() s.mu.Lock() defer s.mu.Unlock() st := Status{ Version: Version, ServerID: s.serverID, BlueGitURL: s.state.BlueGitURL, InstanceID: s.state.InstanceID, Connected: s.state.Connected(), LastSync: s.lastSync, SyncError: s.lastSyncErr, LastStats: s.lastStats, Syncs: s.syncs, Notifies: s.notifies, MirrorBytes: s.mirror.Size(), Archives: len(list), LastArchive: s.lastArchive, ArchiveError: s.archiveErr, Interval: s.Cfg.ArchiveInterval.String(), RetentionDays: s.Cfg.RetentionDays, RateLimitKiB: s.Cfg.RateLimitKiB, Rollback: s.rollback, Protocol: protocol.Protocol(), MinProtocol: protocol.MinProtocol(), Compat: compat, CompatMessage: compatMessage(compat, peer), } if s.bluegitKnown { st.BlueGitProtocol, st.BlueGitMinProtocol, st.BlueGitVersion = peer.Protocol, peer.MinProtocol, peer.Version } return st } func (s *Server) apiStatus(w http.ResponseWriter, r *http.Request) { writeJSON(w, 200, s.Status()) } // ---------- koppelen ---------- // ConnectRequest is POST /api/v1/admin/connect. type ConnectRequest struct { URL string `json:"url"` Key string `json:"key"` // OnConflict is leeg, "wipe" of "restore". Leeg en een andere BlueGit // dan de vorige: 409 met de keuzes. OnConflict string `json:"on_conflict"` } // ConflictError is het 409-antwoord bij een andere BlueGit. type ConflictError struct { Conflict bool `json:"conflict"` Error string `json:"error"` PreviousURL string `json:"previous_url"` PreviousInstance string `json:"previous_instance"` NewInstance string `json:"new_instance"` Archives int `json:"archives"` Choices []string `json:"choices"` } var errBadRequest = errors.New("ongeldig verzoek") // Connect koppelt deze server aan een BlueGit. Er is er altijd hoogstens één. func (s *Server) Connect(ctx context.Context, in ConnectRequest) (map[string]any, *ConflictError, error) { in.URL = strings.TrimRight(strings.TrimSpace(in.URL), "/") in.Key = strings.TrimSpace(in.Key) if !strings.HasPrefix(in.URL, "http://") && !strings.HasPrefix(in.URL, "https://") { return nil, nil, fmt.Errorf("%w: url moet met http:// of https:// beginnen", errBadRequest) } if !strings.HasPrefix(in.Key, protocol.KeyPrefix) { return nil, nil, fmt.Errorf("%w: de Backupserver-Key begint met %s", errBadRequest, protocol.KeyPrefix) } switch in.OnConflict { case "", "wipe", "restore": default: return nil, nil, fmt.Errorf("%w: on_conflict moet wipe of restore zijn", errBadRequest) } pub := s.cfg().PublicURL if pub == "" { return nil, nil, fmt.Errorf("%w: zet public_url in de configuratie; BlueGit moet deze server kunnen bereiken", errBadRequest) } s.work.Lock() defer s.work.Unlock() rem := &mirror.Remote{URL: in.URL, Key: in.Key, HTTP: s.HTTP, Limiter: s.limiter, Version: Version, OnPeer: s.setBlueGit} info, err := rem.Info(ctx) if err != nil { return nil, nil, err } // Ook bij een niet-passende BlueGit koppelen we, zodat BlueGit het zijn // beheerders kan laten zien; synchroniseren en terugzetten gebeurt dan niet. s.setBlueGit(info.Peer()) compat := info.Peer().Compat() old := s.getState() list, _ := s.archives.List() hasData := !s.mirror.Empty() || len(list) > 0 other := old.InstanceID != "" && old.InstanceID != info.InstanceID && hasData mode := "" if other { if in.OnConflict == "" { return nil, &ConflictError{ Conflict: true, Error: "deze backup server hoort bij een andere BlueGit", PreviousURL: old.BlueGitURL, PreviousInstance: old.InstanceID, NewInstance: info.InstanceID, Archives: len(list), Choices: []string{"wipe", "restore"}, }, nil } mode = in.OnConflict } if mode == "wipe" { if err := s.mirror.Wipe(); err != nil { return nil, nil, err } if err := s.archives.DeleteAll(); err != nil { return nil, nil, err } s.mu.Lock() s.lastArchive = time.Time{} s.mu.Unlock() s.Log.Warn("oude backups verwijderd voor een nieuwe BlueGit", "old", old.InstanceID, "new", info.InstanceID) } if mode == "restore" && compat != protocol.CompatOK { return nil, nil, fmt.Errorf("%w: %s", ErrIncompatible, compatMessage(compat, info.Peer())) } if mode == "restore" && s.mirror.Empty() { return nil, nil, fmt.Errorf("%w: de kopie is leeg; er is niets om terug te zetten", errBadRequest) } if err := rem.Connect(ctx, pub, s.serverID); err != nil { return nil, nil, err } st := State{BlueGitURL: in.URL, Key: in.Key, InstanceID: info.InstanceID, ConnectedAt: s.now().UTC()} if err := saveState(s.Cfg.DataDir, st); err != nil { return nil, nil, err } s.mu.Lock() s.state = st s.mu.Unlock() s.Log.Info("gekoppeld", "bluegit", in.URL, "instance", info.InstanceID, "mode", mode) out := map[string]any{"instance_id": info.InstanceID, "bluegit_url": in.URL, "mode": mode, "compat": compat} if msg := compatMessage(compat, info.Peer()); msg != "" { out["warning"] = msg } if mode == "restore" { if err := s.sendMirror(ctx, rem, "restore"); err != nil { return nil, nil, fmt.Errorf("terugzetten naar de nieuwe BlueGit mislukt: %w", err) } out["restored"] = true } s.Kick() return out, nil, nil } // sendMirror stuurt de hele kopie als tar.gz naar BlueGit en wacht tot die // herstart is. Aanroepen met s.work vast. func (s *Server) sendMirror(ctx context.Context, rem *mirror.Remote, label string) error { s.setRollback(RollbackStatus{State: "running", Archive: label, At: s.now().UTC()}) pr, pw := io.Pipe() go func() { pw.CloseWithError(archive.WriteTarGz(pw, s.mirror.Dir)) }() if err := rem.Restore(ctx, pr); err != nil { pr.CloseWithError(err) s.setRollback(RollbackStatus{State: "failed", Archive: label, Error: err.Error(), At: s.now().UTC()}) return err } if err := rem.WaitUp(ctx, 3*time.Minute); err != nil { s.setRollback(RollbackStatus{State: "failed", Archive: label, Error: err.Error(), At: s.now().UTC()}) return err } s.setRollback(RollbackStatus{State: "done", Archive: label, At: s.now().UTC()}) return nil } func (s *Server) setRollback(r RollbackStatus) { s.mu.Lock() s.rollback = r s.mu.Unlock() } // ---------- rollback ---------- func (s *Server) apiRollback(w http.ResponseWriter, r *http.Request) { var in struct { Archive string `json:"archive"` } if err := json.Unmarshal(bodyOf(r), &in); err != nil || !archive.ValidName(in.Archive) { writeErr(w, 400, "ongeldige archiefnaam") return } code, out := s.startRollback(in.Archive) writeJSON(w, code, out) } // Rollback pakt een archief uit, vervangt daarmee de draaiende kopie en // stuurt die naar BlueGit. Lukt het sturen niet, dan komt de oude kopie // terug, zodat kopie en BlueGit gelijk blijven. func (s *Server) Rollback(ctx context.Context, name string) error { s.work.Lock() defer s.work.Unlock() fail := func(err error) error { s.setRollback(RollbackStatus{State: "failed", Archive: name, Error: err.Error(), At: s.now().UTC()}) return err } st := s.getState() if !st.Connected() { return fail(errors.New("geen BlueGit gekoppeld")) } if err := s.checkCompat(ctx, s.remote(st)); err != nil { return fail(err) } src, err := s.archives.Path(name) if err != nil { return fail(err) } fresh := filepath.Join(s.Cfg.DataDir, "mirror.rollback") old := filepath.Join(s.Cfg.DataDir, "mirror.old") _ = os.RemoveAll(fresh) _ = os.RemoveAll(old) if err := archive.Extract(src, fresh); err != nil { _ = os.RemoveAll(fresh) return fail(fmt.Errorf("uitpakken: %w", err)) } oldIndex, _ := os.ReadFile(s.mirror.Index) if err := os.Rename(s.mirror.Dir, old); err != nil && !errors.Is(err, os.ErrNotExist) { return fail(err) } if err := os.Rename(fresh, s.mirror.Dir); err != nil { _ = os.Rename(old, s.mirror.Dir) return fail(err) } if err := s.mirror.RebuildIndex(); err != nil { return fail(err) } if err := s.sendMirror(ctx, s.remote(st), name); err != nil { // Terug naar de kopie van vóór de rollback. _ = os.RemoveAll(s.mirror.Dir) _ = os.Rename(old, s.mirror.Dir) _ = os.WriteFile(s.mirror.Index, oldIndex, 0o600) s.setRollback(RollbackStatus{State: "failed", Archive: name, Error: err.Error(), At: s.now().UTC()}) return err } _ = os.RemoveAll(old) s.Log.Warn("rollback klaar", "archive", name) s.Kick() return nil }