BlueGit

timfa bluegit

Files

bluegit / internal / backupserver / archive / archive.go

archive.go

archive.go 8.6 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// Delete verwijdert één archief.
100func (s *Store) Delete(name string) error {
101 p, err := s.Path(name)
102 if err != nil {
103 return err
104 }
105 return os.Remove(p)
106}
107
108// DeleteAll verwijdert alle archieven.
109func (s *Store) DeleteAll() error {
110 list, err := s.List()
111 if err != nil {
112 return err
113 }
114 for _, a := range list {
115 if err := os.Remove(filepath.Join(s.Dir, a.Name)); err != nil {
116 return err
117 }
118 }
119 return nil
120}
121
122// Create schrijft een nieuw archief van mirrorDir. needBytes is een
123// schatting van de grootte; is er te weinig ruimte, dan gaan eerst oude
124// archieven weg (het nieuwste blijft).
125func (s *Store) Create(mirrorDir string, now time.Time, needBytes int64, minFree uint64) (Archive, []string, error) {
126 if err := os.MkdirAll(s.Dir, 0o750); err != nil {
127 return Archive{}, nil, err
128 }
129 var removed []string
130 for {
131 free, err := s.free()
132 if err != nil || free >= uint64(needBytes)+minFree {
133 break
134 }
135 // Het nieuwe archief wordt het nieuwste; daarvoor mag ook het
136 // laatste oude weg. De draaiende kopie blijft altijd staan.
137 name, ok, err := s.removeOldest(0)
138 if err != nil {
139 return Archive{}, removed, err
140 }
141 if !ok {
142 return Archive{}, removed, fmt.Errorf("te weinig schijfruimte voor een archief (%d MB vrij, %d MB nodig)", free>>20, (uint64(needBytes)+minFree)>>20)
143 }
144 removed = append(removed, name)
145 }
146 base := "bluegit-" + now.UTC().Format("20060102-150405")
147 name := base + ".tar.gz"
148 for i := 1; ; i++ {
149 if _, err := os.Stat(filepath.Join(s.Dir, name)); errors.Is(err, os.ErrNotExist) {
150 break
151 }
152 name = fmt.Sprintf("%s-%d.tar.gz", base, i)
153 }
154 tmp := filepath.Join(s.Dir, "."+name+".partial")
155 f, err := os.OpenFile(tmp, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0o640)
156 if err != nil {
157 return Archive{}, removed, err
158 }
159 if err := WriteTarGz(f, mirrorDir); err != nil {
160 f.Close()
161 os.Remove(tmp)
162 return Archive{}, removed, err
163 }
164 if err := f.Sync(); err != nil {
165 f.Close()
166 os.Remove(tmp)
167 return Archive{}, removed, err
168 }
169 if err := f.Close(); err != nil {
170 os.Remove(tmp)
171 return Archive{}, removed, err
172 }
173 final := filepath.Join(s.Dir, name)
174 if err := os.Rename(tmp, final); err != nil {
175 os.Remove(tmp)
176 return Archive{}, removed, err
177 }
178 _ = os.Chtimes(final, now, now)
179 fi, _ := os.Stat(final)
180 return Archive{Name: name, CreatedAt: now.UTC(), Size: fi.Size()}, removed, nil
181}
182
183// removeOldest verwijdert het oudste archief zolang er meer dan keep zijn.
184func (s *Store) removeOldest(keep int) (string, bool, error) {
185 list, err := s.List()
186 if err != nil {
187 return "", false, err
188 }
189 if len(list) <= keep {
190 return "", false, nil
191 }
192 old := list[len(list)-1]
193 if err := os.Remove(filepath.Join(s.Dir, old.Name)); err != nil {
194 return "", false, err
195 }
196 return old.Name, true, nil
197}
198
199// Prune verwijdert archieven ouder dan retentionDays (0 = niet op leeftijd)
200// en daarna de oudste zolang er minder dan minFree bytes vrij is. Het
201// nieuwste archief blijft altijd staan.
202func (s *Store) Prune(now time.Time, retentionDays int, minFree uint64) ([]string, error) {
203 var removed []string
204 list, err := s.List()
205 if err != nil {
206 return nil, err
207 }
208 if retentionDays > 0 {
209 cut := now.Add(-time.Duration(retentionDays) * 24 * time.Hour)
210 for i, a := range list {
211 if i == 0 || !a.CreatedAt.Before(cut) {
212 continue
213 }
214 if err := os.Remove(filepath.Join(s.Dir, a.Name)); err != nil {
215 return removed, err
216 }
217 removed = append(removed, a.Name)
218 }
219 }
220 for {
221 free, err := s.free()
222 if err != nil || free >= minFree {
223 break
224 }
225 name, ok, err := s.removeOldest(1)
226 if err != nil {
227 return removed, err
228 }
229 if !ok {
230 break
231 }
232 removed = append(removed, name)
233 }
234 return removed, nil
235}
236
237// WriteTarGz schrijft dir als tar.gz met logische paden naar w.
238func WriteTarGz(w io.Writer, dir string) error {
239 gz, _ := gzip.NewWriterLevel(w, gzip.DefaultCompression)
240 tw := tar.NewWriter(gz)
241 var paths []string
242 err := filepath.WalkDir(dir, func(p string, d fs.DirEntry, err error) error {
243 if err != nil {
244 if errors.Is(err, fs.ErrNotExist) && p == dir {
245 return fs.SkipDir
246 }
247 return err
248 }
249 if d.Type().IsRegular() {
250 paths = append(paths, p)
251 }
252 return nil
253 })
254 if err != nil {
255 return err
256 }
257 sort.Strings(paths)
258 for _, p := range paths {
259 rel, _ := filepath.Rel(dir, p)
260 logical := filepath.ToSlash(rel)
261 if _, ok := protocol.CleanLogical(logical); !ok {
262 continue
263 }
264 if err := addFile(tw, p, logical); err != nil {
265 return err
266 }
267 }
268 if err := tw.Close(); err != nil {
269 return err
270 }
271 return gz.Close()
272}
273
274func addFile(tw *tar.Writer, p, logical string) error {
275 f, err := os.Open(p)
276 if err != nil {
277 return err
278 }
279 defer f.Close()
280 fi, err := f.Stat()
281 if err != nil {
282 return err
283 }
284 h := &tar.Header{
285 Name: logical, Mode: int64(fi.Mode().Perm()), Size: fi.Size(), Typeflag: tar.TypeReg,
286 ModTime: fi.ModTime(), Format: tar.FormatPAX,
287 }
288 if err := tw.WriteHeader(h); err != nil {
289 return err
290 }
291 _, err = io.CopyN(tw, f, fi.Size())
292 return err
293}
294
295// Extract pakt archief src uit in dst (dat nog niet mag bestaan). Alleen
296// gewone bestanden met geldige logische paden.
297func Extract(src, dst string) error {
298 f, err := os.Open(src)
299 if err != nil {
300 return err
301 }
302 defer f.Close()
303 return ExtractReader(f, dst)
304}
305
306// ExtractReader is Extract vanaf een stroom.
307func ExtractReader(r io.Reader, dst string) error {
308 if err := os.MkdirAll(dst, 0o750); err != nil {
309 return err
310 }
311 gz, err := gzip.NewReader(r)
312 if err != nil {
313 return err
314 }
315 tr := tar.NewReader(gz)
316 for {
317 h, err := tr.Next()
318 if err == io.EOF {
319 return nil
320 }
321 if err != nil {
322 return err
323 }
324 if h.Typeflag == tar.TypeDir {
325 continue
326 }
327 logical, ok := protocol.CleanLogical(strings.TrimPrefix(h.Name, "./"))
328 if h.Typeflag != tar.TypeReg || !ok {
329 return fmt.Errorf("ongeldig item in archief: %q", h.Name)
330 }
331 out := filepath.Join(dst, filepath.FromSlash(logical))
332 if err := os.MkdirAll(filepath.Dir(out), 0o750); err != nil {
333 return err
334 }
335 mode := os.FileMode(h.Mode).Perm()&0o755 | 0o600
336 w, err := os.OpenFile(out, os.O_CREATE|os.O_EXCL|os.O_WRONLY, mode)
337 if err != nil {
338 return err
339 }
340 if _, err := io.Copy(w, tr); err != nil {
341 w.Close()
342 return err
343 }
344 if err := w.Close(); err != nil {
345 return err
346 }
347 _ = os.Chtimes(out, h.ModTime, h.ModTime)
348 }
349}