diff --git a/go.mod b/go.mod index b727cc3..b78b127 100644 --- a/go.mod +++ b/go.mod @@ -2,13 +2,26 @@ module github.com/vblogio/upandown go 1.24.7 -require github.com/jackc/pgx/v5 v5.7.2 +require ( + github.com/jackc/pgx/v5 v5.7.2 + github.com/minio/minio-go/v7 v7.0.80 +) require ( + github.com/dustin/go-humanize v1.0.1 // indirect + github.com/go-ini/ini v1.67.0 // indirect + github.com/goccy/go-json v0.10.3 // indirect + github.com/google/uuid v1.6.0 // indirect github.com/jackc/pgpassfile v1.0.0 // indirect github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 // indirect github.com/jackc/puddle/v2 v2.2.2 // indirect + github.com/klauspost/compress v1.17.11 // indirect + github.com/klauspost/cpuid/v2 v2.2.8 // indirect + github.com/minio/md5-simd v1.1.2 // indirect + github.com/rs/xid v1.6.0 // indirect golang.org/x/crypto v0.31.0 // indirect + golang.org/x/net v0.30.0 // indirect golang.org/x/sync v0.10.0 // indirect + golang.org/x/sys v0.28.0 // indirect golang.org/x/text v0.21.0 // indirect ) diff --git a/go.sum b/go.sum index 731b5df..23d16dc 100644 --- a/go.sum +++ b/go.sum @@ -1,6 +1,14 @@ github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY= +github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto= +github.com/go-ini/ini v1.67.0 h1:z6ZrTEZqSWOTyH2FlglNbNgARyHG8oLW9gMELqKr06A= +github.com/go-ini/ini v1.67.0/go.mod h1:ByCAeIL28uOIIG0E3PJtZPDL8WnHpFKFOtgjp+3Ies8= +github.com/goccy/go-json v0.10.3 h1:KZ5WoDbxAIgm2HNbYckL0se1fHD6rz5j4ywS6ebzDqA= +github.com/goccy/go-json v0.10.3/go.mod h1:oq7eo15ShAhp70Anwd5lgX2pLfOS3QCiwU/PULtXL6M= +github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= +github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM= github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg= github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 h1:iCEnooe7UlwOQYpKFhBabPMi4aNAfoODPEFNiAnClxo= @@ -9,17 +17,33 @@ github.com/jackc/pgx/v5 v5.7.2 h1:mLoDLV6sonKlvjIEsV56SkWNCnuNv531l94GaIzO+XI= github.com/jackc/pgx/v5 v5.7.2/go.mod h1:ncY89UGWxg82EykZUwSpUKEfccBGGYq1xjrOpsbsfGQ= github.com/jackc/puddle/v2 v2.2.2 h1:PR8nw+E/1w0GLuRFSmiioY6UooMp6KJv0/61nB7icHo= github.com/jackc/puddle/v2 v2.2.2/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4= +github.com/klauspost/compress v1.17.11 h1:In6xLpyWOi1+C7tXUUWv2ot1QvBjxevKAaI6IXrJmUc= +github.com/klauspost/compress v1.17.11/go.mod h1:pMDklpSncoRMuLFrf1W9Ss9KT+0rH90U12bZKk7uwG0= +github.com/klauspost/cpuid/v2 v2.0.1/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg= +github.com/klauspost/cpuid/v2 v2.2.8 h1:+StwCXwm9PdpiEkPyzBXIy+M9KUb4ODm0Zarf1kS5BM= +github.com/klauspost/cpuid/v2 v2.2.8/go.mod h1:Lcz8mBdAVJIBVzewtcLocK12l3Y+JytZYpaMropDUws= +github.com/minio/md5-simd v1.1.2 h1:Gdi1DZK69+ZVMoNHRXJyNcxrMA4dSxoYHZSQbirFg34= +github.com/minio/md5-simd v1.1.2/go.mod h1:MzdKDxYpY2BT9XQFocsiZf/NKVtR7nkE4RoEpN+20RM= +github.com/minio/minio-go/v7 v7.0.80 h1:2mdUHXEykRdY/BigLt3Iuu1otL0JTogT0Nmltg0wujk= +github.com/minio/minio-go/v7 v7.0.80/go.mod h1:84gmIilaX4zcvAWWzJ5Z1WI5axN+hAbM5w25xf8xvC0= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/rs/xid v1.6.0 h1:fV591PaemRlL6JfRxGDEPl69wICngIQ3shQtzfy2gxU= +github.com/rs/xid v1.6.0/go.mod h1:7XoLgs4eV+QndskICGsho+ADou8ySMSjJKDIan90Nz0= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= -github.com/stretchr/testify v1.8.1 h1:w7B6lhMri9wdJUVmEZPGGhZzrYTPvgJArz7wNPgYKsk= -github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= +github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg= +github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= golang.org/x/crypto v0.31.0 h1:ihbySMvVjLAeSH1IbfcRTkD/iNscyz8rGzjF/E5hV6U= golang.org/x/crypto v0.31.0/go.mod h1:kDsLvtWBEx7MV9tJOj9bnXsPbxwJQ6csT/x4KIN4Ssk= +golang.org/x/net v0.30.0 h1:AcW1SDZMkb8IpzCdQUaIq2sP4sZ4zw+55h6ynffypl4= +golang.org/x/net v0.30.0/go.mod h1:2wGyMJ5iFasEhkwi13ChkO/t1ECNC4X4eBKkVFyYFlU= golang.org/x/sync v0.10.0 h1:3NQrjDixjgGwUOCaF8w2+VYHv0Ve/vGYSbdkTa98gmQ= golang.org/x/sync v0.10.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= +golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.28.0 h1:Fksou7UEQUWlKvIdsqzJmUmCX3cZuD2+P3XyyzwMhlA= +golang.org/x/sys v0.28.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= golang.org/x/text v0.21.0 h1:zyQAAkrwaneQ066sspRyJaG9VNi/YJ1NfzcGB3hZ/qo= golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= diff --git a/internal/catalog/migrations/003_s3.sql b/internal/catalog/migrations/003_s3.sql new file mode 100644 index 0000000..cbdc239 --- /dev/null +++ b/internal/catalog/migrations/003_s3.sql @@ -0,0 +1,36 @@ +-- Arborescence de la racine S3 : un nœud par fichier ou dossier. Les contenus +-- sont dans le bucket sous object_key, clé fixée au dépôt : renommer ou +-- déplacer ne modifie que ces lignes. La corbeille range les nœuds sous +-- « .trash// ». +CREATE TABLE s3_nodes ( + path text PRIMARY KEY, + dir text NOT NULL, + name text NOT NULL, + is_dir boolean NOT NULL, + size bigint NOT NULL DEFAULT 0, + mtime timestamptz NOT NULL, + object_key text, + created_by text NOT NULL DEFAULT '' +); +CREATE INDEX s3_nodes_dir ON s3_nodes (dir); +CREATE INDEX s3_nodes_prefix ON s3_nodes (path text_pattern_ops); + +CREATE TABLE s3_trash ( + id text PRIMARY KEY, + origin text NOT NULL, + name text NOT NULL, + is_dir boolean NOT NULL, + size bigint NOT NULL DEFAULT 0, + deleted timestamptz NOT NULL, + deleted_by text NOT NULL DEFAULT '', + meta jsonb +); + +-- Configuration de la racine S3 saisie dans l'interface d'administration +-- (les variables d'environnement l'emportent champ par champ). La clé secrète +-- y est chiffrée avec une clé dérivée de SHARE_SECRET. +CREATE TABLE s3_config ( + id integer PRIMARY KEY CHECK (id = 1), + data jsonb NOT NULL, + updated timestamptz NOT NULL DEFAULT clock_timestamp() +); diff --git a/internal/storage/details.go b/internal/storage/details.go index ba64183..f210089 100644 --- a/internal/storage/details.go +++ b/internal/storage/details.go @@ -32,6 +32,17 @@ type Details struct { const maxDirWalk = 20000 func (s *Store) fileDetails(rel string, meta map[string]itemMeta, shares map[string]int) (*Details, error) { + if s.s3 != nil { + c, _, err := s.lstat(rel) + if err != nil { + return nil, err + } + d := &Details{Shares: shares[c]} + if m := meta[c]; m.Created != nil { + d.Created, d.CreatedBy = m.Created, m.CreatedBy + } + return d, nil + } c, abs, err := s.resolve(rel) if err != nil { return nil, err @@ -83,6 +94,13 @@ func (s *Store) versionCount(c string) (int, string) { // dirDetails compte le contenu d'un dossier : éléments directs, puis taille // et nombre de fichiers de toute l'arborescence (borné à maxDirWalk entrées). func (s *Store) dirDetails(rel string) (*Details, error) { + if s.s3 != nil { + c, err := Clean(rel) + if err != nil { + return nil, err + } + return s.s3DirDetails(c) + } _, abs, err := s.resolve(rel) if err != nil { return nil, err diff --git a/internal/storage/history.go b/internal/storage/history.go index a02f97e..dd7cc89 100644 --- a/internal/storage/history.go +++ b/internal/storage/history.go @@ -149,6 +149,12 @@ func (s *Store) autoSnapshot(c, abs string, fi fs.FileInfo) { // Versions liste les versions d'un fichier existant, la plus récente en premier. func (s *Store) Versions(rel string) ([]Version, error) { + if s.s3 != nil { // pas d'historique sur S3 + if _, err := s.Stat(rel); err != nil { + return nil, err + } + return []Version{}, nil + } c, abs, err := s.resolve(rel) if err != nil { return nil, err diff --git a/internal/storage/meta.go b/internal/storage/meta.go index 399ecb3..389a111 100644 --- a/internal/storage/meta.go +++ b/internal/storage/meta.go @@ -179,15 +179,15 @@ func normTag(t string) (string, error) { func (s *Store) editMeta(paths []string, edit func(*itemMeta) error) error { cs := make([]string, 0, len(paths)) for _, p := range paths { - c, abs, err := s.resolve(p) + c, err := Clean(p) if err != nil { return err } if c == "" { return ErrInvalidPath } - if _, err := os.Lstat(abs); err != nil { - return mapErr(err) + if _, _, err := s.lstat(c); err != nil { + return err } cs = append(cs, c) } @@ -218,12 +218,8 @@ func (s *Store) SetIcon(paths []string, icon string) error { return fmt.Errorf("%w : icône %q", ErrInvalidPath, icon) } for _, p := range paths { - _, abs, err := s.resolve(p) - if err != nil { + if _, fi, err := s.lstat(p); err != nil { return err - } - if fi, err := os.Lstat(abs); err != nil { - return mapErr(err) } else if !fi.IsDir() { return fmt.Errorf("%w : %q n'est pas un dossier", ErrInvalidPath, p) } diff --git a/internal/storage/root.go b/internal/storage/root.go index 6c31fba..2a9f158 100644 --- a/internal/storage/root.go +++ b/internal/storage/root.go @@ -52,6 +52,13 @@ 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 { + if s.s3 != nil { + c, err := Clean(rel) + if err != nil { + return err + } + return s.s3Walk(c, fn) + } c, abs, err := s.resolve(rel) if err != nil { return err @@ -91,6 +98,13 @@ func (s *Store) Walk(rel string, fn WalkFunc) error { // 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 { + if s.s3 != nil { + c, err := Clean(rel) + if err != nil { + return err + } + return s.s3Remove(c) + } c, abs, err := s.resolve(rel) if err != nil { return err diff --git a/internal/storage/s3minio.go b/internal/storage/s3minio.go new file mode 100644 index 0000000..c62e0f2 --- /dev/null +++ b/internal/storage/s3minio.go @@ -0,0 +1,134 @@ +package storage + +import ( + "context" + "errors" + "fmt" + "io" + "net/http" + "net/url" + "strings" + + "github.com/minio/minio-go/v7" + "github.com/minio/minio-go/v7/pkg/credentials" +) + +// S3Config décrit la connexion au bucket (Garage ou tout S3 compatible). +type S3Config struct { + Endpoint string // URL (https://garage:3900) ou hôte:port + Region string // Garage : celle de sa configuration (s3_region), "garage" par défaut + Bucket string + AccessKey string + SecretKey string + Insecure bool // endpoint sans schéma : HTTP au lieu de HTTPS + + transport http.RoundTripper // tests +} + +// Valid indique si la configuration est complète. +func (c S3Config) Valid() bool { + return c.Endpoint != "" && c.Bucket != "" && c.AccessKey != "" && c.SecretKey != "" +} + +// partSize : taille des parties d'un envoi en plusieurs morceaux (mémoire +// tampon par envoi en cours). +const partSize = 16 << 20 + +type minioObjects struct { + c *minio.Client + bucket string +} + +// NewMinioObjects ouvre le bucket décrit par cfg et vérifie qu'il existe. +func NewMinioObjects(ctx context.Context, cfg S3Config) (ObjectStore, error) { + if !cfg.Valid() { + return nil, errors.New("configuration S3 incomplète (endpoint, bucket, clés)") + } + host, secure := cfg.Endpoint, !cfg.Insecure + if u, err := url.Parse(cfg.Endpoint); err == nil && u.Host != "" { + host, secure = u.Host, u.Scheme == "https" + } + region := cfg.Region + if region == "" { + region = "garage" + } + c, err := minio.New(host, &minio.Options{ + Creds: credentials.NewStaticV4(cfg.AccessKey, cfg.SecretKey, ""), + Secure: secure, + Region: region, + BucketLookup: minio.BucketLookupPath, // Garage : style chemin + Transport: cfg.transport, + }) + if err != nil { + return nil, err + } + ok, err := c.BucketExists(ctx, cfg.Bucket) + if err != nil { + return nil, fmt.Errorf("bucket %s : %w", cfg.Bucket, err) + } + if !ok { + return nil, fmt.Errorf("bucket %s introuvable", cfg.Bucket) + } + return &minioObjects{c: c, bucket: cfg.Bucket}, nil +} + +func (m *minioObjects) Put(ctx context.Context, key string, r io.Reader, meta map[string]string) (int64, error) { + info, err := m.c.PutObject(ctx, m.bucket, key, r, -1, minio.PutObjectOptions{ + UserMetadata: meta, PartSize: partSize, ContentType: "application/octet-stream", + }) + return info.Size, err +} + +// minioFile : objet lu par plages (Seek puis Read relance un GET partiel). +type minioFile struct{ *minio.Object } + +func (m *minioObjects) Get(ctx context.Context, key string) (File, error) { + // Le contexte de l'appelant ne borne que l'ouverture : la lecture dure + // autant que le téléchargement. + o, err := m.c.GetObject(context.Background(), m.bucket, key, minio.GetObjectOptions{}) + if err != nil { + return nil, err + } + if _, err := o.Stat(); err != nil { + o.Close() + if minio.ToErrorResponse(err).Code == "NoSuchKey" { + return nil, ErrNotFound + } + return nil, err + } + return minioFile{o}, nil +} + +func (m *minioObjects) Copy(ctx context.Context, src, dst string, meta map[string]string) error { + dstOpts := minio.CopyDestOptions{Bucket: m.bucket, Object: dst, UserMetadata: meta, ReplaceMetadata: true} + srcOpts := minio.CopySrcOptions{Bucket: m.bucket, Object: src} + info, err := m.c.StatObject(ctx, m.bucket, src, minio.StatObjectOptions{}) + if err != nil { + return err + } + if info.Size < 5<<30 { // CopyObject : une requête, jusqu'à 5 Go + _, err = m.c.CopyObject(ctx, dstOpts, srcOpts) + return err + } + // Au-delà : copie par parties (UploadPartCopy, implémenté par Garage). + _, err = m.c.ComposeObject(ctx, dstOpts, srcOpts) + return err +} + +func (m *minioObjects) Remove(ctx context.Context, key string) error { + return m.c.RemoveObject(ctx, m.bucket, key, minio.RemoveObjectOptions{}) +} + +func (m *minioObjects) Empty(ctx context.Context) (bool, error) { + ctx, cancel := context.WithCancel(ctx) + defer cancel() + for o := range m.c.ListObjects(ctx, m.bucket, minio.ListObjectsOptions{Recursive: true, MaxKeys: 1}) { + if o.Err != nil { + return false, o.Err + } + if !strings.HasPrefix(o.Key, ".upandown/") { + return false, nil + } + } + return true, nil +} diff --git a/internal/storage/search.go b/internal/storage/search.go index c1221c6..5dcd5e0 100644 --- a/internal/storage/search.go +++ b/internal/storage/search.go @@ -156,6 +156,32 @@ func (s *Store) Search(q string, f Filter, limit int) ([]Hit, error) { return []Hit{}, nil } meta := s.metaSnapshot() + if s.s3 != nil { // S3 : noms et tags seulement, pas de plein texte + out := []Hit{} + err := s.s3Walk("", func(rel string, e Entry) error { + if rel == "" || len(out) >= limit { + return nil + } + hit := Hit{Entry: e} + decorate(&hit.Entry, meta) + if f.Favorite && !hit.Favorite { + return nil + } + tags := fold(strings.Join(hit.Tags, "\n")) + if tag != "" && !strings.Contains("\n"+tags+"\n", "\n"+tag+"\n") { + return nil + } + name := fold(e.Name) + "\n" + tags + for _, t := range terms { + if !strings.Contains(name, t) { + return nil + } + } + out = append(out, hit) + return nil + }) + return out, err + } s.index.mu.Lock() defer s.index.mu.Unlock() if s.index.docs == nil { diff --git a/internal/storage/share.go b/internal/storage/share.go index a92a44e..730962c 100644 --- a/internal/storage/share.go +++ b/internal/storage/share.go @@ -208,7 +208,7 @@ func (s *Store) editShares(edit func(map[string]shareDisk) (bool, error)) error func (s *Store) toShare(key []byte, id string, d shareDisk) Share { sh := Share{ID: id, Token: id + "." + sign(key, id), Path: d.Path, Created: d.Created, Expires: d.Expires, Protected: d.Password != "", Downloads: d.Downloads, pw: d.Password} - if fi, err := os.Stat(absOf(s, d.Path)); err == nil { + if _, fi, err := s.lstat(d.Path); err == nil { sh.IsDir = fi.IsDir() } return sh @@ -219,15 +219,15 @@ const MaxPasswordLen = 200 // CreateShare crée un lien de partage d'un fichier ou d'un dossier. func (s *Store) CreateShare(rel string, o ShareOptions) (Share, error) { - c, abs, err := s.resolve(rel) + c, err := Clean(rel) if err != nil { return Share{}, err } if c == "" { return Share{}, ErrInvalidPath } - if fi, err := os.Lstat(abs); err != nil { - return Share{}, mapErr(err) + if _, fi, err := s.lstat(c); err != nil { + return Share{}, err } else if !fi.IsDir() && !fi.Mode().IsRegular() { return Share{}, ErrNotFound } @@ -266,7 +266,7 @@ func (s *Store) Shares(rel string) ([]Share, error) { c := "" if rel != "" { var err error - if c, _, err = s.resolve(rel); err != nil { + if c, err = Clean(rel); err != nil { return nil, err } } diff --git a/internal/storage/storage.go b/internal/storage/storage.go index c7ba42a..62bef0a 100644 --- a/internal/storage/storage.go +++ b/internal/storage/storage.go @@ -94,6 +94,8 @@ type Store struct { fixedKey bool // clé imposée par SHARE_SECRET keyFrom *Store // espace personnel : clé de signature du Store principal + s3 *s3Root // racine S3 (s3.go) ; nil : disque + usageMu sync.Mutex usageAt time.Time usageSize int64 @@ -209,6 +211,13 @@ func visible(name string) bool { return !strings.HasPrefix(name, ".") } // List renvoie le contenu d'un dossier : dossiers d'abord, puis fichiers, // triés par nom (insensible à la casse). func (s *Store) List(rel string) ([]Entry, error) { + if s.s3 != nil { + c, err := Clean(rel) + if err != nil { + return nil, err + } + return s.s3List(c) + } c, abs, err := s.resolve(rel) if err != nil { return nil, err @@ -243,6 +252,13 @@ func (s *Store) List(rel string) ([]Entry, error) { // Stat décrit un fichier ou un dossier. func (s *Store) Stat(rel string) (Entry, error) { + if s.s3 != nil { + c, err := Clean(rel) + if err != nil { + return Entry{}, err + } + return s.s3Stat(c) + } c, abs, err := s.resolve(rel) if err != nil { return Entry{}, err @@ -266,6 +282,13 @@ func ETag(fi fs.FileInfo) string { // Open ouvre un fichier en lecture. Les liens symboliques sont refusés. func (s *Store) Open(rel string) (File, fs.FileInfo, error) { + if s.s3 != nil { + c, err := Clean(rel) + if err != nil { + return nil, nil, err + } + return s.s3Open(c) + } c, abs, err := s.resolve(rel) if err != nil { return nil, nil, err @@ -314,6 +337,13 @@ type PutOptions struct { // dossiers parents sont créés. Renvoie l'entrée écrite (son chemin peut // différer de rel avec Conflict = "rename"). func (s *Store) Put(rel string, r io.Reader, o PutOptions) (Entry, error) { + if s.s3 != nil { + c, err := Clean(rel) + if err != nil { + return Entry{}, err + } + return s.s3Put(c, r, o) + } c, abs, err := s.resolve(rel) if err != nil { return Entry{}, err @@ -408,6 +438,13 @@ func (s *Store) Put(rel string, r io.Reader, o PutOptions) (Entry, error) { // Mkdir crée un dossier (et ses parents). func (s *Store) Mkdir(rel string) (Entry, error) { + if s.s3 != nil { + c, err := Clean(rel) + if err != nil { + return Entry{}, err + } + return s.s3Mkdir(c) + } c, abs, err := s.resolve(rel) if err != nil { return Entry{}, err @@ -434,6 +471,17 @@ func (s *Store) Mkdir(rel string) (Entry, error) { // Move renomme ou déplace un fichier ou un dossier. La destination ne doit // pas exister ; un dossier ne peut pas être déplacé dans lui-même. func (s *Store) Move(from, to string) (Entry, error) { + if s.s3 != nil { + cf, err := Clean(from) + if err != nil { + return Entry{}, err + } + ct, err := Clean(to) + if err != nil { + return Entry{}, err + } + return s.s3Move(cf, ct) + } cf, af, err := s.resolve(from) if err != nil { return Entry{}, err @@ -491,6 +539,17 @@ func (r MoveResult) Err() error { return r.err } // Copy duplique un fichier, ou un dossier avec tout son contenu (fichiers // réguliers seulement). Les tags sont copiés, pas les favoris ni les partages. func (s *Store) Copy(from, to string) (Entry, error) { + if s.s3 != nil { + cf, err := Clean(from) + if err != nil { + return Entry{}, err + } + ct, err := Clean(to) + if err != nil { + return Entry{}, err + } + return s.s3Copy(cf, ct) + } cf, af, err := s.resolve(from) if err != nil { return Entry{}, err @@ -592,6 +651,13 @@ func (s *Store) Delete(rel string, recursive bool) error { // deleteAs est Delete en notant l'auteur de la suppression (by). func (s *Store) deleteAs(rel string, recursive bool, by string) error { + if s.s3 != nil { + c, err := Clean(rel) + if err != nil { + return err + } + return s.s3Delete(c, recursive, by) + } c, abs, err := s.resolve(rel) if err != nil { return err @@ -654,6 +720,9 @@ func (s *Store) usageDirty() { // compris ; miniatures exclues). Le résultat est gardé 15 s, ou jusqu'à la // prochaine écriture. func (s *Store) Usage() int64 { + if s.s3 != nil { + return s.s3Usage() + } s.usageMu.Lock() defer s.usageMu.Unlock() if time.Since(s.usageAt) < 15*time.Second { diff --git a/internal/storage/thumbs.go b/internal/storage/thumbs.go index a0ecd0b..0de0b43 100644 --- a/internal/storage/thumbs.go +++ b/internal/storage/thumbs.go @@ -53,15 +53,11 @@ func (s *Store) thumbAbs(c string, isDir bool) string { // type MIME et sa date. ErrNotFound si le fichier n'est pas une image // décodable. func (s *Store) Thumb(rel string) ([]byte, string, time.Time, error) { - c, abs, err := s.resolve(rel) + c, src, err := s.lstat(rel) if err != nil { return nil, "", time.Time{}, err } - if c == "" || !isDecodableImage(c) { - return nil, "", time.Time{}, ErrNotFound - } - src, err := os.Lstat(abs) - if err != nil || !src.Mode().IsRegular() { + if c == "" || !isDecodableImage(c) || !src.Mode().IsRegular() { return nil, "", time.Time{}, ErrNotFound } ta := s.thumbAbs(c, false) @@ -75,7 +71,12 @@ func (s *Store) Thumb(rel string) ([]byte, string, time.Time, error) { } s.thumbSem <- struct{}{} defer func() { <-s.thumbSem }() - b, err := makeThumb(abs) + f, _, err := s.Open(c) + if err != nil { + return nil, "", time.Time{}, ErrNotFound + } + b, err := makeThumb(f) + f.Close() if err != nil { return nil, "", time.Time{}, ErrNotFound } @@ -92,12 +93,7 @@ func sniffThumb(b []byte) string { return "image/jpeg" } -func makeThumb(abs string) ([]byte, error) { - f, err := os.Open(abs) - if err != nil { - return nil, err - } - defer f.Close() +func makeThumb(f io.ReadSeeker) ([]byte, error) { cfg, format, err := image.DecodeConfig(f) if err != nil { return nil, err diff --git a/internal/storage/trash.go b/internal/storage/trash.go index c0bec46..f429f64 100644 --- a/internal/storage/trash.go +++ b/internal/storage/trash.go @@ -114,6 +114,9 @@ func (s *Store) trashEntry(id string) (string, trashInfo, error) { // TrashItems liste la corbeille, les suppressions les plus récentes en premier. func (s *Store) TrashItems() ([]TrashItem, error) { + if s.s3 != nil { + return s.s3TrashItems() + } des, err := os.ReadDir(filepath.Join(s.root, trashDir)) if errors.Is(err, fs.ErrNotExist) { return []TrashItem{}, nil @@ -146,6 +149,9 @@ func (s *Store) TrashItems() ([]TrashItem, error) { // TrashCount renvoie le nombre d'éléments dans la corbeille. func (s *Store) TrashCount() int { + if s.s3 != nil { + return s.s3TrashCount() + } des, _ := os.ReadDir(filepath.Join(s.root, trashDir)) n := 0 for _, de := range des { @@ -159,6 +165,9 @@ func (s *Store) TrashCount() int { // RestoreTrash remet un élément à son emplacement d'origine (dossiers parents // recréés au besoin), sous un autre nom si la place est prise. func (s *Store) RestoreTrash(id string) (Entry, error) { + if s.s3 != nil { + return s.s3RestoreTrash(id) + } name, info, err := s.trashEntry(id) if err != nil { return Entry{}, err @@ -193,6 +202,12 @@ func (s *Store) RestoreTrash(id string) (Entry, error) { // DropTrash supprime définitivement un élément de la corbeille. func (s *Store) DropTrash(id string) error { + if s.s3 != nil { + if !trashID.MatchString(id) { + return fmt.Errorf("%w : élément de corbeille %q", ErrInvalidPath, id) + } + return s.s3DropTrash(func(i string) bool { return i == id }) + } if _, _, err := s.trashEntry(id); err != nil { return err } @@ -214,6 +229,9 @@ func (s *Store) PurgeTrashOlder(maxAge time.Duration) error { } func (s *Store) purgeTrash(drop func(id string) bool) error { + if s.s3 != nil { + return s.s3DropTrash(drop) + } root := filepath.Join(s.root, trashDir) des, err := os.ReadDir(root) if errors.Is(err, fs.ErrNotExist) {