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) }) }