Lot 0 : interface Root et lecture en flux, préalable à la racine S3

- 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 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LNfwm4pfYR9C914C2EeiuB
This commit is contained in:
claude BotandClaude Opus 5.5 committed 2026-11-20 17:09:52 +01:00
1 parent 59d8b1f012
commit 68885f7e6b
8 files changed
+323 -85

No files matched your search

+1 -2
View File
@@ -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) {
+1 -2
View File
@@ -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"))
+2 -3
View File
@@ -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
+170
View File
@@ -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)
})
}
+118
View File
@@ -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", "<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 != "<svg/>" {
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)
}
}
}
+2 -2
View File
@@ -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
+2 -8
View File
@@ -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
+27 -68
View File
@@ -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