Files
mtusi2026lab6/app/internal/objectstore/s3.go
T

252 lines
9.1 KiB
Go

package objectstore
import (
"context"
"crypto/hmac"
"crypto/sha256"
"errors"
"fmt"
"io"
"net/http"
"net/url"
"os"
"strings"
"time"
"github.com/minio/minio-go/v7"
"github.com/minio/minio-go/v7/pkg/credentials"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/config"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/domain"
)
// S3 работает с любым S3-совместимым сервером; на стенде это SeaweedFS.
type S3 struct {
signingCreds *credentials.Credentials
region string
ticketKey []byte
client *minio.Client
core minio.Core
endpoint string
bucket string
timeout time.Duration
}
var (
_ Store = (*S3)(nil)
_ Lister = (*S3)(nil)
)
// NewS3 только готовит клиента и не обращается к серверу: недоступность S3 при запуске не мешает
// реплике обслуживать пользователей и сообщения.
func NewS3(cfg config.S3) (*S3, error) {
u, err := url.Parse(cfg.Endpoint)
if err != nil || u.Host == "" || (u.Scheme != "http" && u.Scheme != "https") {
return nil, errors.New("objectstore: S3_ENDPOINT must be http(s)://host:port")
}
id, err := readSecret("S3_ACCESS_KEY_ID_FILE", cfg.AccessKeyIDFile)
if err != nil {
return nil, err
}
secret, err := readSecret("S3_SECRET_ACCESS_KEY_FILE", cfg.SecretAccessKeyFile)
if err != nil {
return nil, err
}
client, err := minio.New(u.Host, &minio.Options{
Creds: credentials.NewStaticV4(id, secret, ""),
Secure: u.Scheme == "https",
Region: cfg.Region,
BucketLookup: minio.BucketLookupPath,
})
if err != nil {
return nil, fmt.Errorf("objectstore: client: %w", err)
}
return &S3{
signingCreds: credentials.NewStaticV4(id, secret, ""),
region: cfg.Region,
ticketKey: []byte(secret),
client: client,
core: minio.Core{Client: client},
endpoint: cfg.Endpoint,
bucket: cfg.Bucket,
timeout: time.Duration(cfg.TimeoutMs) * time.Millisecond,
}, nil
}
func readSecret(name, path string) (string, error) {
if path == "" {
return "", fmt.Errorf("objectstore: %s is required", name)
}
b, err := os.ReadFile(path)
if err != nil {
return "", fmt.Errorf("objectstore: read %s: %w", name, err)
}
v := strings.TrimSpace(string(b))
if v == "" {
return "", fmt.Errorf("objectstore: %s is empty", name)
}
return v, nil
}
// unavailable скрывает детали S3 от клиента: наружу уходит только 503.
func unavailable(op string, err error) error {
return fmt.Errorf("%w: s3 %s: %v", domain.ErrUnavailable, op, err)
}
// Put отправляет объект одним запросом и не буферизует его. Multipart выключен намеренно: при обрыве
// одиночного PUT объект не появляется, а незавершённых multipart-загрузок, которые надо отдельно
// искать и отменять, просто не существует.
func (s *S3) Put(ctx context.Context, key, contentType string, body io.Reader, size int64) error {
ctx, cancel := context.WithTimeout(ctx, s.timeout)
defer cancel()
info, err := s.client.PutObject(ctx, s.bucket, key, body, size,
minio.PutObjectOptions{ContentType: contentType, DisableMultipart: true})
if err != nil {
return unavailable("put", err)
}
if info.Size != size {
return unavailable("put", fmt.Errorf("stored %d of %d bytes", info.Size, size))
}
return nil
}
// List постранично обходит bucket; размер страницы задаёт сервер, в памяти одна страница.
func (s *S3) List(ctx context.Context, prefix string, visit func(ObjectInfo) error) error {
// Отмена нужна, чтобы при раннем выходе остановить горутину листинга клиента S3.
ctx, cancel := context.WithCancel(ctx)
defer cancel()
for object := range s.client.ListObjects(ctx, s.bucket, minio.ListObjectsOptions{Prefix: prefix, Recursive: true}) {
if object.Err != nil {
return unavailable("list", object.Err)
}
if err := visit(ObjectInfo{Key: object.Key, LastModified: object.LastModified}); err != nil {
return err
}
}
return ctx.Err()
}
func (s *S3) Get(ctx context.Context, key string) (io.ReadCloser, int64, error) {
// Таймаут нужен только на получение ответа: чтение потока ограничивает родительский контекст.
ctx, cancel := context.WithCancel(ctx)
timer := time.AfterFunc(s.timeout, cancel)
body, info, _, err := s.core.GetObject(ctx, s.bucket, key, minio.GetObjectOptions{})
timer.Stop()
if err != nil {
cancel()
if minio.ToErrorResponse(err).Code == "NoSuchKey" {
return nil, 0, ErrNotFound
}
return nil, 0, unavailable("get", err)
}
return &cancelOnClose{ReadCloser: body, cancel: cancel}, info.Size, nil
}
type cancelOnClose struct {
io.ReadCloser
cancel context.CancelFunc
}
func (c *cancelOnClose) Close() error {
defer c.cancel()
return c.ReadCloser.Close()
}
func (s *S3) Delete(ctx context.Context, key string) error {
ctx, cancel := context.WithTimeout(ctx, s.timeout)
defer cancel()
if err := s.client.RemoveObject(ctx, s.bucket, key, minio.RemoveObjectOptions{}); err != nil {
return unavailable("delete", err)
}
return nil
}
// EnsureBucket создаёт bucket, если его нет. Повторный запуск ничего не меняет и не трогает объекты.
func (s *S3) EnsureBucket(ctx context.Context) error {
ctx, cancel := context.WithTimeout(ctx, s.timeout)
defer cancel()
exists, err := s.client.BucketExists(ctx, s.bucket)
if err != nil {
return fmt.Errorf("objectstore: bucket exists: %w", err)
}
if exists {
return nil
}
err = s.client.MakeBucket(ctx, s.bucket, minio.MakeBucketOptions{})
if err != nil && minio.ToErrorResponse(err).Code != "BucketAlreadyOwnedByYou" {
return fmt.Errorf("objectstore: make bucket: %w", err)
}
return nil
}
// RemovePolicy удаляет политику bucket, если она есть, и сообщает, была ли она. Доступ на стенде
// определяют только ключи, поэтому любая политика — чужеродное изменение, а не настройка.
func (s *S3) RemovePolicy(ctx context.Context) (bool, error) {
ctx, cancel := context.WithTimeout(ctx, s.timeout)
defer cancel()
policy, err := s.client.GetBucketPolicy(ctx, s.bucket)
if err != nil && minio.ToErrorResponse(err).Code != "NoSuchBucketPolicy" {
return false, fmt.Errorf("objectstore: get policy: %w", err)
}
if policy == "" {
return false, nil
}
if err := s.client.SetBucketPolicy(ctx, s.bucket, ""); err != nil {
return false, fmt.Errorf("objectstore: remove policy: %w", err)
}
return true, nil
}
// CheckPrivate делает запрос без подписи и ожидает отказ. Политику bucket никто не задаёт, поэтому
// приватность — поведение по умолчанию, а эта проверка не даёт запустить стенд, если это не так.
func (s *S3) CheckPrivate(ctx context.Context) error {
ctx, cancel := context.WithTimeout(ctx, s.timeout)
defer cancel()
req, err := http.NewRequestWithContext(ctx, http.MethodGet, strings.TrimRight(s.endpoint, "/")+"/"+s.bucket+"/", nil)
if err != nil {
return err
}
resp, err := http.DefaultClient.Do(req)
if err != nil {
return fmt.Errorf("objectstore: anonymous probe: %w", err)
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusForbidden && resp.StatusCode != http.StatusUnauthorized {
return fmt.Errorf("objectstore: anonymous listing returned %d, bucket is not private", resp.StatusCode)
}
return nil
}
// UploadMAC uses a separate domain from S3 request signatures. Shared credentials
// allow init and complete to run on different replicas without pending DB rows.
func (s *S3) UploadMAC(data []byte) []byte {
h := hmac.New(sha256.New, s.ticketKey)
h.Write([]byte("lab4-upload-ticket-v1\x00"))
h.Write(data)
return h.Sum(nil)
}
func (s *S3) PresignUpload(ctx context.Context, key, contentType string, size int64) (string, error) {
endpoint := os.Getenv("S3_PUBLIC_ENDPOINT")
if endpoint == "" {
endpoint = s.endpoint
}
u, err := url.Parse(endpoint)
if err != nil || u.Host == "" || (u.Scheme != "http" && u.Scheme != "https") {
return "", domain.ErrUnavailable
}
// Presign with the public Host from the outset: rewriting a signed URL breaks SigV4.
client, err := minio.New(u.Host, &minio.Options{Creds: s.signingCreds, Secure: u.Scheme == "https", Region: s.region, BucketLookup: minio.BucketLookupPath})
if err != nil {
return "", unavailable("presign", err)
}
headers := http.Header{}
headers.Set("Content-Type", contentType)
headers.Set("Content-Length", fmt.Sprint(size))
signed, err := client.PresignHeader(ctx, http.MethodPut, s.bucket, key, 60*time.Second, nil, headers)
if err != nil {
return "", unavailable("presign", err)
}
return signed.String(), nil
}