- 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
710 lines
19 KiB
Go
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)
|
|
}
|