94 lines
2.9 KiB
Go
94 lines
2.9 KiB
Go
// Package s3 adapts a caller-owned MinIO client to S3-compatible object storage.
|
|
package s3
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"git.yuntuo.hk/k2safe/go-omni/storage"
|
|
"github.com/minio/minio-go/v7"
|
|
"io"
|
|
"net/url"
|
|
"strings"
|
|
"time"
|
|
)
|
|
|
|
type Store struct {
|
|
client *minio.Client
|
|
bucket string
|
|
maxBytes int64
|
|
}
|
|
|
|
func New(client *minio.Client, bucket string, maxBytes int64) (*Store, error) {
|
|
if client == nil || bucket == "" || maxBytes < 0 {
|
|
return nil, errors.New("storage/s3: client, bucket and nonnegative limit required")
|
|
}
|
|
if maxBytes == 0 {
|
|
maxBytes = 32 << 20
|
|
}
|
|
return &Store{client: client, bucket: bucket, maxBytes: maxBytes}, nil
|
|
}
|
|
func (s *Store) Put(ctx context.Context, key string, reader io.Reader, size int64, contentType string) (storage.Info, error) {
|
|
if err := storage.Check(ctx, key); err != nil {
|
|
return storage.Info{}, err
|
|
}
|
|
if reader == nil || size < 0 || len(contentType) > 256 || strings.ContainsAny(contentType, "\r\n") {
|
|
return storage.Info{}, errors.New("storage/s3: invalid upload")
|
|
}
|
|
if size > s.maxBytes {
|
|
return storage.Info{}, storage.ErrTooLarge
|
|
}
|
|
result, err := s.client.PutObject(ctx, s.bucket, key, storage.ContextReader{Context: ctx, Reader: reader}, size, minio.PutObjectOptions{ContentType: contentType})
|
|
if err != nil {
|
|
return storage.Info{}, err
|
|
}
|
|
return storage.Info{Key: key, Size: result.Size, ContentType: contentType, ModifiedAt: time.Now().UTC()}, nil
|
|
}
|
|
func (s *Store) Get(ctx context.Context, key string) (storage.Object, error) {
|
|
if err := storage.Check(ctx, key); err != nil {
|
|
return storage.Object{}, err
|
|
}
|
|
object, err := s.client.GetObject(ctx, s.bucket, key, minio.GetObjectOptions{})
|
|
if err != nil {
|
|
return storage.Object{}, mapError(err)
|
|
}
|
|
stat, err := object.Stat()
|
|
if err != nil {
|
|
object.Close()
|
|
return storage.Object{}, mapError(err)
|
|
}
|
|
if stat.Size > s.maxBytes {
|
|
object.Close()
|
|
return storage.Object{}, storage.ErrTooLarge
|
|
}
|
|
return storage.Object{Info: storage.Info{Key: key, Size: stat.Size, ContentType: stat.ContentType, ModifiedAt: stat.LastModified}, Body: object}, nil
|
|
}
|
|
func (s *Store) Delete(ctx context.Context, key string) error {
|
|
if err := storage.Check(ctx, key); err != nil {
|
|
return err
|
|
}
|
|
err := s.client.RemoveObject(ctx, s.bucket, key, minio.RemoveObjectOptions{})
|
|
if errors.Is(mapError(err), storage.ErrNotFound) {
|
|
return nil
|
|
}
|
|
return err
|
|
}
|
|
func (s *Store) PresignGet(ctx context.Context, key string, ttl time.Duration) (*url.URL, error) {
|
|
if err := storage.Check(ctx, key); err != nil {
|
|
return nil, err
|
|
}
|
|
if ttl < time.Second || ttl > time.Hour {
|
|
return nil, errors.New("storage/s3: TTL must be 1s..1h")
|
|
}
|
|
return s.client.PresignedGetObject(ctx, s.bucket, key, ttl, url.Values{"response-content-disposition": {"attachment"}})
|
|
}
|
|
func mapError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
switch minio.ToErrorResponse(err).Code {
|
|
case "NoSuchKey", "NoSuchObject":
|
|
return storage.ErrNotFound
|
|
}
|
|
return err
|
|
}
|