// Package archive maakt, bewaart, ruimt op en pakt archieven uit. // // Een archief is een tar.gz (PAX, mtimes in milliseconden) van de kopie met // logische paden (state/…, data/…), precies wat BlueGit bij een restore // aanneemt. Naam: bluegit-YYYYMMDD-HHMMSS.tar.gz in UTC. package archive import ( "archive/tar" "compress/gzip" "errors" "fmt" "io" "io/fs" "os" "path/filepath" "regexp" "sort" "strings" "time" "gitlab.com/Timfa/bluegit/internal/backupserver/protocol" ) var nameRE = regexp.MustCompile(`^bluegit-\d{8}-\d{6}(-\d{1,3})?\.tar\.gz$`) // ValidName zegt of name een archiefnaam is (geen pad, geen ..). func ValidName(name string) bool { return nameRE.MatchString(name) } // Archive is één archief op schijf. type Archive struct { Name string `json:"name"` CreatedAt time.Time `json:"created_at"` Size int64 `json:"size"` } // Store is de map met archieven. type Store struct { Dir string // Free geeft de vrije bytes op het bestandssysteem van Dir. Tests // zetten een nep-versie; nil gebruikt statfs. Free func(dir string) (uint64, error) } func (s *Store) free() (uint64, error) { if s.Free != nil { return s.Free(s.Dir) } return FreeBytes(s.Dir) } // List geeft de archieven, nieuwste eerst. func (s *Store) List() ([]Archive, error) { ents, err := os.ReadDir(s.Dir) if errors.Is(err, os.ErrNotExist) { return []Archive{}, nil } if err != nil { return nil, err } out := []Archive{} for _, e := range ents { if e.IsDir() || !ValidName(e.Name()) { continue } fi, err := e.Info() if err != nil { continue } out = append(out, Archive{Name: e.Name(), CreatedAt: createdAt(e.Name(), fi), Size: fi.Size()}) } sort.Slice(out, func(i, j int) bool { if out[i].CreatedAt.Equal(out[j].CreatedAt) { return out[i].Name > out[j].Name } return out[i].CreatedAt.After(out[j].CreatedAt) }) return out, nil } // createdAt neemt de mtime: die is gelijk aan de naam, maar tests en een // beheerder kunnen hem verzetten om de bewaartermijn te testen. func createdAt(name string, fi fs.FileInfo) time.Time { return fi.ModTime().UTC() } // Path geeft het pad van een bestaand archief. func (s *Store) Path(name string) (string, error) { if !ValidName(name) { return "", errors.New("ongeldige archiefnaam") } p := filepath.Join(s.Dir, name) if _, err := os.Stat(p); err != nil { return "", fmt.Errorf("archief %s bestaat niet", name) } return p, nil } // Delete verwijdert één archief. func (s *Store) Delete(name string) error { p, err := s.Path(name) if err != nil { return err } return os.Remove(p) } // DeleteAll verwijdert alle archieven. func (s *Store) DeleteAll() error { list, err := s.List() if err != nil { return err } for _, a := range list { if err := os.Remove(filepath.Join(s.Dir, a.Name)); err != nil { return err } } return nil } // Create schrijft een nieuw archief van mirrorDir. needBytes is een // schatting van de grootte; is er te weinig ruimte, dan gaan eerst oude // archieven weg (het nieuwste blijft). func (s *Store) Create(mirrorDir string, now time.Time, needBytes int64, minFree uint64) (Archive, []string, error) { if err := os.MkdirAll(s.Dir, 0o750); err != nil { return Archive{}, nil, err } var removed []string for { free, err := s.free() if err != nil || free >= uint64(needBytes)+minFree { break } // Het nieuwe archief wordt het nieuwste; daarvoor mag ook het // laatste oude weg. De draaiende kopie blijft altijd staan. name, ok, err := s.removeOldest(0) if err != nil { return Archive{}, removed, err } if !ok { return Archive{}, removed, fmt.Errorf("te weinig schijfruimte voor een archief (%d MB vrij, %d MB nodig)", free>>20, (uint64(needBytes)+minFree)>>20) } removed = append(removed, name) } base := "bluegit-" + now.UTC().Format("20060102-150405") name := base + ".tar.gz" for i := 1; ; i++ { if _, err := os.Stat(filepath.Join(s.Dir, name)); errors.Is(err, os.ErrNotExist) { break } name = fmt.Sprintf("%s-%d.tar.gz", base, i) } tmp := filepath.Join(s.Dir, "."+name+".partial") f, err := os.OpenFile(tmp, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0o640) if err != nil { return Archive{}, removed, err } if err := WriteTarGz(f, mirrorDir); err != nil { f.Close() os.Remove(tmp) return Archive{}, removed, err } if err := f.Sync(); err != nil { f.Close() os.Remove(tmp) return Archive{}, removed, err } if err := f.Close(); err != nil { os.Remove(tmp) return Archive{}, removed, err } final := filepath.Join(s.Dir, name) if err := os.Rename(tmp, final); err != nil { os.Remove(tmp) return Archive{}, removed, err } _ = os.Chtimes(final, now, now) fi, _ := os.Stat(final) return Archive{Name: name, CreatedAt: now.UTC(), Size: fi.Size()}, removed, nil } // removeOldest verwijdert het oudste archief zolang er meer dan keep zijn. func (s *Store) removeOldest(keep int) (string, bool, error) { list, err := s.List() if err != nil { return "", false, err } if len(list) <= keep { return "", false, nil } old := list[len(list)-1] if err := os.Remove(filepath.Join(s.Dir, old.Name)); err != nil { return "", false, err } return old.Name, true, nil } // Prune verwijdert archieven ouder dan retentionDays (0 = niet op leeftijd) // en daarna de oudste zolang er minder dan minFree bytes vrij is. Het // nieuwste archief blijft altijd staan. func (s *Store) Prune(now time.Time, retentionDays int, minFree uint64) ([]string, error) { var removed []string list, err := s.List() if err != nil { return nil, err } if retentionDays > 0 { cut := now.Add(-time.Duration(retentionDays) * 24 * time.Hour) for i, a := range list { if i == 0 || !a.CreatedAt.Before(cut) { continue } if err := os.Remove(filepath.Join(s.Dir, a.Name)); err != nil { return removed, err } removed = append(removed, a.Name) } } for { free, err := s.free() if err != nil || free >= minFree { break } name, ok, err := s.removeOldest(1) if err != nil { return removed, err } if !ok { break } removed = append(removed, name) } return removed, nil } // WriteTarGz schrijft dir als tar.gz met logische paden naar w. func WriteTarGz(w io.Writer, dir string) error { gz, _ := gzip.NewWriterLevel(w, gzip.DefaultCompression) tw := tar.NewWriter(gz) var paths []string err := filepath.WalkDir(dir, func(p string, d fs.DirEntry, err error) error { if err != nil { if errors.Is(err, fs.ErrNotExist) && p == dir { return fs.SkipDir } return err } if d.Type().IsRegular() { paths = append(paths, p) } return nil }) if err != nil { return err } sort.Strings(paths) for _, p := range paths { rel, _ := filepath.Rel(dir, p) logical := filepath.ToSlash(rel) if _, ok := protocol.CleanLogical(logical); !ok { continue } if err := addFile(tw, p, logical); err != nil { return err } } if err := tw.Close(); err != nil { return err } return gz.Close() } func addFile(tw *tar.Writer, p, logical string) error { f, err := os.Open(p) if err != nil { return err } defer f.Close() fi, err := f.Stat() if err != nil { return err } h := &tar.Header{ Name: logical, Mode: int64(fi.Mode().Perm()), Size: fi.Size(), Typeflag: tar.TypeReg, ModTime: fi.ModTime(), Format: tar.FormatPAX, } if err := tw.WriteHeader(h); err != nil { return err } _, err = io.CopyN(tw, f, fi.Size()) return err } // Extract pakt archief src uit in dst (dat nog niet mag bestaan). Alleen // gewone bestanden met geldige logische paden. func Extract(src, dst string) error { f, err := os.Open(src) if err != nil { return err } defer f.Close() return ExtractReader(f, dst) } // ExtractReader is Extract vanaf een stroom. func ExtractReader(r io.Reader, dst string) error { if err := os.MkdirAll(dst, 0o750); err != nil { return err } gz, err := gzip.NewReader(r) if err != nil { return err } tr := tar.NewReader(gz) for { h, err := tr.Next() if err == io.EOF { return nil } if err != nil { return err } if h.Typeflag == tar.TypeDir { continue } logical, ok := protocol.CleanLogical(strings.TrimPrefix(h.Name, "./")) if h.Typeflag != tar.TypeReg || !ok { return fmt.Errorf("ongeldig item in archief: %q", h.Name) } out := filepath.Join(dst, filepath.FromSlash(logical)) if err := os.MkdirAll(filepath.Dir(out), 0o750); err != nil { return err } mode := os.FileMode(h.Mode).Perm()&0o755 | 0o600 w, err := os.OpenFile(out, os.O_CREATE|os.O_EXCL|os.O_WRONLY, mode) if err != nil { return err } if _, err := io.Copy(w, tr); err != nil { w.Close() return err } if err := w.Close(); err != nil { return err } _ = os.Chtimes(out, h.ModTime, h.ModTime) } }