forked from mtusi2026/mtusi2026lab5
292 lines
11 KiB
Go
292 lines
11 KiB
Go
package service
|
|
|
|
import (
|
|
"context"
|
|
"crypto/sha256"
|
|
"encoding/hex"
|
|
"errors"
|
|
"fmt"
|
|
|
|
"io"
|
|
"log/slog"
|
|
"mime"
|
|
"os"
|
|
"time"
|
|
|
|
"github.com/google/uuid"
|
|
|
|
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/domain"
|
|
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/imagecheck"
|
|
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/objectstore"
|
|
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/store"
|
|
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/validate"
|
|
)
|
|
|
|
var _ AttachmentsService = (*Attachments)(nil)
|
|
|
|
// ObjectKeyPrefix — префикс ключей оригиналов. Очиститель обходит только его.
|
|
const ObjectKeyPrefix = "originals/"
|
|
|
|
// Предел на компенсирующее удаление объекта, когда запись метаданных не удалась.
|
|
const compensationTimeout = 5 * time.Second
|
|
|
|
type AttachmentLimits struct {
|
|
MaxUploadBytes int64
|
|
MaxImagePixels int64
|
|
MaxConcurrentUploads int
|
|
}
|
|
|
|
type attachmentRepo interface {
|
|
store.ChatStore
|
|
store.AttachmentStore
|
|
}
|
|
|
|
type Attachments struct {
|
|
repo attachmentRepo
|
|
objects objectstore.Store
|
|
limits AttachmentLimits
|
|
checker *imagecheck.Checker
|
|
// uploads — слоты загрузок. Вместе с лимитом размера они ограничивают диск реплики под временные
|
|
// файлы; память на одну загрузку от размера файла не зависит.
|
|
uploads chan struct{}
|
|
logger *slog.Logger
|
|
}
|
|
|
|
func NewAttachments(repo attachmentRepo, objects objectstore.Store, limits AttachmentLimits, logger *slog.Logger) *Attachments {
|
|
return &Attachments{
|
|
repo: repo,
|
|
objects: objects,
|
|
limits: limits,
|
|
checker: imagecheck.New(limits.MaxImagePixels),
|
|
uploads: make(chan struct{}, limits.MaxConcurrentUploads),
|
|
logger: logger,
|
|
}
|
|
}
|
|
|
|
// Upload сохраняет проверенный оригинал в staging и публикует устойчивое задание до ответа 202.
|
|
func (a *Attachments) Upload(ctx context.Context, in UploadInput) (domain.Attachment, error) {
|
|
chatID, err := validate.CanonicalUUID("chat_id", in.ChatID)
|
|
if err != nil {
|
|
return domain.Attachment{}, err
|
|
}
|
|
if _, err := a.repo.ChatByID(ctx, in.CallerID, chatID); err != nil {
|
|
return domain.Attachment{}, err
|
|
}
|
|
if err := validate.Filename(in.Filename); err != nil {
|
|
return domain.Attachment{}, err
|
|
}
|
|
declared, err := parseImageType(in.ContentType)
|
|
if err != nil {
|
|
return domain.Attachment{}, err
|
|
}
|
|
if in.ContentLength > a.limits.MaxUploadBytes {
|
|
return domain.Attachment{}, domain.ErrPayloadTooLarge
|
|
}
|
|
|
|
select {
|
|
case a.uploads <- struct{}{}:
|
|
defer func() { <-a.uploads }()
|
|
default:
|
|
return domain.Attachment{}, domain.ErrRateLimited
|
|
}
|
|
|
|
spool, size, sum, err := a.spoolBody(in.Body)
|
|
if err != nil {
|
|
return domain.Attachment{}, err
|
|
}
|
|
defer spool.Close()
|
|
|
|
if err := a.checkImage(ctx, spool, declared); err != nil {
|
|
return domain.Attachment{}, err
|
|
}
|
|
if _, err := spool.Seek(0, io.SeekStart); err != nil {
|
|
return domain.Attachment{}, fmt.Errorf("%w: spool: %v", domain.ErrUnavailable, err)
|
|
}
|
|
|
|
id := uuid.NewString()
|
|
att := domain.Attachment{
|
|
ID: id,
|
|
ChatID: chatID,
|
|
OwnerID: in.CallerID,
|
|
Filename: in.Filename,
|
|
ContentType: declared,
|
|
SizeBytes: size,
|
|
SHA256: sum,
|
|
ObjectKey: "staging/" + id,
|
|
Status: "queued",
|
|
}
|
|
if err := a.objects.Put(ctx, att.ObjectKey, att.ContentType, spool, size); err != nil {
|
|
// Объект мог успеть сохраниться. Удалять его здесь бессмысленно: при недоступном S3 удаление
|
|
// тоже не пройдёт, а клиент лишние секунды ждал бы ответа. Его уберёт очиститель.
|
|
a.logger.Warn("attachment object put failed", slog.Any("err", err))
|
|
return domain.Attachment{}, err
|
|
}
|
|
saved, err := a.repo.CreateAttachment(ctx, att)
|
|
if err != nil {
|
|
a.compensate(ctx, att)
|
|
return domain.Attachment{}, err
|
|
}
|
|
if os.Getenv("FAULT_AFTER_UPLOAD_COMMIT") == "1" {
|
|
os.Exit(86)
|
|
} // Только для локальной проверки окна COMMIT/publish.
|
|
return saved, nil
|
|
}
|
|
|
|
// checkImage сравнивает заявленный тип с настоящим до декодирования: подмена типа не тратит память.
|
|
func (a *Attachments) checkImage(ctx context.Context, file io.ReadSeeker, declared string) error {
|
|
detected, err := a.checker.Inspect(file)
|
|
if err == nil && detected != declared {
|
|
return domain.ErrUnsupportedMedia
|
|
}
|
|
if err == nil {
|
|
err = a.checker.Decode(ctx, file)
|
|
}
|
|
switch {
|
|
case err == nil:
|
|
return nil
|
|
case errors.Is(err, imagecheck.ErrTooManyPixels):
|
|
return domain.ErrPayloadTooLarge
|
|
case errors.Is(err, imagecheck.ErrUnsupported):
|
|
return domain.ErrUnsupportedMedia
|
|
case errors.Is(err, imagecheck.ErrBusy):
|
|
return domain.ErrRateLimited
|
|
}
|
|
return fmt.Errorf("%w: image check: %v", domain.ErrUnavailable, err)
|
|
}
|
|
|
|
// compensate убирает объект, для которого метаданные не сохранились. Контекст отвязан от запроса:
|
|
// клиент мог уже отключиться. Удалять можно, только убедившись, что строки нет: ошибка INSERT не
|
|
// доказывает отсутствие записи (COMMIT мог пройти, а ответ потеряться), и удаление оставило бы
|
|
// подтверждённую строку без файла. Если проверить нельзя, объект остаётся очистителю: он удаляет
|
|
// только объекты без строки и только после grace period (cmd/janitor).
|
|
func (a *Attachments) compensate(ctx context.Context, att domain.Attachment) {
|
|
ctx, cancel := context.WithTimeout(context.WithoutCancel(ctx), compensationTimeout)
|
|
defer cancel()
|
|
exists, err := a.repo.AttachmentExists(ctx, att.ID)
|
|
if err != nil {
|
|
a.logger.Warn("orphan check failed, object is left to the janitor", slog.String("object_key", att.ObjectKey), slog.Any("err", err))
|
|
return
|
|
}
|
|
if exists {
|
|
a.logger.Warn("metadata write reported an error but the row exists, object is kept", slog.String("attachment_id", att.ID))
|
|
return
|
|
}
|
|
if err := a.objects.Delete(ctx, att.ObjectKey); err != nil {
|
|
a.logger.Warn("compensating delete failed, object is left to the janitor", slog.String("object_key", att.ObjectKey), slog.Any("err", err))
|
|
}
|
|
}
|
|
|
|
// spoolBody пишет тело во временный файл и считает SHA-256 на лету. Файл удаляется из каталога сразу
|
|
// после создания: данные живут, пока он открыт, поэтому при любом завершении, даже kill -9, на диске
|
|
// ничего не остаётся и отдельная уборка не нужна. Это не хранилище: 201 вернётся только после S3.
|
|
func (a *Attachments) spoolBody(body io.Reader) (*os.File, int64, string, error) {
|
|
file, err := os.CreateTemp("", "upload-*")
|
|
if err != nil {
|
|
return nil, 0, "", fmt.Errorf("%w: spool: %v", domain.ErrUnavailable, err)
|
|
}
|
|
if err := os.Remove(file.Name()); err != nil {
|
|
file.Close()
|
|
return nil, 0, "", fmt.Errorf("%w: spool: %v", domain.ErrUnavailable, err)
|
|
}
|
|
|
|
hash := sha256.New()
|
|
source := &errorTrackingReader{r: body}
|
|
// LimitReader на байт больше лимита: так отличается файл ровно на границе от файла больше неё.
|
|
n, err := io.Copy(io.MultiWriter(file, hash), io.LimitReader(source, a.limits.MaxUploadBytes+1))
|
|
switch {
|
|
case source.err != nil:
|
|
file.Close()
|
|
// Клиент оборвал передачу или не уложился в таймаут. Отвечать чаще всего уже некому.
|
|
return nil, 0, "", &validate.Error{Field: "body", Reason: "cannot read body"}
|
|
case err != nil:
|
|
file.Close()
|
|
return nil, 0, "", fmt.Errorf("%w: spool: %v", domain.ErrUnavailable, err)
|
|
case n > a.limits.MaxUploadBytes:
|
|
file.Close()
|
|
return nil, 0, "", domain.ErrPayloadTooLarge
|
|
}
|
|
return file, n, hex.EncodeToString(hash.Sum(nil)), nil
|
|
}
|
|
|
|
// errorTrackingReader отделяет ошибку чтения от клиента (400) от ошибки записи на диск (503).
|
|
type errorTrackingReader struct {
|
|
r io.Reader
|
|
err error
|
|
}
|
|
|
|
func (e *errorTrackingReader) Read(p []byte) (int, error) {
|
|
n, err := e.r.Read(p)
|
|
if err != nil && !errors.Is(err, io.EOF) {
|
|
e.err = err
|
|
}
|
|
return n, err
|
|
}
|
|
|
|
func parseImageType(header string) (string, error) {
|
|
mediaType, _, err := mime.ParseMediaType(header)
|
|
if err != nil {
|
|
return "", domain.ErrUnsupportedMedia
|
|
}
|
|
switch mediaType {
|
|
case domain.ContentTypePNG, domain.ContentTypeJPEG:
|
|
return mediaType, nil
|
|
}
|
|
return "", domain.ErrUnsupportedMedia
|
|
}
|
|
|
|
func (a *Attachments) Get(ctx context.Context, callerID, attachmentID string) (domain.Attachment, error) {
|
|
id, err := validate.CanonicalUUID("attachment_id", attachmentID)
|
|
if err != nil {
|
|
return domain.Attachment{}, err
|
|
}
|
|
return a.repo.AttachmentForMember(ctx, callerID, id)
|
|
}
|
|
|
|
func (a *Attachments) Content(ctx context.Context, callerID, attachmentID, variant string) (domain.Attachment, io.ReadCloser, error) {
|
|
if err := validateVariantName(variant); err != nil {
|
|
return domain.Attachment{}, nil, err
|
|
}
|
|
att, err := a.Get(ctx, callerID, attachmentID)
|
|
if err != nil {
|
|
return domain.Attachment{}, nil, err
|
|
}
|
|
if att.Status != domain.StatusReady {
|
|
return domain.Attachment{}, nil, domain.ErrConflict
|
|
}
|
|
if variant != VariantOriginal {
|
|
found := false
|
|
for _, v := range att.Variants {
|
|
if v.Name == variant {
|
|
att.ObjectKey = variant + "s/" + att.ID
|
|
att.ContentType, att.SizeBytes, att.SHA256 = v.ContentType, v.SizeBytes, v.SHA256
|
|
found = true
|
|
break
|
|
}
|
|
}
|
|
if !found {
|
|
return domain.Attachment{}, nil, domain.ErrNotFound
|
|
}
|
|
}
|
|
body, size, err := a.objects.Get(ctx, att.ObjectKey)
|
|
if err != nil {
|
|
if errors.Is(err, objectstore.ErrNotFound) {
|
|
return domain.Attachment{}, nil, fmt.Errorf("attachment %s: object missing in bucket", att.ID)
|
|
}
|
|
a.logger.Warn("attachment object get failed", slog.Any("err", err))
|
|
return domain.Attachment{}, nil, err
|
|
}
|
|
if size != att.SizeBytes {
|
|
body.Close()
|
|
return domain.Attachment{}, nil, fmt.Errorf("attachment %s: object size %d differs from metadata %d", att.ID, size, att.SizeBytes)
|
|
}
|
|
return att, body, nil
|
|
}
|
|
|
|
func validateVariantName(variant string) error {
|
|
switch variant {
|
|
case VariantOriginal, "thumbnail", "crop", "optimized":
|
|
return nil
|
|
}
|
|
return &validate.Error{Field: "variant", Reason: "unknown variant"}
|
|
}
|