diff --git a/internal/api/preview.go b/internal/api/preview.go
index 5f778ed..7031e56 100644
--- a/internal/api/preview.go
+++ b/internal/api/preview.go
@@ -5,7 +5,6 @@ import (
"io"
"io/fs"
"net/http"
- "os"
"path"
"strconv"
"strings"
@@ -199,7 +198,7 @@ func (c previewConfig) maxText() int64 {
return int64(c.MaxTextMB) << 20
}
-func (h *Handler) servePreview(w http.ResponseWriter, r *http.Request, f *os.File, fi fs.FileInfo, cfg previewConfig) {
+func (h *Handler) servePreview(w http.ResponseWriter, r *http.Request, f storage.File, fi fs.FileInfo, cfg previewConfig) {
name := fi.Name()
kind := cfg.kind(name)
if fi.IsDir() || cfg.excluded(name) || (kind == "" && !cfg.Sniff) {
diff --git a/internal/api/serve.go b/internal/api/serve.go
index 154ecdd..4796866 100644
--- a/internal/api/serve.go
+++ b/internal/api/serve.go
@@ -7,7 +7,6 @@ import (
"mime"
"net/http"
"net/url"
- "os"
"path"
"strings"
@@ -66,7 +65,7 @@ func contentDisposition(inline bool, name string) string {
// serveFile envoie un fichier avec prise en charge de Range, If-Modified-Since
// et ETag. Affichage en ligne seulement si inline est demandé et que le type
// est sûr ; sinon téléchargement.
-func serveFile(w http.ResponseWriter, r *http.Request, f *os.File, fi fs.FileInfo, name string, inline bool) {
+func serveFile(w http.ResponseWriter, r *http.Request, f storage.File, fi fs.FileInfo, name string, inline bool) {
ct := contentType(name)
bt := baseType(ct)
showInline := inline && (inlineTypes[bt] || strings.HasPrefix(ct, "text/plain"))
diff --git a/internal/storage/history.go b/internal/storage/history.go
index c5b5bdd..a02f97e 100644
--- a/internal/storage/history.go
+++ b/internal/storage/history.go
@@ -164,7 +164,7 @@ func (s *Store) Versions(rel string) ([]Version, error) {
}
// OpenVersion ouvre une version en lecture.
-func (s *Store) OpenVersion(rel, id string) (*os.File, fs.FileInfo, error) {
+func (s *Store) OpenVersion(rel, id string) (File, fs.FileInfo, error) {
c, _, err := s.resolve(rel)
if err != nil {
return nil, nil, err
@@ -203,7 +203,7 @@ func (s *Store) Snapshot(rel string) (Version, error) {
// Restore remplace le contenu d'un fichier par une de ses versions. Le contenu
// courant est d'abord enregistré comme version : une restauration s'annule.
func (s *Store) Restore(rel, id string) (Entry, error) {
- vf, _, err := s.OpenVersion(rel, id)
+ vf, vfi, err := s.OpenVersion(rel, id)
if err != nil {
return Entry{}, err
}
@@ -213,7 +213,6 @@ func (s *Store) Restore(rel, id string) (Entry, error) {
if err != nil || !fi.Mode().IsRegular() {
return Entry{}, ErrNotFound
}
- vfi, _ := vf.Stat()
tmp, err := os.CreateTemp(filepath.Dir(abs), ".tmp-*")
if err != nil {
return Entry{}, err
diff --git a/internal/storage/root.go b/internal/storage/root.go
new file mode 100644
index 0000000..6c31fba
--- /dev/null
+++ b/internal/storage/root.go
@@ -0,0 +1,170 @@
+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 {
+ 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 {
+ 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)
+ })
+}
diff --git a/internal/storage/root_test.go b/internal/storage/root_test.go
new file mode 100644
index 0000000..e7b92e7
--- /dev/null
+++ b/internal/storage/root_test.go
@@ -0,0 +1,118 @@
+package storage
+
+import (
+ "archive/zip"
+ "bytes"
+ "errors"
+ "sort"
+ "testing"
+)
+
+func TestWalkSkipsInternalFiles(t *testing.T) {
+ s := newStore(t)
+ put(t, s, "d/a.txt", "a", PutOptions{})
+ put(t, s, "d/sous/b.txt", "bb", PutOptions{})
+ put(t, s, "d/a.txt", "a2", PutOptions{Conflict: "overwrite"}) // crée .history
+ if err := s.EditTags([]string{"d/a.txt"}, []string{"x"}, nil); err != nil {
+ t.Fatal(err)
+ }
+ var got []string
+ if err := s.Walk("d", func(rel string, e Entry) error {
+ if rel != e.Path {
+ t.Errorf("rel %q != Path %q", rel, e.Path)
+ }
+ got = append(got, rel)
+ return nil
+ }); err != nil {
+ t.Fatal(err)
+ }
+ sort.Strings(got)
+ want := []string{"d", "d/a.txt", "d/sous", "d/sous/b.txt"}
+ if len(got) != len(want) {
+ t.Fatalf("Walk = %v, veut %v", got, want)
+ }
+ for i := range want {
+ if got[i] != want[i] {
+ t.Fatalf("Walk = %v, veut %v", got, want)
+ }
+ }
+ var root []string
+ _ = s.Walk("", func(rel string, e Entry) error { root = append(root, rel); return nil })
+ for _, r := range root {
+ if r == ".history" || r == ".meta.json" {
+ t.Errorf("Walk expose un fichier interne : %s", r)
+ }
+ }
+}
+
+func TestTransferBetweenRoots(t *testing.T) {
+ src, dst := newStore(t), newStore(t)
+ put(t, src, "projet/plan.txt", "plan", PutOptions{})
+ put(t, src, "projet/img/logo.svg", "", PutOptions{})
+ if _, err := src.Mkdir("projet/vide"); err != nil {
+ t.Fatal(err)
+ }
+ e, err := transfer(src, "projet", dst, "copie/projet", "alice")
+ if err != nil {
+ t.Fatal(err)
+ }
+ if !e.IsDir || e.Path != "copie/projet" {
+ t.Errorf("transfer = %+v", e)
+ }
+ if got := read(t, dst, "copie/projet/img/logo.svg"); got != "" {
+ t.Errorf("contenu copié = %q", got)
+ }
+ if _, err := dst.Stat("copie/projet/vide"); err != nil {
+ t.Errorf("dossier vide non copié : %v", err)
+ }
+ if _, err := transfer(src, "projet", dst, "copie/projet", "alice"); !errors.Is(err, ErrExists) {
+ t.Errorf("destination existante : %v", err)
+ }
+ // Un fichier seul.
+ if _, err := transfer(src, "projet/plan.txt", dst, "plan.txt", ""); err != nil {
+ t.Fatal(err)
+ }
+ if got := read(t, dst, "plan.txt"); got != "plan" {
+ t.Errorf("fichier copié = %q", got)
+ }
+}
+
+func TestRemoveIsDefinitive(t *testing.T) {
+ s := newStore(t)
+ put(t, s, "d/a.txt", "a", PutOptions{})
+ if err := s.Remove("d"); err != nil {
+ t.Fatal(err)
+ }
+ if _, err := s.Stat("d"); !errors.Is(err, ErrNotFound) {
+ t.Errorf("Stat après Remove : %v", err)
+ }
+ if s.TrashCount() != 0 {
+ t.Errorf("Remove ne doit pas passer par la corbeille")
+ }
+ if err := s.Remove(""); !errors.Is(err, ErrInvalidPath) {
+ t.Errorf("Remove de la racine : %v", err)
+ }
+}
+
+func TestZipThroughRoot(t *testing.T) {
+ s := newStore(t)
+ put(t, s, "d/a.txt", "a", PutOptions{})
+ put(t, s, "d/s/b.txt", "b", PutOptions{})
+ var buf bytes.Buffer
+ if err := WriteZip(&buf, []ZipItem{{Root: s, Rel: "d", Name: "d"}, {Root: s, Rel: "d/a.txt", Name: "a.txt"}}); err != nil {
+ t.Fatal(err)
+ }
+ zr, err := zip.NewReader(bytes.NewReader(buf.Bytes()), int64(buf.Len()))
+ if err != nil {
+ t.Fatal(err)
+ }
+ names := map[string]bool{}
+ for _, f := range zr.File {
+ names[f.Name] = true
+ }
+ for _, n := range []string{"d/", "d/a.txt", "d/s/", "d/s/b.txt", "a.txt"} {
+ if !names[n] {
+ t.Errorf("archive sans %s : %v", n, names)
+ }
+ }
+}
diff --git a/internal/storage/spaces.go b/internal/storage/spaces.go
index a84fab2..6552cbd 100644
--- a/internal/storage/spaces.go
+++ b/internal/storage/spaces.go
@@ -642,7 +642,7 @@ func (u *Space) Stat(p string) (Entry, error) {
}
// Open ouvre un fichier en lecture (chemin virtuel).
-func (u *Space) Open(p string) (*os.File, fs.FileInfo, error) {
+func (u *Space) Open(p string) (File, fs.FileInfo, error) {
st, rel, err := u.route(p)
if err != nil {
return nil, nil, err
@@ -939,7 +939,7 @@ func (u *Space) Versions(p string) ([]Version, error) {
}
// OpenVersion ouvre une version d'un fichier en lecture.
-func (u *Space) OpenVersion(p, id string) (*os.File, fs.FileInfo, error) {
+func (u *Space) OpenVersion(p, id string) (File, fs.FileInfo, error) {
st, rel, err := u.route(p)
if err != nil {
return nil, nil, err
diff --git a/internal/storage/storage.go b/internal/storage/storage.go
index fb4cefb..eb19672 100644
--- a/internal/storage/storage.go
+++ b/internal/storage/storage.go
@@ -17,7 +17,6 @@ import (
"os"
"path"
"path/filepath"
- "sort"
"strconv"
"strings"
"sync"
@@ -237,12 +236,7 @@ func (s *Store) List(rel string) ([]Entry, error) {
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)
- })
+ sortEntries(out)
return out, nil
}
@@ -270,7 +264,7 @@ func ETag(fi fs.FileInfo) string {
}
// Open ouvre un fichier en lecture. Les liens symboliques sont refusés.
-func (s *Store) Open(rel string) (*os.File, fs.FileInfo, error) {
+func (s *Store) Open(rel string) (File, fs.FileInfo, error) {
c, abs, err := s.resolve(rel)
if err != nil {
return nil, nil, err
diff --git a/internal/storage/zip.go b/internal/storage/zip.go
index c58e576..3b91742 100644
--- a/internal/storage/zip.go
+++ b/internal/storage/zip.go
@@ -2,23 +2,22 @@ package storage
import (
"archive/zip"
+ "errors"
"fmt"
"io"
- "io/fs"
- "os"
"path"
- "path/filepath"
"strings"
)
// Téléchargement d'un dossier ou d'une sélection en archive ZIP, générée en
// flux (aucun fichier temporaire, mémoire constante).
-// ZipItem est un fichier ou un dossier à archiver : Abs est son chemin sur le
-// disque, Name son nom dans l'archive.
+// ZipItem est un fichier ou un dossier à archiver : Rel est son chemin dans
+// la racine Root, Name son nom dans l'archive.
type ZipItem struct {
- Abs string
- Name string
+ Root Root `json:"-"`
+ Rel string `json:"rel"`
+ Name string `json:"name"`
}
// compressed : extensions déjà compressées, stockées sans recompression.
@@ -44,22 +43,15 @@ func (u *Space) ZipItems(paths []string) ([]ZipItem, string, error) {
if err != nil {
return nil, "", err
}
- c, abs, err := st.resolve(rel)
+ e, err := st.Stat(rel)
if err != nil {
return nil, "", err
}
- name := path.Base(c)
- if c == "" {
+ name := path.Base(e.Path)
+ if e.Path == "" {
name = "fichiers" // racine de l'espace personnel
}
- fi, err := os.Lstat(abs)
- if err != nil {
- return nil, "", mapErr(err)
- }
- if !fi.IsDir() && !fi.Mode().IsRegular() {
- return nil, "", ErrNotFound
- }
- items = append(items, ZipItem{Abs: abs, Name: uniqueZipName(name, used)})
+ items = append(items, ZipItem{Root: st, Rel: e.Path, Name: uniqueZipName(name, used)})
}
archive := "fichiers"
if len(items) == 1 {
@@ -81,82 +73,49 @@ func uniqueZipName(name string, used map[string]bool) string {
// SharedZipItem renvoie l'élément d'un lien de partage (ou d'un de ses
// sous-dossiers) à archiver.
func (s *Store) SharedZipItem(rel string) (ZipItem, error) {
- c, abs, err := s.resolve(rel)
+ e, err := s.Stat(rel)
if err != nil {
return ZipItem{}, err
}
- if _, err := os.Lstat(abs); err != nil {
- return ZipItem{}, mapErr(err)
- }
- return ZipItem{Abs: abs, Name: path.Base(c)}, nil
+ return ZipItem{Root: s, Rel: e.Path, Name: path.Base(e.Path)}, nil
}
-// WriteZip écrit les éléments dans w au format ZIP. Les liens symboliques, les
-// fichiers spéciaux et les fichiers internes (noms cachés) sont ignorés ; un
-// fichier illisible est sauté sans interrompre l'archive.
+// WriteZip écrit les éléments dans w au format ZIP, en flux. Les liens
+// symboliques, les fichiers spéciaux et les fichiers internes (noms cachés)
+// sont ignorés ; un fichier illisible est sauté sans interrompre l'archive.
func WriteZip(w io.Writer, items []ZipItem) error {
zw := zip.NewWriter(w)
for _, it := range items {
- fi, err := os.Lstat(it.Abs)
- if err != nil {
- continue
- }
- if !fi.IsDir() {
- if err := addZipFile(zw, it.Abs, it.Name, fi); err != nil {
- return err
- }
- continue
- }
- err = filepath.WalkDir(it.Abs, func(p string, d fs.DirEntry, err error) error {
- if err != nil {
- return nil
- }
- if p != it.Abs && !visible(d.Name()) {
- if d.IsDir() {
- return filepath.SkipDir
- }
- return nil
- }
- rel, _ := filepath.Rel(it.Abs, p)
+ base := it.Rel
+ err := it.Root.Walk(it.Rel, func(rel string, e Entry) error {
name := it.Name
- if rel != "." {
- name = path.Join(it.Name, filepath.ToSlash(rel))
+ if rel != base {
+ name = path.Join(it.Name, strings.TrimPrefix(strings.TrimPrefix(rel, base), "/"))
}
- switch {
- case d.IsDir():
- h := &zip.FileHeader{Name: name + "/", Method: zip.Store}
- if info, err := d.Info(); err == nil {
- h.Modified = info.ModTime()
- }
- _, err := zw.CreateHeader(h)
+ if e.IsDir {
+ _, err := zw.CreateHeader(&zip.FileHeader{Name: name + "/", Method: zip.Store, Modified: e.ModTime})
return err
- case d.Type().IsRegular():
- info, err := d.Info()
- if err != nil {
- return nil
- }
- return addZipFile(zw, p, name, info)
}
- return nil
+ return addZipFile(zw, it.Root, rel, name, e)
})
- if err != nil {
+ if err != nil && !errors.Is(err, ErrNotFound) {
return err
}
}
return zw.Close()
}
-func addZipFile(zw *zip.Writer, abs, name string, fi fs.FileInfo) error {
- f, err := os.Open(abs)
+func addZipFile(zw *zip.Writer, root Root, rel, name string, e Entry) error {
+ f, _, err := root.Open(rel)
if err != nil {
return nil // fichier illisible : sauté
}
defer f.Close()
- h := &zip.FileHeader{Name: name, Method: zip.Deflate, Modified: fi.ModTime()}
+ h := &zip.FileHeader{Name: name, Method: zip.Deflate, Modified: e.ModTime}
if compressed[strings.ToLower(path.Ext(name))] {
h.Method = zip.Store
}
- h.UncompressedSize64 = uint64(fi.Size())
+ h.UncompressedSize64 = uint64(e.Size)
out, err := zw.CreateHeader(h)
if err != nil {
return err