273 lines
7.8 KiB
Go
273 lines
7.8 KiB
Go
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/<date>). 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) (*os.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, _, 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
|
|
}
|
|
vfi, _ := vf.Stat()
|
|
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/<nom>), 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)
|
|
}
|
|
}
|