// Package server is de backup server: sync, archieven, de API voor BlueGit // en de lokale beheer-API. package server import ( "context" "crypto/subtle" "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 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} } 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") } stats, err := s.mirror.Sync(ctx, s.remote(st)) 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 } 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"` } // Status geeft de huidige stand. func (s *Server) Status() Status { list, _ := s.archives.List() s.mu.Lock() defer s.mu.Unlock() return 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, } } 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} info, err := rem.Info(ctx) if err != nil { return nil, nil, err } 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" && 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} 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")) } 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 } // ---------- self-update ---------- // UpdateStarter start de update-unit (tests zetten een stub). var UpdateStarter = func(ctx context.Context, ref string) error { return startUpdateUnit(ctx, ref) } var updateHits = struct { sync.Mutex at []time.Time }{} func (s *Server) selfUpdate(w http.ResponseWriter, r *http.Request) { tok := os.Getenv("BLUEGIT_BACKUP_UPDATE_TOKEN") if tok == "" { http.NotFound(w, r) return } updateHits.Lock() cut := time.Now().Add(-time.Minute) keep := updateHits.at[:0] for _, t := range updateHits.at { if t.After(cut) { keep = append(keep, t) } } updateHits.at = append(keep, time.Now()) n := len(updateHits.at) updateHits.Unlock() if n > 5 { writeErr(w, http.StatusTooManyRequests, "te veel verzoeken") return } got := strings.TrimSpace(strings.TrimPrefix(r.Header.Get("Authorization"), "Bearer ")) if subtle.ConstantTimeCompare([]byte(got), []byte(tok)) != 1 { writeErr(w, http.StatusUnauthorized, "unauthorized") return } var in struct { Ref string `json:"ref"` } _ = json.NewDecoder(io.LimitReader(r.Body, 4096)).Decode(&in) if !validRef(in.Ref) { writeErr(w, 400, "ref moet een volledige sha zijn") return } if err := UpdateStarter(r.Context(), in.Ref); err != nil { writeErr(w, 500, err.Error()) return } writeJSON(w, http.StatusAccepted, map[string]string{"ref": in.Ref, "state": "started"}) } func validRef(ref string) bool { if len(ref) != 40 { return false } for _, c := range ref { if !(c >= '0' && c <= '9' || c >= 'a' && c <= 'f') { return false } } return true }