Files
upandown/internal/storage/history.go
T
claude BotandClaude Opus 5.5 68885f7e6b Lot 0 : interface Root et lecture en flux, préalable à la racine S3
- storage.File (Read/Seek/Close) remplace *os.File dans Open, OpenVersion
  et l'API (téléchargement, aperçu, liens publics) : un objet S3 lu par
  plages pourra être servi tel quel par http.ServeContent.
- Interface storage.Root (List, Stat, Open, Put, Mkdir, Move, Copy,
  Delete, Remove, Walk), implémentée par Store ; ajout de Store.Walk et
  Store.Remove (suppression définitive).
- Archives ZIP construites via Root (Walk + Open) au lieu de chemins disque.
- transfer : copie en flux entre deux racines quelconques, base des
  déplacements disque <-> S3.
- Aucun changement de comportement ; tests ajoutés (root_test.go).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LNfwm4pfYR9C914C2EeiuB
2026-11-20 17:09:52 +01:00

272 lines
7.7 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) (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/<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)
}
}