Arborescence dans s3_nodes, contenus sous des clés o/<id> figées au dépôt, corbeille dans s3_trash, configuration admin dans s3_config. Délégations S3 dans List/Stat/Open/Put/Mkdir/Move/Copy/Delete/Walk/corbeille, miniatures, partages, tags, recherche (noms et tags). Pas d'historique. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01LNfwm4pfYR9C914C2EeiuB
135 lines
4.0 KiB
Go
135 lines
4.0 KiB
Go
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
|
|
}
|