package storage import ( "errors" "fmt" "io" "io/fs" "log/slog" "os" "path/filepath" "regexp" "sort" "time" ) // Historique des versions : avant qu'un fichier soit remplacé, son contenu // précédent est conservé dans .history/ en miroir de l'arborescence // (a/b.pdf -> .history/a/b.pdf/). La version est un lien physique vers // l'ancien fichier quand le volume le permet (aucune copie de données), sinon // une copie. // // Une version n'est prise que si la précédente date d'au moins // HistoryPolicy.Interval (0 : à chaque remplacement). Restaurer une version ou // en créer une à la demande ignore l'intervalle. const historyDir = ".history" // HistoryPolicy règle la prise et la rétention des versions. type HistoryPolicy struct { Keep int // versions conservées par fichier (0 : historique désactivé) Interval time.Duration // écart minimal entre deux versions automatiques MaxAge time.Duration // âge maximal d'une version (0 : illimité) } // DefaultHistory : 10 versions par fichier, une à chaque remplacement. var DefaultHistory = HistoryPolicy{Keep: 10} // Version décrit une version enregistrée d'un fichier. Time est la date à // laquelle ce contenu avait été déposé. type Version struct { ID string `json:"id"` Time time.Time `json:"time"` Size int64 `json:"size"` } const versionLayout = "20060102T150405.000000000Z" var versionID = regexp.MustCompile(`^\d{8}T\d{6}\.\d{9}Z$`) func (s *Store) historyAbs(c string) string { return filepath.Join(s.root, historyDir, filepath.FromSlash(c)) } func (s *Store) versionAbs(c, id string) string { return filepath.Join(s.historyAbs(c), id) } // versions liste les versions d'un fichier, la plus récente en premier. // taken renvoie en plus la date de prise de la plus récente (date du fichier). func (s *Store) versions(c string) ([]Version, time.Time, error) { des, err := os.ReadDir(s.historyAbs(c)) if errors.Is(err, fs.ErrNotExist) { return []Version{}, time.Time{}, nil } if err != nil { return nil, time.Time{}, err } out := []Version{} var taken time.Time for _, de := range des { id := de.Name() if de.IsDir() || !versionID.MatchString(id) { continue } t, err := time.Parse(versionLayout, id) if err != nil { continue } fi, err := de.Info() if err != nil { continue } out = append(out, Version{ID: id, Time: t, Size: fi.Size()}) if ct := changeTime(fi); ct.After(taken) { taken = ct } } sort.Slice(out, func(i, j int) bool { return out[i].ID > out[j].ID }) return out, taken, nil } // changeTime : date de prise d'une version. Un lien physique garde la date du // contenu : on utilise la date de création de l'entrée d'historique, que le // nom de fichier ne porte pas ; à défaut, la date du contenu. func changeTime(fi fs.FileInfo) time.Time { return fi.ModTime() } // snapshot conserve le fichier abs (daté de mod) comme version. Sans force, // rien n'est pris si la dernière version a moins de Interval. Une version // de même date et de même taille que la plus récente n'est jamais dupliquée. func (s *Store) snapshot(c, abs string, fi fs.FileInfo, force bool) (Version, error) { p := s.History if p.Keep <= 0 { return Version{}, nil } vs, _, err := s.versions(c) if err != nil { return Version{}, err } if !force && len(vs) > 0 && p.Interval > 0 && time.Since(vs[0].Time) < p.Interval { return Version{}, nil } v := Version{ID: fi.ModTime().UTC().Format(versionLayout), Time: fi.ModTime().UTC(), Size: fi.Size()} if len(vs) > 0 && vs[0].ID == v.ID && vs[0].Size == v.Size { return vs[0], nil } dst := s.versionAbs(c, v.ID) if err := os.MkdirAll(filepath.Dir(dst), 0o755); err != nil { return Version{}, err } _ = os.Remove(dst) if err := os.Link(abs, dst); err != nil { if err := copyFile(abs, dst); err != nil { return Version{}, err } _ = os.Chtimes(dst, fi.ModTime(), fi.ModTime()) } s.pruneHistory(c) return v, nil } // pruneHistory applique la rétention (nombre et âge) aux versions d'un fichier. func (s *Store) pruneHistory(c string) { vs, _, err := s.versions(c) if err != nil { return } for i, v := range vs { if i >= s.History.Keep || (s.History.MaxAge > 0 && time.Since(v.Time) > s.History.MaxAge) { _ = os.Remove(s.versionAbs(c, v.ID)) } } } // autoSnapshot est appelé par Put avant de remplacer un fichier ; un échec est // journalisé mais n'empêche pas l'enregistrement. func (s *Store) autoSnapshot(c, abs string, fi fs.FileInfo) { if _, err := s.snapshot(c, abs, fi, false); err != nil { slog.Warn("historique : version non enregistrée", "path", c, "err", err) } } // Versions liste les versions d'un fichier existant, la plus récente en premier. func (s *Store) Versions(rel string) ([]Version, error) { c, abs, err := s.resolve(rel) if err != nil { return nil, err } if c == "" { return nil, ErrInvalidPath } if fi, err := os.Lstat(abs); err != nil || !fi.Mode().IsRegular() { return nil, ErrNotFound } vs, _, err := s.versions(c) return vs, err } // OpenVersion ouvre une version en lecture. func (s *Store) OpenVersion(rel, id string) (File, fs.FileInfo, error) { c, _, err := s.resolve(rel) if err != nil { return nil, nil, err } if c == "" || !versionID.MatchString(id) { return nil, nil, fmt.Errorf("%w : version %q", ErrInvalidPath, id) } f, err := os.Open(s.versionAbs(c, id)) if err != nil { return nil, nil, mapErr(err) } fi, err := f.Stat() if err != nil { f.Close() return nil, nil, err } return f, fi, nil } // Snapshot crée une version du contenu courant, quel que soit l'intervalle. func (s *Store) Snapshot(rel string) (Version, error) { c, abs, err := s.resolve(rel) if err != nil { return Version{}, err } if s.History.Keep <= 0 { return Version{}, fmt.Errorf("%w : historique désactivé (HISTORY_KEEP=0)", ErrInvalidPath) } fi, err := os.Lstat(abs) if err != nil || !fi.Mode().IsRegular() { return Version{}, ErrNotFound } return s.snapshot(c, abs, fi, true) } // Restore remplace le contenu d'un fichier par une de ses versions. Le contenu // courant est d'abord enregistré comme version : une restauration s'annule. func (s *Store) Restore(rel, id string) (Entry, error) { vf, vfi, err := s.OpenVersion(rel, id) if err != nil { return Entry{}, err } defer vf.Close() c, abs, _ := s.resolve(rel) fi, err := os.Lstat(abs) if err != nil || !fi.Mode().IsRegular() { return Entry{}, ErrNotFound } tmp, err := os.CreateTemp(filepath.Dir(abs), ".tmp-*") if err != nil { return Entry{}, err } defer os.Remove(tmp.Name()) if _, err := io.Copy(tmp, vf); err != nil { tmp.Close() return Entry{}, err } if err := tmp.Close(); err != nil { return Entry{}, err } _ = os.Chmod(tmp.Name(), 0o644) if vfi != nil { _ = os.Chtimes(tmp.Name(), vfi.ModTime(), vfi.ModTime()) } if _, err := s.snapshot(c, abs, fi, true); err != nil { return Entry{}, err } if err := os.Rename(tmp.Name(), abs); err != nil { return Entry{}, err } s.usageDirty() s.removeThumb(c) nfi, err := os.Stat(abs) if err != nil { return Entry{}, err } return toEntry(c, nfi), nil } // Les opérations suivantes accompagnent Move/Delete. func (s *Store) moveHistory(from, to string) { src, dst := s.historyAbs(from), s.historyAbs(to) if _, err := os.Stat(src); err != nil { return } _ = os.RemoveAll(dst) if err := os.MkdirAll(filepath.Dir(dst), 0o755); err == nil { _ = os.Rename(src, dst) } } // trashHistory range l'historique d'un élément supprimé avec lui dans la // corbeille (trash/.history/), pour pouvoir le récupérer à la main. func (s *Store) trashHistory(c, trash string) { src := s.historyAbs(c) if _, err := os.Stat(src); err != nil { return } dst := filepath.Join(trash, historyDir, filepath.Base(src)) if err := os.MkdirAll(filepath.Dir(dst), 0o755); err == nil { _ = os.Rename(src, dst) } }