- 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
126 lines
3.7 KiB
Go
126 lines
3.7 KiB
Go
package storage
|
|
|
|
import (
|
|
"archive/zip"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"path"
|
|
"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 : Rel est son chemin dans
|
|
// la racine Root, Name son nom dans l'archive.
|
|
type ZipItem struct {
|
|
Root Root `json:"-"`
|
|
Rel string `json:"rel"`
|
|
Name string `json:"name"`
|
|
}
|
|
|
|
// compressed : extensions déjà compressées, stockées sans recompression.
|
|
var compressed = map[string]bool{
|
|
".zip": true, ".gz": true, ".tgz": true, ".bz2": true, ".xz": true, ".7z": true, ".rar": true, ".zst": true,
|
|
".jpg": true, ".jpeg": true, ".png": true, ".gif": true, ".webp": true, ".avif": true, ".heic": true,
|
|
".mp3": true, ".aac": true, ".ogg": true, ".opus": true, ".flac": true, ".m4a": true,
|
|
".mp4": true, ".mkv": true, ".webm": true, ".mov": true, ".avi": true, ".m4v": true,
|
|
".pdf": true, ".docx": true, ".xlsx": true, ".pptx": true, ".odt": true, ".ods": true, ".jar": true,
|
|
}
|
|
|
|
// ZipItems traduit des chemins virtuels en éléments à archiver ; les doublons
|
|
// de noms (même nom dans deux dossiers) reçoivent un suffixe « (2) ». Renvoie
|
|
// aussi un nom d'archive : celui de l'élément unique, sinon « fichiers ».
|
|
func (u *Space) ZipItems(paths []string) ([]ZipItem, string, error) {
|
|
if len(paths) == 0 {
|
|
return nil, "", ErrInvalidPath
|
|
}
|
|
var items []ZipItem
|
|
used := map[string]bool{}
|
|
for _, p := range paths {
|
|
st, rel, err := u.route(p)
|
|
if err != nil {
|
|
return nil, "", err
|
|
}
|
|
e, err := st.Stat(rel)
|
|
if err != nil {
|
|
return nil, "", err
|
|
}
|
|
name := path.Base(e.Path)
|
|
if e.Path == "" {
|
|
name = "fichiers" // racine de l'espace personnel
|
|
}
|
|
items = append(items, ZipItem{Root: st, Rel: e.Path, Name: uniqueZipName(name, used)})
|
|
}
|
|
archive := "fichiers"
|
|
if len(items) == 1 {
|
|
archive = items[0].Name
|
|
}
|
|
return items, archive, nil
|
|
}
|
|
|
|
func uniqueZipName(name string, used map[string]bool) string {
|
|
n := name
|
|
for i := 2; used[strings.ToLower(n)]; i++ {
|
|
ext := path.Ext(name)
|
|
n = fmt.Sprintf("%s (%d)%s", strings.TrimSuffix(name, ext), i, ext)
|
|
}
|
|
used[strings.ToLower(n)] = true
|
|
return n
|
|
}
|
|
|
|
// 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) {
|
|
e, err := s.Stat(rel)
|
|
if err != nil {
|
|
return ZipItem{}, err
|
|
}
|
|
return ZipItem{Root: s, Rel: e.Path, Name: path.Base(e.Path)}, nil
|
|
}
|
|
|
|
// 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 {
|
|
base := it.Rel
|
|
err := it.Root.Walk(it.Rel, func(rel string, e Entry) error {
|
|
name := it.Name
|
|
if rel != base {
|
|
name = path.Join(it.Name, strings.TrimPrefix(strings.TrimPrefix(rel, base), "/"))
|
|
}
|
|
if e.IsDir {
|
|
_, err := zw.CreateHeader(&zip.FileHeader{Name: name + "/", Method: zip.Store, Modified: e.ModTime})
|
|
return err
|
|
}
|
|
return addZipFile(zw, it.Root, rel, name, e)
|
|
})
|
|
if err != nil && !errors.Is(err, ErrNotFound) {
|
|
return err
|
|
}
|
|
}
|
|
return zw.Close()
|
|
}
|
|
|
|
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: e.ModTime}
|
|
if compressed[strings.ToLower(path.Ext(name))] {
|
|
h.Method = zip.Store
|
|
}
|
|
h.UncompressedSize64 = uint64(e.Size)
|
|
out, err := zw.CreateHeader(h)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
_, err = io.Copy(out, f)
|
|
return err
|
|
}
|