package mirror import ( "context" "crypto/sha256" "encoding/hex" "encoding/json" "errors" "fmt" "io" "io/fs" "os" "path/filepath" "sort" "strings" "time" "gitlab.com/Timfa/bluegit/internal/backupserver/protocol" ) // Mirror is de draaiende kopie: Dir bevat de logische paden (state/…, // data/…). Index onthoudt per bestand grootte en mtime zoals BlueGit ze // meldde, zodat een volgende sync alleen wijzigingen ophaalt. type Mirror struct { Dir string Index string } // Stats zegt wat een sync deed. type Stats struct { Files int `json:"files"` Downloaded int `json:"downloaded"` Bytes int64 `json:"bytes"` Deleted int `json:"deleted"` Skipped int `json:"skipped"` } // LoadIndex leest de index. Geen bestand: leeg. func (m *Mirror) LoadIndex() (map[string]protocol.Entry, error) { idx := map[string]protocol.Entry{} b, err := os.ReadFile(m.Index) if errors.Is(err, os.ErrNotExist) { return idx, nil } if err != nil { return idx, err } return idx, json.Unmarshal(b, &idx) } func (m *Mirror) saveIndex(idx map[string]protocol.Entry) error { b, err := json.Marshal(idx) if err != nil { return err } tmp := m.Index + ".tmp" if err := os.WriteFile(tmp, b, 0o600); err != nil { return err } return os.Rename(tmp, m.Index) } // Empty zegt of de kopie nog niets bevat. func (m *Mirror) Empty() bool { idx, err := m.LoadIndex() return err != nil || len(idx) == 0 } // Size is de totale grootte volgens de index. func (m *Mirror) Size() int64 { idx, _ := m.LoadIndex() var n int64 for _, e := range idx { n += e.Size } return n } // Wipe verwijdert de kopie en de index. func (m *Mirror) Wipe() error { if err := os.RemoveAll(m.Dir); err != nil { return err } err := os.Remove(m.Index) if errors.Is(err, os.ErrNotExist) { return nil } return err } func (m *Mirror) real(logical string) string { return filepath.Join(m.Dir, filepath.FromSlash(logical)) } func same(a, b protocol.Entry) bool { if a.Path == protocol.DBPath || b.Path == protocol.DBPath { return a.SHA256 != "" && a.SHA256 == b.SHA256 && a.Size == b.Size } return a.Size == b.Size && a.MTime == b.MTime } // Sync haalt het manifest op en brengt de kopie gelijk: nieuwe en // gewijzigde bestanden downloaden (begrensd), verdwenen bestanden weg. func (m *Mirror) Sync(ctx context.Context, r *Remote) (Stats, error) { var st Stats man, err := r.Manifest(ctx) if err != nil { return st, err } idx, err := m.LoadIndex() if err != nil { idx = map[string]protocol.Entry{} } if err := os.MkdirAll(m.Dir, 0o750); err != nil { return st, err } tmpDir := filepath.Join(filepath.Dir(m.Dir), "tmp") if err := os.MkdirAll(tmpDir, 0o750); err != nil { return st, err } want := map[string]bool{} dirty := 0 for _, e := range man.Files { logical, ok := protocol.CleanLogical(e.Path) if !ok { continue } want[logical] = true st.Files++ if old, ok := idx[logical]; ok && same(old, e) { if _, err := os.Stat(m.real(logical)); err == nil { continue } } n, err := m.download(ctx, r, tmpDir, e) if errors.Is(err, ErrGone) { st.Skipped++ want[logical] = false continue } if err != nil { _ = m.saveIndex(idx) return st, fmt.Errorf("%s: %w", logical, err) } idx[logical] = e st.Downloaded++ st.Bytes += n dirty++ if dirty >= 200 { _ = m.saveIndex(idx) dirty = 0 } } for p := range idx { if !want[p] { _ = os.Remove(m.real(p)) delete(idx, p) st.Deleted++ } } // Ook bestanden die niet in de index stonden (een afgebroken download). _ = filepath.WalkDir(m.Dir, func(p string, d fs.DirEntry, err error) error { if err != nil || d.IsDir() { return nil } rel, _ := filepath.Rel(m.Dir, p) if _, ok := idx[filepath.ToSlash(rel)]; !ok { _ = os.Remove(p) } return nil }) removeEmptyDirs(m.Dir) return st, m.saveIndex(idx) } func (m *Mirror) download(ctx context.Context, r *Remote, tmpDir string, e protocol.Entry) (int64, error) { rc, err := r.Fetch(ctx, e.Path) if err != nil { return 0, err } defer rc.Close() f, err := os.CreateTemp(tmpDir, "dl-*") if err != nil { return 0, err } tmp := f.Name() defer os.Remove(tmp) h := sha256.New() n, err := io.Copy(io.MultiWriter(f, h), rc) if cerr := f.Close(); err == nil { err = cerr } if err != nil { return n, err } if e.SHA256 != "" && hex.EncodeToString(h.Sum(nil)) != e.SHA256 { return n, errors.New("sha256 klopt niet") } mode := os.FileMode(e.Mode).Perm() if mode == 0 { mode = 0o640 } _ = os.Chmod(tmp, mode|0o600) dst := m.real(e.Path) if err := os.MkdirAll(filepath.Dir(dst), 0o750); err != nil { return n, err } if err := os.Rename(tmp, dst); err != nil { return n, err } mt := time.UnixMilli(e.MTime) _ = os.Chtimes(dst, mt, mt) return n, nil } func removeEmptyDirs(root string) { var dirs []string _ = filepath.WalkDir(root, func(p string, d fs.DirEntry, err error) error { if err == nil && d.IsDir() && p != root { dirs = append(dirs, p) } return nil }) sort.Slice(dirs, func(i, j int) bool { return len(dirs[i]) > len(dirs[j]) }) for _, d := range dirs { _ = os.Remove(d) // faalt als hij niet leeg is } } // RebuildIndex maakt de index opnieuw uit de bestanden zelf, na het // uitpakken van een archief. De mtimes komen uit het archief en zijn // dezelfde die BlueGit na het terugzetten heeft. func (m *Mirror) RebuildIndex() error { idx := map[string]protocol.Entry{} err := filepath.WalkDir(m.Dir, func(p string, d fs.DirEntry, err error) error { if err != nil { return err } if d.IsDir() || !d.Type().IsRegular() { return nil } rel, _ := filepath.Rel(m.Dir, p) logical := filepath.ToSlash(rel) if _, ok := protocol.CleanLogical(logical); !ok { return nil } fi, err := d.Info() if err != nil { return err } e := protocol.Entry{Path: logical, Size: fi.Size(), MTime: fi.ModTime().UnixMilli(), Mode: uint32(fi.Mode().Perm())} if logical == protocol.DBPath { f, err := os.Open(p) if err != nil { return err } h := sha256.New() _, err = io.Copy(h, f) f.Close() if err != nil { return err } e.SHA256 = hex.EncodeToString(h.Sum(nil)) } idx[logical] = e return nil }) if err != nil && !errors.Is(err, fs.ErrNotExist) { return err } return m.saveIndex(idx) } // HasPath zegt of een logisch pad in de kopie staat (voor tests en status). func (m *Mirror) HasPath(prefix string) bool { idx, _ := m.LoadIndex() for p := range idx { if strings.HasPrefix(p, prefix) { return true } } return false }