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
185 lines
4.8 KiB
Go
185 lines
4.8 KiB
Go
package storage
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"io/fs"
|
|
"os"
|
|
"path"
|
|
"path/filepath"
|
|
"sort"
|
|
"strings"
|
|
)
|
|
|
|
// Une racine (Root) est une arborescence de fichiers adressée par chemins
|
|
// relatifs « slash » : l'arborescence commune et les espaces personnels sur
|
|
// disque (Store), demain un bucket S3. Space aiguille les chemins virtuels vers
|
|
// la racine qui les porte ; ce qui ne dépend que de Root (archives ZIP, copie
|
|
// et déplacement entre racines) marche pour toutes.
|
|
|
|
// File est un fichier ouvert en lecture : *os.File sur disque, objet distant
|
|
// lu par plages pour S3. http.ServeContent n'a besoin que de Read et Seek.
|
|
type File interface {
|
|
io.Reader
|
|
io.Seeker
|
|
io.Closer
|
|
}
|
|
|
|
// WalkFunc reçoit chaque élément visité par Root.Walk ; rel est relatif à la
|
|
// racine. Renvoyer fs.SkipDir sur un dossier saute son contenu.
|
|
type WalkFunc func(rel string, e Entry) error
|
|
|
|
// Root regroupe les opérations de base d'une racine de fichiers.
|
|
type Root interface {
|
|
List(rel string) ([]Entry, error)
|
|
Stat(rel string) (Entry, error)
|
|
Open(rel string) (File, fs.FileInfo, error)
|
|
Put(rel string, r io.Reader, o PutOptions) (Entry, error)
|
|
Mkdir(rel string) (Entry, error)
|
|
Move(from, to string) (Entry, error)
|
|
Copy(from, to string) (Entry, error)
|
|
// Delete met l'élément à la corbeille de la racine.
|
|
Delete(rel string, recursive bool) error
|
|
// Remove supprime définitivement l'élément (fin d'un déplacement entre racines).
|
|
Remove(rel string) error
|
|
// Walk parcourt rel puis son contenu, dossiers avant leur contenu, en
|
|
// ignorant les éléments internes (noms cachés) et les liens.
|
|
Walk(rel string, fn WalkFunc) error
|
|
}
|
|
|
|
var _ Root = (*Store)(nil)
|
|
|
|
// Walk parcourt un fichier ou un dossier du Store (voir Root.Walk).
|
|
func (s *Store) Walk(rel string, fn WalkFunc) error {
|
|
if s.s3 != nil {
|
|
c, err := Clean(rel)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return s.s3Walk(c, fn)
|
|
}
|
|
c, abs, err := s.resolve(rel)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if _, err := os.Lstat(abs); err != nil {
|
|
return mapErr(err)
|
|
}
|
|
return filepath.WalkDir(abs, func(p string, d fs.DirEntry, err error) error {
|
|
if err != nil {
|
|
return nil // élément illisible : sauté
|
|
}
|
|
if p != abs && (!visible(d.Name()) || d.Type()&fs.ModeSymlink != 0) {
|
|
if d.IsDir() {
|
|
return filepath.SkipDir
|
|
}
|
|
return nil
|
|
}
|
|
if !d.IsDir() && !d.Type().IsRegular() {
|
|
return nil
|
|
}
|
|
fi, err := d.Info()
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
r, _ := filepath.Rel(abs, p)
|
|
er := c
|
|
if r != "." {
|
|
er = path.Join(c, filepath.ToSlash(r))
|
|
}
|
|
if p == abs && c == "" {
|
|
er = ""
|
|
}
|
|
return fn(er, toEntry(er, fi))
|
|
})
|
|
}
|
|
|
|
// Remove supprime définitivement un fichier ou un dossier, avec ses
|
|
// miniatures, son historique, ses métadonnées et ses liens de partage.
|
|
func (s *Store) Remove(rel string) error {
|
|
if s.s3 != nil {
|
|
c, err := Clean(rel)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return s.s3Remove(c)
|
|
}
|
|
c, abs, err := s.resolve(rel)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if c == "" {
|
|
return ErrInvalidPath
|
|
}
|
|
if _, err := os.Lstat(abs); err != nil {
|
|
return mapErr(err)
|
|
}
|
|
if err := os.RemoveAll(abs); err != nil {
|
|
return err
|
|
}
|
|
_ = os.RemoveAll(s.historyAbs(c))
|
|
s.removeThumb(c)
|
|
s.removeMeta(c)
|
|
s.removeShares(c)
|
|
s.usageDirty()
|
|
return nil
|
|
}
|
|
|
|
// transfer copie from (racine src) vers to (racine dst) en flux, fichier par
|
|
// fichier : c'est le chemin générique entre deux racines qui ne partagent pas
|
|
// de volume. La destination ne doit pas exister. En cas d'échec, ce qui a été
|
|
// copié est retiré. by est l'auteur noté sur les fichiers copiés.
|
|
func transfer(src Root, from string, dst Root, to string, by string) (Entry, error) {
|
|
top, err := src.Stat(from)
|
|
if err != nil {
|
|
return Entry{}, err
|
|
}
|
|
if _, err := dst.Stat(to); err == nil {
|
|
return Entry{}, ErrExists
|
|
} else if !errors.Is(err, ErrNotFound) {
|
|
return Entry{}, err
|
|
}
|
|
base := top.Path
|
|
target := func(rel string) string {
|
|
if rel == base {
|
|
return to
|
|
}
|
|
return path.Join(to, strings.TrimPrefix(rel, base+"/"))
|
|
}
|
|
if base == "" {
|
|
target = func(rel string) string { return path.Join(to, rel) }
|
|
}
|
|
err = src.Walk(from, func(rel string, e Entry) error {
|
|
t := target(rel)
|
|
if e.IsDir {
|
|
if _, err := dst.Mkdir(t); err != nil && !errors.Is(err, ErrExists) {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
f, _, err := src.Open(rel)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer f.Close()
|
|
_, err = dst.Put(t, f, PutOptions{ModTime: e.ModTime, By: by})
|
|
return err
|
|
})
|
|
if err != nil {
|
|
_ = dst.Remove(to)
|
|
return Entry{}, fmt.Errorf("copie vers %s : %w", to, err)
|
|
}
|
|
return dst.Stat(to)
|
|
}
|
|
|
|
// sortEntries trie une liste de dossier : dossiers d'abord, puis par nom.
|
|
func sortEntries(out []Entry) {
|
|
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)
|
|
})
|
|
}
|