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 }