Files
upandown/internal/storage/storage.go
T
claude BotandClaude Opus 5.5 f8801f00f9 Lot 1 : catalogue PostgreSQL partagé pour les métadonnées et les partages
- Nouveau paquet internal/catalog : pool pgx, migrations SQL embarquées
  (sérialisées entre instances par verrou consultatif), transactions
  rejouées après conflit, interblocage ou bascule du primaire (pool vidé
  sur erreur de lecture seule ou de connexion). DSN multi-hôtes accepté
  (target_session_attrs=read-write) pour une future HA.
- Store.UseCatalog : tags, icônes, auteurs (item_meta) et liens de partage
  (shares) lus et écrits en base ; chaque modification se fait sous verrou
  consultatif par racine (« main », « home/<id> »), donc sans perte
  d'écriture entre instances. Sans DATABASE_URL, rien ne change (JSON).
- Reprise unique de .meta.json et .shares.json au premier branchement
  (table imports), fichiers renommés en *.imported.
- Serveur : DATABASE_URL / DATABASE_URL_FILE, DATABASE_WAIT (60 s).
- Compose : service postgres:16 sur un réseau interne dédié ; Traefik
  inchangé. Dockerfile : go.sum et téléchargement des modules.
- Tests : UPANDOWN_TEST_DATABASE_URL fait passer toute la suite storage par
  la base ; tests de partage entre deux instances et de reprise JSON.

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

710 lines
19 KiB
Go

// Package storage gère l'arborescence de fichiers sur disque.
//
// Tous les chemins manipulés par l'API sont relatifs à la racine (DATA_DIR),
// au format "slash" (a/b/rapport.pdf). Le package garantit qu'aucun chemin ne
// sort de la racine, y compris via un lien symbolique, et que les fichiers
// internes (noms commençant par un point : .trash, .history, .meta.json...)
// ne sont jamais exposés.
package storage
import (
"crypto/sha256"
"encoding/hex"
"errors"
"fmt"
"io"
"io/fs"
"os"
"path"
"path/filepath"
"strconv"
"strings"
"sync"
"time"
"unicode/utf8"
)
const (
trashDir = ".trash"
thumbsDir = ".thumbs"
// MaxNameLen borne la longueur d'un nom de fichier ou de dossier (octets).
MaxNameLen = 255
)
var (
ErrNotFound = errors.New("introuvable")
ErrExists = errors.New("existe déjà")
ErrInvalidPath = errors.New("chemin invalide")
ErrConflict = errors.New("le fichier a été modifié entre-temps")
ErrNotEmpty = errors.New("dossier non vide")
ErrForbidden = errors.New("action non autorisée")
ErrQuota = errors.New("quota de stockage dépassé")
ErrTooLarge = errors.New("fichier trop volumineux")
)
// Entry décrit un élément de l'arborescence.
type Entry struct {
Name string `json:"name"`
Path string `json:"path"`
IsDir bool `json:"isDir"`
Size int64 `json:"size"`
ModTime time.Time `json:"modTime"`
Tags []string `json:"tags,omitempty"`
Favorite bool `json:"favorite,omitempty"`
Icon string `json:"icon,omitempty"` // dossier : icône choisie (meta.go)
EditedBy string `json:"editedBy,omitempty"` // fichier : dernier utilisateur à l'avoir déposé
// Détails (details.go), seulement sur demande (/api/list?details=1).
Details *Details `json:"details,omitempty"`
// Dossiers virtuels et favoris (spaces.go).
Special string `json:"special,omitempty"` // "favoris", "perso" ou "poubelle" : entrée de la racine
Link string `json:"link,omitempty"` // nom du lien dans le dossier Favoris
Broken bool `json:"broken,omitempty"` // favori dont l'élément d'origine a disparu
// Poubelle (trash.go, spaces.go).
Count int `json:"count,omitempty"` // entrée « poubelle » de la racine : nombre d'éléments
Origin string `json:"origin,omitempty"` // élément de la poubelle : chemin d'origine
By string `json:"by,omitempty"` // élément de la poubelle : supprimé par
}
// Store est un dépôt de fichiers enraciné dans un répertoire.
type Store struct {
root string
// History règle l'historique des versions (DefaultHistory par défaut).
History HistoryPolicy
// Defaults : valeurs des paramètres tant que l'administrateur ne les a pas
// modifiés (variables d'environnement, voir settings.go).
Defaults SettingsDefaults
settingsMu sync.Mutex // sérialise les lectures-modifications de .settings.json
index textIndex // texte des fichiers pour la recherche (search.go)
thumbSem chan struct{}
metaMu sync.Mutex // tags, favoris, auteurs (meta.go)
cat *catalogRef // catalogue PostgreSQL (catalog.go) ; nil : fichiers JSON
meta map[string]itemMeta // nil : pas encore chargé
sharesMu sync.Mutex // liens de partage (share.go)
shareKey []byte // clé HMAC ; nil : pas encore chargée
fixedKey bool // clé imposée par SHARE_SECRET
keyFrom *Store // espace personnel : clé de signature du Store principal
usageMu sync.Mutex
usageAt time.Time
usageSize int64
}
// New crée le répertoire racine si besoin et renvoie un Store.
func New(root string) (*Store, error) {
abs, err := filepath.Abs(root)
if err != nil {
return nil, err
}
if err := os.MkdirAll(abs, 0o755); err != nil {
return nil, err
}
// Résout un éventuel lien symbolique sur la racine elle-même pour que
// les comparaisons de préfixe soient fiables.
if abs, err = filepath.EvalSymlinks(abs); err != nil {
return nil, err
}
return &Store{root: abs, History: DefaultHistory, Defaults: DefaultSettings, thumbSem: make(chan struct{}, 2)}, nil
}
// Clean normalise un chemin relatif : "/a/../b/" -> "b", "" -> "".
// Les composants cachés (".trash", ".git"...), les caractères de contrôle et
// les noms trop longs sont refusés.
func Clean(rel string) (string, error) {
if strings.ContainsRune(rel, 0) || strings.Contains(rel, `\`) || !utf8.ValidString(rel) {
return "", ErrInvalidPath
}
c := strings.TrimPrefix(path.Clean("/"+rel), "/")
if c == "" {
return "", nil
}
for _, part := range strings.Split(c, "/") {
if strings.HasPrefix(part, ".") || len(part) > MaxNameLen || strings.TrimSpace(part) != part {
return "", ErrInvalidPath
}
for _, r := range part {
if r < 0x20 || r == 0x7f {
return "", ErrInvalidPath
}
}
}
return c, nil
}
// resolve convertit un chemin relatif en chemin absolu sous la racine et
// vérifie que l'ancêtre existant le plus proche ne s'échappe pas via symlink
// et ne mène pas à un répertoire interne.
func (s *Store) resolve(rel string) (string, string, error) {
c, err := Clean(rel)
if err != nil {
return "", "", err
}
abs := filepath.Join(s.root, filepath.FromSlash(c))
probe := abs
for {
real, err := filepath.EvalSymlinks(probe)
if err == nil {
if real != s.root && !strings.HasPrefix(real, s.root+string(os.PathSeparator)) {
return "", "", ErrInvalidPath
}
if real != s.root {
inner, _ := filepath.Rel(s.root, real)
for _, part := range strings.Split(filepath.ToSlash(inner), "/") {
if strings.HasPrefix(part, ".") {
return "", "", ErrInvalidPath
}
}
}
break
}
if !errors.Is(err, fs.ErrNotExist) {
return "", "", err
}
parent := filepath.Dir(probe)
if parent == probe {
return "", "", ErrInvalidPath
}
probe = parent
}
return c, abs, nil
}
func mapErr(err error) error {
switch {
case err == nil:
return nil
case errors.Is(err, fs.ErrNotExist):
return ErrNotFound
case errors.Is(err, fs.ErrExist):
return ErrExists
}
return err
}
func toEntry(rel string, fi fs.FileInfo) Entry {
e := Entry{
Name: fi.Name(),
Path: rel,
IsDir: fi.IsDir(),
Size: fi.Size(),
ModTime: fi.ModTime().UTC(),
}
if e.IsDir {
e.Size = 0
}
return e
}
func visible(name string) bool { return !strings.HasPrefix(name, ".") }
// List renvoie le contenu d'un dossier : dossiers d'abord, puis fichiers,
// triés par nom (insensible à la casse).
func (s *Store) List(rel string) ([]Entry, error) {
c, abs, err := s.resolve(rel)
if err != nil {
return nil, err
}
des, err := os.ReadDir(abs)
if err != nil {
if errors.Is(err, fs.ErrNotExist) || strings.Contains(err.Error(), "not a directory") {
return nil, ErrNotFound
}
return nil, mapErr(err)
}
out := make([]Entry, 0, len(des))
meta := s.metaSnapshot()
for _, de := range des {
if !visible(de.Name()) || de.Type()&fs.ModeSymlink != 0 {
continue
}
fi, err := de.Info()
if err != nil {
continue
}
if !fi.IsDir() && !fi.Mode().IsRegular() {
continue
}
e := toEntry(path.Join(c, de.Name()), fi)
decorate(&e, meta)
out = append(out, e)
}
sortEntries(out)
return out, nil
}
// Stat décrit un fichier ou un dossier.
func (s *Store) Stat(rel string) (Entry, error) {
c, abs, err := s.resolve(rel)
if err != nil {
return Entry{}, err
}
fi, err := os.Lstat(abs)
if err != nil {
return Entry{}, mapErr(err)
}
if fi.Mode()&fs.ModeSymlink != 0 {
return Entry{}, ErrNotFound
}
e := toEntry(c, fi)
decorate(&e, s.metaSnapshot())
return e, nil
}
// ETag calcule l'empreinte faible d'un fichier (taille et date de modification).
func ETag(fi fs.FileInfo) string {
return `W/"` + strconv.FormatInt(fi.Size(), 36) + "-" + strconv.FormatInt(fi.ModTime().UnixNano(), 36) + `"`
}
// Open ouvre un fichier en lecture. Les liens symboliques sont refusés.
func (s *Store) Open(rel string) (File, fs.FileInfo, error) {
c, abs, err := s.resolve(rel)
if err != nil {
return nil, nil, err
}
if c == "" {
return nil, nil, ErrInvalidPath
}
fi, err := os.Lstat(abs)
if err != nil {
return nil, nil, mapErr(err)
}
if !fi.Mode().IsRegular() {
return nil, nil, ErrNotFound
}
f, err := os.Open(abs)
if err != nil {
return nil, nil, mapErr(err)
}
if fi, err = f.Stat(); err != nil {
f.Close()
return nil, nil, err
}
return f, fi, nil
}
// PutOptions règle l'écriture d'un fichier (Put).
type PutOptions struct {
// Conflict : conduite si le fichier existe. "" ou "fail" : ErrExists ;
// "overwrite" : remplacement (la version précédente part dans l'historique) ;
// "rename" : le nouveau fichier prend un nom libre « nom (2).ext ».
Conflict string
// IfMatch : ETag attendu du fichier remplacé (ErrConflict sinon) ; vide : pas de contrôle.
IfMatch string
// Limit : nombre maximal d'octets acceptés (0 : illimité) ; LimitErr est
// renvoyée s'il est dépassé (ErrTooLarge ou ErrQuota).
Limit int64
LimitErr error
// ModTime : date de modification à donner au fichier (zéro : maintenant).
ModTime time.Time
// By : utilisateur qui dépose le fichier (auteur et dernier auteur).
By string
}
// Put écrit un fichier de façon atomique et en flux (fichier temporaire dans
// le dossier cible, fsync, rename) : un envoi interrompu ne laisse rien. Les
// dossiers parents sont créés. Renvoie l'entrée écrite (son chemin peut
// différer de rel avec Conflict = "rename").
func (s *Store) Put(rel string, r io.Reader, o PutOptions) (Entry, error) {
c, abs, err := s.resolve(rel)
if err != nil {
return Entry{}, err
}
if c == "" {
return Entry{}, ErrInvalidPath
}
fi, err := os.Lstat(abs)
exists := err == nil
if err != nil && !errors.Is(err, fs.ErrNotExist) {
return Entry{}, mapErr(err)
}
if exists {
if fi.IsDir() {
return Entry{}, fmt.Errorf("%w : un dossier porte déjà ce nom", ErrExists)
}
switch o.Conflict {
case "overwrite":
if o.IfMatch != "" && o.IfMatch != "*" && o.IfMatch != ETag(fi) {
return Entry{}, ErrConflict
}
case "rename":
c = s.freeName(c, false, " (%d)")
if _, abs, err = s.resolve(c); err != nil {
return Entry{}, err
}
exists = false
default:
return Entry{}, ErrExists
}
} else if o.IfMatch != "" && o.IfMatch != "*" {
return Entry{}, ErrConflict
}
// Un composant du chemin ne doit pas être un fichier.
if err := os.MkdirAll(filepath.Dir(abs), 0o755); err != nil {
if errors.Is(err, fs.ErrExist) || strings.Contains(err.Error(), "not a directory") {
return Entry{}, fmt.Errorf("%w : un fichier porte le nom d'un dossier du chemin", ErrExists)
}
return Entry{}, err
}
tmp, err := os.CreateTemp(filepath.Dir(abs), ".tmp-*")
if err != nil {
return Entry{}, err
}
defer os.Remove(tmp.Name()) // no-op après un rename réussi
src := r
if o.Limit > 0 {
src = io.LimitReader(r, o.Limit+1)
}
n, err := io.Copy(tmp, src)
if err != nil {
tmp.Close()
return Entry{}, err
}
if o.Limit > 0 && n > o.Limit {
tmp.Close()
if o.LimitErr != nil {
return Entry{}, o.LimitErr
}
return Entry{}, ErrTooLarge
}
if err := tmp.Sync(); err != nil {
tmp.Close()
return Entry{}, err
}
if err := tmp.Close(); err != nil {
return Entry{}, err
}
if err := os.Chmod(tmp.Name(), 0o644); err != nil {
return Entry{}, err
}
if m := o.ModTime; !m.IsZero() && m.After(time.Date(1980, 1, 1, 0, 0, 0, 0, time.UTC)) && m.Before(time.Now().Add(24*time.Hour)) {
_ = os.Chtimes(tmp.Name(), m, m)
}
if exists {
s.autoSnapshot(c, abs, fi)
}
if err := os.Rename(tmp.Name(), abs); err != nil {
return Entry{}, err
}
s.usageDirty()
s.removeThumb(c)
s.noteEdit(c, o.By, !exists)
nfi, err := os.Stat(abs)
if err != nil {
return Entry{}, err
}
e := toEntry(c, nfi)
e.EditedBy = o.By
return e, nil
}
// Mkdir crée un dossier (et ses parents).
func (s *Store) Mkdir(rel string) (Entry, error) {
c, abs, err := s.resolve(rel)
if err != nil {
return Entry{}, err
}
if c == "" {
return Entry{}, ErrInvalidPath
}
if _, err := os.Lstat(abs); err == nil {
return Entry{}, ErrExists
}
if err := os.MkdirAll(abs, 0o755); err != nil {
if strings.Contains(err.Error(), "not a directory") {
return Entry{}, fmt.Errorf("%w : un fichier porte le nom d'un dossier du chemin", ErrExists)
}
return Entry{}, mapErr(err)
}
fi, err := os.Stat(abs)
if err != nil {
return Entry{}, err
}
return toEntry(c, fi), nil
}
// Move renomme ou déplace un fichier ou un dossier. La destination ne doit
// pas exister ; un dossier ne peut pas être déplacé dans lui-même.
func (s *Store) Move(from, to string) (Entry, error) {
cf, af, err := s.resolve(from)
if err != nil {
return Entry{}, err
}
ct, at, err := s.resolve(to)
if err != nil {
return Entry{}, err
}
if cf == "" || ct == "" {
return Entry{}, ErrInvalidPath
}
fi, err := os.Lstat(af)
if err != nil {
return Entry{}, mapErr(err)
}
if fi.IsDir() && (ct == cf || strings.HasPrefix(ct, cf+"/")) {
return Entry{}, fmt.Errorf("%w : déplacement d'un dossier dans lui-même", ErrInvalidPath)
}
if _, err := os.Lstat(at); err == nil {
// Renommage qui ne change que la casse (volume insensible à la casse).
if !strings.EqualFold(cf, ct) || cf == ct {
return Entry{}, ErrExists
}
}
if err := os.MkdirAll(filepath.Dir(at), 0o755); err != nil {
return Entry{}, err
}
if err := os.Rename(af, at); err != nil {
return Entry{}, mapErr(err)
}
s.moveThumb(cf, ct, fi.IsDir())
s.moveHistory(cf, ct)
s.moveMeta(cf, ct)
s.moveShares(cf, ct)
fi, err = os.Stat(at)
if err != nil {
return Entry{}, err
}
e := toEntry(ct, fi)
decorate(&e, s.metaSnapshot())
return e, nil
}
// MoveResult est le résultat d'un déplacement unitaire dans MoveMany.
type MoveResult struct {
From string `json:"from"`
To string `json:"to,omitempty"`
Error string `json:"error,omitempty"`
err error
}
// Err renvoie l'erreur du déplacement (nil si réussi).
func (r MoveResult) Err() error { return r.err }
// Copy duplique un fichier, ou un dossier avec tout son contenu (fichiers
// réguliers seulement). Les tags sont copiés, pas les favoris ni les partages.
func (s *Store) Copy(from, to string) (Entry, error) {
cf, af, err := s.resolve(from)
if err != nil {
return Entry{}, err
}
ct, at, err := s.resolve(to)
if err != nil {
return Entry{}, err
}
if cf == "" || ct == "" {
return Entry{}, ErrInvalidPath
}
fi, err := os.Lstat(af)
if err != nil {
return Entry{}, mapErr(err)
}
if _, err := os.Lstat(at); err == nil {
return Entry{}, ErrExists
}
if fi.IsDir() {
if ct == cf || strings.HasPrefix(ct, cf+"/") {
return Entry{}, fmt.Errorf("%w : copie d'un dossier dans lui-même", ErrInvalidPath)
}
err = copyTree(af, at)
} else if fi.Mode().IsRegular() {
err = copyFile(af, at)
} else {
return Entry{}, ErrNotFound
}
if err != nil {
_ = os.RemoveAll(at)
return Entry{}, err
}
s.usageDirty()
s.copyMeta(cf, ct)
nfi, err := os.Stat(at)
if err != nil {
return Entry{}, err
}
return toEntry(ct, nfi), nil
}
func copyFile(src, dst string) error {
in, err := os.Open(src)
if err != nil {
return err
}
defer in.Close()
fi, err := in.Stat()
if err != nil {
return err
}
if err := os.MkdirAll(filepath.Dir(dst), 0o755); err != nil {
return err
}
tmp, err := os.CreateTemp(filepath.Dir(dst), ".tmp-*")
if err != nil {
return err
}
defer os.Remove(tmp.Name())
if _, err := io.Copy(tmp, in); err != nil {
tmp.Close()
return err
}
if err := tmp.Sync(); err != nil {
tmp.Close()
return err
}
if err := tmp.Close(); err != nil {
return err
}
_ = os.Chmod(tmp.Name(), 0o644)
_ = os.Chtimes(tmp.Name(), fi.ModTime(), fi.ModTime())
return os.Rename(tmp.Name(), dst)
}
func copyTree(src, dst string) error {
return filepath.WalkDir(src, func(p string, d fs.DirEntry, err error) error {
if err != nil {
return err
}
rel, _ := filepath.Rel(src, p)
target := filepath.Join(dst, rel)
switch {
case d.IsDir():
return os.MkdirAll(target, 0o755)
case d.Type().IsRegular() && visible(d.Name()):
return copyFile(p, target)
}
return nil // liens, fichiers spéciaux et fichiers internes ignorés
})
}
// Delete déplace un fichier ou un dossier dans la corbeille (.trash/, voir
// trash.go), sans suppression physique. Un dossier non vide n'est supprimé que
// si recursive.
func (s *Store) Delete(rel string, recursive bool) error {
return s.deleteAs(rel, recursive, "")
}
// deleteAs est Delete en notant l'auteur de la suppression (by).
func (s *Store) deleteAs(rel string, recursive bool, by string) error {
c, abs, err := s.resolve(rel)
if err != nil {
return err
}
if c == "" {
return ErrInvalidPath
}
fi, err := os.Lstat(abs)
if err != nil {
return mapErr(err)
}
if fi.IsDir() && !recursive {
des, err := os.ReadDir(abs)
if err != nil {
return err
}
if len(des) > 0 {
return ErrNotEmpty
}
}
if err := s.trash(c, abs, by); err != nil {
return err
}
s.removeThumb(c)
s.removeShares(c)
return nil
}
// freeName renvoie c s'il est libre, sinon « nom (2).ext », « nom (3).ext »...
// (format : suffixe avec %d) ; les dossiers n'ont pas d'extension.
func (s *Store) freeName(c string, isDir bool, format string) string {
if _, err := os.Lstat(absOf(s, c)); errors.Is(err, fs.ErrNotExist) {
return c
}
dir, base, ext := path.Dir(c), path.Base(c), ""
if !isDir {
ext = path.Ext(base)
base = strings.TrimSuffix(base, ext)
}
for i := 2; ; i++ {
n := base + fmt.Sprintf(format, i) + ext
if dir != "." {
n = dir + "/" + n
}
if _, err := os.Lstat(absOf(s, n)); errors.Is(err, fs.ErrNotExist) {
return n
}
}
}
// --- Occupation disque -------------------------------------------------------------
func (s *Store) usageDirty() {
s.usageMu.Lock()
s.usageAt = time.Time{}
s.usageMu.Unlock()
}
// Usage renvoie le nombre d'octets occupés (fichiers, corbeille et historique
// compris ; miniatures exclues). Le résultat est gardé 15 s, ou jusqu'à la
// prochaine écriture.
func (s *Store) Usage() int64 {
s.usageMu.Lock()
defer s.usageMu.Unlock()
if time.Since(s.usageAt) < 15*time.Second {
return s.usageSize
}
var total int64
_ = filepath.WalkDir(s.root, func(p string, d fs.DirEntry, err error) error {
if err != nil {
return nil
}
if d.IsDir() && p != s.root && d.Name() == thumbsDir {
return filepath.SkipDir
}
if d.Type().IsRegular() {
if fi, err := d.Info(); err == nil {
total += fi.Size()
}
}
return nil
})
s.usageSize, s.usageAt = total, time.Now()
return total
}
// fileID : empreinte courte d'une chaîne (noms de fichiers dérivés).
func fileID(s string) string {
h := sha256.Sum256([]byte(s))
return hex.EncodeToString(h[:8])
}
// atomicWrite écrit data dans abs de façon atomique (fichier temporaire + rename).
func atomicWrite(abs string, data []byte) error {
tmp, err := os.CreateTemp(filepath.Dir(abs), ".tmp-*")
if err != nil {
return err
}
defer os.Remove(tmp.Name()) // no-op après un rename réussi
if _, err := tmp.Write(data); err != nil {
tmp.Close()
return err
}
if err := tmp.Sync(); err != nil {
tmp.Close()
return err
}
if err := tmp.Close(); err != nil {
return err
}
if err := os.Chmod(tmp.Name(), 0o644); err != nil {
return err
}
return os.Rename(tmp.Name(), abs)
}