715 lines
19 KiB
Go
715 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"
|
|
"sort"
|
|
"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)
|
|
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)
|
|
}
|
|
sort.Slice(out, func(i, j int) bool {
|
|
if out[i].IsDir != out[j].IsDir {
|
|
return out[i].IsDir
|
|
}
|
|
return strings.ToLower(out[i].Name) < strings.ToLower(out[j].Name)
|
|
})
|
|
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) (*os.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)
|
|
}
|