BlueGit

timfa bluegit

Files

bluegit / internal / backupserver / archive / archive.go

archive.go

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