forked from mtusi2026/mtusi2026lab5
252 lines
9.1 KiB
Go
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
|
|
}
|