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:
1 parent
59d8b1f012
commit
68885f7e6b
8 files changed
+323
-85
No files matched your search
+27
-68
@@ -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
|
||||
|
||||
Reference in new issue
Block a user