Files
upandown/internal/storage/storage.go
claude BotandClaude Opus 5.5 7c1f49cb5c Lot 3 (1/4) : racine S3, backend du Store (catalogue + objets minio-go)
Arborescence dans s3_nodes, contenus sous des clés o/<id> figées au dépôt,
corbeille dans s3_trash, configuration admin dans s3_config. Délégations
S3 dans List/Stat/Open/Put/Mkdir/Move/Copy/Delete/Walk/corbeille,
miniatures, partages, tags, recherche (noms et tags). Pas d'historique.

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

779 lines
20 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
s3 *s3Root // racine S3 (s3.go) ; nil : disque
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) {
if s.s3 != nil {
c, err := Clean(rel)
if err != nil {
return nil, err
}
return s.s3List(c)
}
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) {
if s.s3 != nil {
c, err := Clean(rel)
if err != nil {
return Entry{}, err
}
return s.s3Stat(c)
}
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) {
if s.s3 != nil {
c, err := Clean(rel)
if err != nil {
return nil, nil, err
}
return s.s3Open(c)
}
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) {
if s.s3 != nil {
c, err := Clean(rel)
if err != nil {
return Entry{}, err
}
return s.s3Put(c, r, o)
}
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) {
if s.s3 != nil {
c, err := Clean(rel)
if err != nil {
return Entry{}, err
}
return s.s3Mkdir(c)
}
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) {
if s.s3 != nil {
cf, err := Clean(from)
if err != nil {
return Entry{}, err
}
ct, err := Clean(to)
if err != nil {
return Entry{}, err
}
return s.s3Move(cf, ct)
}
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) {
if s.s3 != nil {
cf, err := Clean(from)
if err != nil {
return Entry{}, err
}
ct, err := Clean(to)
if err != nil {
return Entry{}, err
}
return s.s3Copy(cf, ct)
}
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 {
if s.s3 != nil {
c, err := Clean(rel)
if err != nil {
return err
}
return s.s3Delete(c, recursive, by)
}
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 {
if s.s3 != nil {
return s.s3Usage()
}
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)
}