From 68885f7e6b93c24a3b0e188fff97f93a58d8de59 Mon Sep 17 00:00:00 2001 From: claude Date: Fri, 20 Nov 2026 17:09:52 +0100 Subject: [PATCH] =?UTF-8?q?Lot=200=20:=20interface=20Root=20et=20lecture?= =?UTF-8?q?=20en=20flux,=20pr=C3=A9alable=20=C3=A0=20la=20racine=20S3?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - storage.File (Read/Seek/Close) remplace *os.File dans Open, OpenVersion et l'API (téléchargement, aperçu, liens publics) : un objet S3 lu par plages pourra être servi tel quel par http.ServeContent. - Interface storage.Root (List, Stat, Open, Put, Mkdir, Move, Copy, Delete, Remove, Walk), implémentée par Store ; ajout de Store.Walk et Store.Remove (suppression définitive). - Archives ZIP construites via Root (Walk + Open) au lieu de chemins disque. - transfer : copie en flux entre deux racines quelconques, base des déplacements disque <-> S3. - Aucun changement de comportement ; tests ajoutés (root_test.go). Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01LNfwm4pfYR9C914C2EeiuB --- internal/api/preview.go | 3 +- internal/api/serve.go | 3 +- internal/storage/history.go | 5 +- internal/storage/root.go | 170 ++++++++++++++++++++++++++++++++++ internal/storage/root_test.go | 118 +++++++++++++++++++++++ internal/storage/spaces.go | 4 +- internal/storage/storage.go | 10 +- internal/storage/zip.go | 95 ++++++------------- 8 files changed, 323 insertions(+), 85 deletions(-) create mode 100644 internal/storage/root.go create mode 100644 internal/storage/root_test.go 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