BlueGit

timfa bluegit

Files

bluegit / internal / backupserver / archive / archive.go

archive.go

archive.go 8.4 KiB Download Raw
1// Package archive maakt, bewaart, ruimt op en pakt archieven uit.
2//
3// Een archief is een tar.gz (PAX, mtimes in milliseconden) van de kopie met
4// logische paden (state/…, data/…), precies wat BlueGit bij een restore
5// aanneemt. Naam: bluegit-YYYYMMDD-HHMMSS.tar.gz in UTC.
6package archive
7
8import (
9 "archive/tar"
10 "compress/gzip"
11 "errors"
12 "fmt"
13 "io"
14 "io/fs"
15 "os"
16 "path/filepath"
17 "regexp"
18 "sort"
19 "strings"
20 "time"
21
22 "git.timfalken.com/timfa/bluegit-backup/internal/protocol"
23)
24
25var nameRE = regexp.MustCompile(`^bluegit-\d{8}-\d{6}(-\d{1,3})?\.tar\.gz$`)
26
27// ValidName zegt of name een archiefnaam is (geen pad, geen ..).
28func ValidName(name string) bool { return nameRE.MatchString(name) }
29
30// Archive is één archief op schijf.
31type Archive struct {
32 Name string `json:"name"`
33 CreatedAt time.Time `json:"created_at"`
34 Size int64 `json:"size"`
35}
36
37// Store is de map met archieven.
38type Store struct {
39 Dir string
40 // Free geeft de vrije bytes op het bestandssysteem van Dir. Tests
41 // zetten een nep-versie; nil gebruikt statfs.
42 Free func(dir string) (uint64, error)
43}
44
45func (s *Store) free() (uint64, error) {
46 if s.Free != nil {
47 return s.Free(s.Dir)
48 }
49 return FreeBytes(s.Dir)
50}
51
52// List geeft de archieven, nieuwste eerst.
53func (s *Store) List() ([]Archive, error) {
54 ents, err := os.ReadDir(s.Dir)
55 if errors.Is(err, os.ErrNotExist) {
56 return []Archive{}, nil
57 }
58 if err != nil {
59 return nil, err
60 }
61 out := []Archive{}
62 for _, e := range ents {
63 if e.IsDir() || !ValidName(e.Name()) {
64 continue
65 }
66 fi, err := e.Info()
67 if err != nil {
68 continue
69 }
70 out = append(out, Archive{Name: e.Name(), CreatedAt: createdAt(e.Name(), fi), Size: fi.Size()})
71 }
72 sort.Slice(out, func(i, j int) bool {
73 if out[i].CreatedAt.Equal(out[j].CreatedAt) {
74 return out[i].Name > out[j].Name
75 }
76 return out[i].CreatedAt.After(out[j].CreatedAt)
77 })
78 return out, nil
79}
80
81// createdAt neemt de mtime: die is gelijk aan de naam, maar tests en een
82// beheerder kunnen hem verzetten om de bewaartermijn te testen.
83func createdAt(name string, fi fs.FileInfo) time.Time {
84 return fi.ModTime().UTC()
85}
86
87// Path geeft het pad van een bestaand archief.
88func (s *Store) Path(name string) (string, error) {
89 if !ValidName(name) {
90 return "", errors.New("ongeldige archiefnaam")
91 }
92 p := filepath.Join(s.Dir, name)
93 if _, err := os.Stat(p); err != nil {
94 return "", fmt.Errorf("archief %s bestaat niet", name)
95 }
96 return p, nil
97}
98
99// DeleteAll verwijdert alle archieven.
100func (s *Store) DeleteAll() error {
101 list, err := s.List()
102 if err != nil {
103 return err
104 }
105 for _, a := range list {
106 if err := os.Remove(filepath.Join(s.Dir, a.Name)); err != nil {
107 return err
108 }
109 }
110 return nil
111}
112
113// Create schrijft een nieuw archief van mirrorDir. needBytes is een
114// schatting van de grootte; is er te weinig ruimte, dan gaan eerst oude
115// archieven weg (het nieuwste blijft).
116func (s *Store) Create(mirrorDir string, now time.Time, needBytes int64, minFree uint64) (Archive, []string, error) {
117 if err := os.MkdirAll(s.Dir, 0o750); err != nil {
118 return Archive{}, nil, err
119 }
120 var removed []string
121 for {
122 free, err := s.free()
123 if err != nil || free >= uint64(needBytes)+minFree {
124 break
125 }
126 // Het nieuwe archief wordt het nieuwste; daarvoor mag ook het
127 // laatste oude weg. De draaiende kopie blijft altijd staan.
128 name, ok, err := s.removeOldest(0)
129 if err != nil {
130 return Archive{}, removed, err
131 }
132 if !ok {
133 return Archive{}, removed, fmt.Errorf("te weinig schijfruimte voor een archief (%d MB vrij, %d MB nodig)", free>>20, (uint64(needBytes)+minFree)>>20)
134 }
135 removed = append(removed, name)
136 }
137 base := "bluegit-" + now.UTC().Format("20060102-150405")
138 name := base + ".tar.gz"
139 for i := 1; ; i++ {
140 if _, err := os.Stat(filepath.Join(s.Dir, name)); errors.Is(err, os.ErrNotExist) {
141 break
142 }
143 name = fmt.Sprintf("%s-%d.tar.gz", base, i)
144 }
145 tmp := filepath.Join(s.Dir, "."+name+".partial")
146 f, err := os.OpenFile(tmp, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0o640)
147 if err != nil {
148 return Archive{}, removed, err
149 }
150 if err := WriteTarGz(f, mirrorDir); err != nil {
151 f.Close()
152 os.Remove(tmp)
153 return Archive{}, removed, err
154 }
155 if err := f.Sync(); err != nil {
156 f.Close()
157 os.Remove(tmp)
158 return Archive{}, removed, err
159 }
160 if err := f.Close(); err != nil {
161 os.Remove(tmp)
162 return Archive{}, removed, err
163 }
164 final := filepath.Join(s.Dir, name)
165 if err := os.Rename(tmp, final); err != nil {
166 os.Remove(tmp)
167 return Archive{}, removed, err
168 }
169 _ = os.Chtimes(final, now, now)
170 fi, _ := os.Stat(final)
171 return Archive{Name: name, CreatedAt: now.UTC(), Size: fi.Size()}, removed, nil
172}
173
174// removeOldest verwijdert het oudste archief zolang er meer dan keep zijn.
175func (s *Store) removeOldest(keep int) (string, bool, error) {
176 list, err := s.List()
177 if err != nil {
178 return "", false, err
179 }
180 if len(list) <= keep {
181 return "", false, nil
182 }
183 old := list[len(list)-1]
184 if err := os.Remove(filepath.Join(s.Dir, old.Name)); err != nil {
185 return "", false, err
186 }
187 return old.Name, true, nil
188}
189
190// Prune verwijdert archieven ouder dan retentionDays (0 = niet op leeftijd)
191// en daarna de oudste zolang er minder dan minFree bytes vrij is. Het
192// nieuwste archief blijft altijd staan.
193func (s *Store) Prune(now time.Time, retentionDays int, minFree uint64) ([]string, error) {
194 var removed []string
195 list, err := s.List()
196 if err != nil {
197 return nil, err
198 }
199 if retentionDays > 0 {
200 cut := now.Add(-time.Duration(retentionDays) * 24 * time.Hour)
201 for i, a := range list {
202 if i == 0 || !a.CreatedAt.Before(cut) {
203 continue
204 }
205 if err := os.Remove(filepath.Join(s.Dir, a.Name)); err != nil {
206 return removed, err
207 }
208 removed = append(removed, a.Name)
209 }
210 }
211 for {
212 free, err := s.free()
213 if err != nil || free >= minFree {
214 break
215 }
216 name, ok, err := s.removeOldest(1)
217 if err != nil {
218 return removed, err
219 }
220 if !ok {
221 break
222 }
223 removed = append(removed, name)
224 }
225 return removed, nil
226}
227
228// WriteTarGz schrijft dir als tar.gz met logische paden naar w.
229func WriteTarGz(w io.Writer, dir string) error {
230 gz, _ := gzip.NewWriterLevel(w, gzip.DefaultCompression)
231 tw := tar.NewWriter(gz)
232 var paths []string
233 err := filepath.WalkDir(dir, func(p string, d fs.DirEntry, err error) error {
234 if err != nil {
235 if errors.Is(err, fs.ErrNotExist) && p == dir {
236 return fs.SkipDir
237 }
238 return err
239 }
240 if d.Type().IsRegular() {
241 paths = append(paths, p)
242 }
243 return nil
244 })
245 if err != nil {
246 return err
247 }
248 sort.Strings(paths)
249 for _, p := range paths {
250 rel, _ := filepath.Rel(dir, p)
251 logical := filepath.ToSlash(rel)
252 if _, ok := protocol.CleanLogical(logical); !ok {
253 continue
254 }
255 if err := addFile(tw, p, logical); err != nil {
256 return err
257 }
258 }
259 if err := tw.Close(); err != nil {
260 return err
261 }
262 return gz.Close()
263}
264
265func addFile(tw *tar.Writer, p, logical string) error {
266 f, err := os.Open(p)
267 if err != nil {
268 return err
269 }
270 defer f.Close()
271 fi, err := f.Stat()
272 if err != nil {
273 return err
274 }
275 h := &tar.Header{
276 Name: logical, Mode: int64(fi.Mode().Perm()), Size: fi.Size(), Typeflag: tar.TypeReg,
277 ModTime: fi.ModTime(), Format: tar.FormatPAX,
278 }
279 if err := tw.WriteHeader(h); err != nil {
280 return err
281 }
282 _, err = io.CopyN(tw, f, fi.Size())
283 return err
284}
285
286// Extract pakt archief src uit in dst (dat nog niet mag bestaan). Alleen
287// gewone bestanden met geldige logische paden.
288func Extract(src, dst string) error {
289 f, err := os.Open(src)
290 if err != nil {
291 return err
292 }
293 defer f.Close()
294 return ExtractReader(f, dst)
295}
296
297// ExtractReader is Extract vanaf een stroom.
298func ExtractReader(r io.Reader, dst string) error {
299 if err := os.MkdirAll(dst, 0o750); err != nil {
300 return err
301 }
302 gz, err := gzip.NewReader(r)
303 if err != nil {
304 return err
305 }
306 tr := tar.NewReader(gz)
307 for {
308 h, err := tr.Next()
309 if err == io.EOF {
310 return nil
311 }
312 if err != nil {
313 return err
314 }
315 if h.Typeflag == tar.TypeDir {
316 continue
317 }
318 logical, ok := protocol.CleanLogical(strings.TrimPrefix(h.Name, "./"))
319 if h.Typeflag != tar.TypeReg || !ok {
320 return fmt.Errorf("ongeldig item in archief: %q", h.Name)
321 }
322 out := filepath.Join(dst, filepath.FromSlash(logical))
323 if err := os.MkdirAll(filepath.Dir(out), 0o750); err != nil {
324 return err
325 }
326 mode := os.FileMode(h.Mode).Perm()&0o755 | 0o600
327 w, err := os.OpenFile(out, os.O_CREATE|os.O_EXCL|os.O_WRONLY, mode)
328 if err != nil {
329 return err
330 }
331 if _, err := io.Copy(w, tr); err != nil {
332 w.Close()
333 return err
334 }
335 if err := w.Close(); err != nil {
336 return err
337 }
338 _ = os.Chtimes(out, h.ModTime, h.ModTime)
339 }
340}