forked from mtusi2026/mtusi2026lab5
289 lines
6.8 KiB
Go
289 lines
6.8 KiB
Go
package service
|
|
|
|
import (
|
|
"context"
|
|
"crypto/sha256"
|
|
"encoding/hex"
|
|
"errors"
|
|
"image"
|
|
_ "image/jpeg"
|
|
_ "image/png"
|
|
"io"
|
|
"net"
|
|
"net/http"
|
|
"os"
|
|
|
|
"github.com/google/uuid"
|
|
|
|
"mtusi2026-messenger/internal/db"
|
|
"mtusi2026-messenger/internal/model"
|
|
"mtusi2026-messenger/internal/postgres"
|
|
s3store "mtusi2026-messenger/internal/s3"
|
|
)
|
|
|
|
var (
|
|
ErrAttachmentNotFound = errors.New("attachment not found")
|
|
ErrAttachmentNotReady = errors.New("attachment not ready")
|
|
ErrInvalidImage = errors.New("invalid image")
|
|
ErrInvalidSize = errors.New("invalid size")
|
|
ErrUploadReadTimeout = errors.New("upload body read timed out")
|
|
)
|
|
|
|
type attachmentQueries interface {
|
|
CreateAttachment(ctx context.Context, arg db.CreateAttachmentParams) (db.Attachment, error)
|
|
GetAttachmentByID(ctx context.Context, id uuid.UUID) (db.Attachment, error)
|
|
IsChatMember(ctx context.Context, arg db.IsChatMemberParams) (bool, error)
|
|
MarkAttachmentReady(ctx context.Context, id uuid.UUID) (db.Attachment, error)
|
|
}
|
|
|
|
type AttachmentService struct {
|
|
q attachmentQueries
|
|
s3 *s3store.Client
|
|
maxBytes int
|
|
maxPixels int
|
|
decodeSlot chan struct{}
|
|
}
|
|
|
|
func NewAttachmentService(
|
|
q attachmentQueries,
|
|
s3 *s3store.Client,
|
|
maxBytes, maxPixels int,
|
|
) *AttachmentService {
|
|
return &AttachmentService{
|
|
q: q,
|
|
s3: s3,
|
|
maxBytes: maxBytes,
|
|
maxPixels: maxPixels,
|
|
decodeSlot: make(chan struct{}, 1),
|
|
}
|
|
}
|
|
|
|
func (s *AttachmentService) Upload(
|
|
ctx context.Context,
|
|
userID, chatID uuid.UUID,
|
|
filename string,
|
|
body io.Reader,
|
|
contentType string,
|
|
) (model.Attachment, error) {
|
|
if err := s.ensureMember(ctx, userID, chatID); err != nil {
|
|
return model.Attachment{}, err
|
|
}
|
|
|
|
tmp, err := os.CreateTemp("", "upload-*.tmp")
|
|
if err != nil {
|
|
return model.Attachment{}, err
|
|
}
|
|
defer func() {
|
|
_ = tmp.Close()
|
|
_ = os.Remove(tmp.Name())
|
|
}()
|
|
|
|
hasher := sha256.New()
|
|
size, err := io.Copy(io.MultiWriter(tmp, hasher), body)
|
|
if err != nil {
|
|
var maxBytesErr *http.MaxBytesError
|
|
if errors.As(err, &maxBytesErr) {
|
|
return model.Attachment{}, ErrInvalidSize
|
|
}
|
|
var networkErr net.Error
|
|
if errors.As(err, &networkErr) && networkErr.Timeout() {
|
|
return model.Attachment{}, ErrUploadReadTimeout
|
|
}
|
|
return model.Attachment{}, err
|
|
}
|
|
if size > int64(s.maxBytes) {
|
|
return model.Attachment{}, ErrInvalidSize
|
|
}
|
|
|
|
if _, err := tmp.Seek(0, io.SeekStart); err != nil {
|
|
return model.Attachment{}, err
|
|
}
|
|
detectedType, width, height, err := s.checkImage(ctx, tmp, contentType)
|
|
if err != nil {
|
|
return model.Attachment{}, err
|
|
}
|
|
|
|
id, err := uuid.NewV7()
|
|
if err != nil {
|
|
return model.Attachment{}, err
|
|
}
|
|
|
|
hash := hex.EncodeToString(hasher.Sum(nil))
|
|
key := "chats/" + chatID.String() + "/attachments/" + id.String()
|
|
|
|
if _, err := tmp.Seek(0, io.SeekStart); err != nil {
|
|
return model.Attachment{}, err
|
|
}
|
|
|
|
_, err = s.q.CreateAttachment(ctx, db.CreateAttachmentParams{
|
|
ID: id,
|
|
ChatID: chatID,
|
|
OwnerID: userID,
|
|
S3Key: key,
|
|
Filename: filename,
|
|
ContentType: db.AttachmentContentType(detectedType),
|
|
SizeBytes: int(size),
|
|
Sha256: hash,
|
|
Width: width,
|
|
Height: height,
|
|
ErrorCode: "",
|
|
})
|
|
if postgres.IsNotFound(err) {
|
|
return model.Attachment{}, ErrAttachmentNotFound
|
|
}
|
|
if err != nil {
|
|
return model.Attachment{}, err
|
|
}
|
|
|
|
if err := s.s3.Put(ctx, key, tmp, size, string(detectedType)); err != nil {
|
|
return model.Attachment{}, err
|
|
}
|
|
|
|
row, err := s.q.MarkAttachmentReady(ctx, id)
|
|
if err != nil {
|
|
return model.Attachment{}, err
|
|
}
|
|
|
|
return model.Attachment{
|
|
ID: row.ID,
|
|
ChatID: row.ChatID,
|
|
OwnerID: row.OwnerID,
|
|
Filename: row.Filename,
|
|
ContentType: model.ContentType(row.ContentType),
|
|
SizeBytes: row.SizeBytes,
|
|
Sha256: row.Sha256,
|
|
Status: model.AttachmentStatus(row.Status),
|
|
ErrorCode: row.ErrorCode,
|
|
CreatedAt: row.CreatedAt,
|
|
UpdatedAt: row.UpdatedAt,
|
|
}, nil
|
|
}
|
|
|
|
func (s *AttachmentService) Get(
|
|
ctx context.Context,
|
|
userID, attachmentID uuid.UUID,
|
|
) (model.Attachment, error) {
|
|
row, err := s.q.GetAttachmentByID(ctx, attachmentID)
|
|
if postgres.IsNotFound(err) {
|
|
return model.Attachment{}, ErrAttachmentNotFound
|
|
}
|
|
if err != nil {
|
|
return model.Attachment{}, err
|
|
}
|
|
|
|
if err := s.ensureMember(ctx, userID, row.ChatID); err != nil {
|
|
return model.Attachment{}, err
|
|
}
|
|
|
|
return model.Attachment{
|
|
ID: row.ID,
|
|
ChatID: row.ChatID,
|
|
OwnerID: row.OwnerID,
|
|
Filename: row.Filename,
|
|
ContentType: model.ContentType(row.ContentType),
|
|
SizeBytes: row.SizeBytes,
|
|
Sha256: row.Sha256,
|
|
Status: model.AttachmentStatus(row.Status),
|
|
ErrorCode: row.ErrorCode,
|
|
CreatedAt: row.CreatedAt,
|
|
UpdatedAt: row.UpdatedAt,
|
|
}, nil
|
|
}
|
|
|
|
func (s *AttachmentService) GetContent(
|
|
ctx context.Context,
|
|
userID, attachmentID uuid.UUID,
|
|
) ([]byte, model.ContentType, error) {
|
|
row, err := s.q.GetAttachmentByID(ctx, attachmentID)
|
|
if postgres.IsNotFound(err) {
|
|
return nil, "", ErrAttachmentNotFound
|
|
}
|
|
if err != nil {
|
|
return nil, "", err
|
|
}
|
|
|
|
if err := s.ensureMember(ctx, userID, row.ChatID); err != nil {
|
|
return nil, "", err
|
|
}
|
|
|
|
if model.AttachmentStatus(row.Status) != model.AttachmentStatusReady {
|
|
return nil, "", ErrAttachmentNotReady
|
|
}
|
|
|
|
out, err := s.s3.Get(ctx, row.S3Key)
|
|
if err != nil {
|
|
return nil, "", err
|
|
}
|
|
defer out.Body.Close()
|
|
|
|
data, err := io.ReadAll(out.Body)
|
|
if err != nil {
|
|
return nil, "", err
|
|
}
|
|
|
|
return data, model.ContentType(row.ContentType), nil
|
|
}
|
|
|
|
func (s *AttachmentService) checkImage(ctx context.Context, r io.ReadSeeker, contentType string) (model.ContentType, int, int, error) {
|
|
cfg, format, err := image.DecodeConfig(r)
|
|
if err != nil {
|
|
return "", 0, 0, ErrInvalidImage
|
|
}
|
|
|
|
if cfg.Width <= 0 || cfg.Height <= 0 {
|
|
return "", 0, 0, ErrInvalidImage
|
|
}
|
|
if cfg.Width > s.maxPixels/cfg.Height {
|
|
return "", 0, 0, ErrInvalidSize
|
|
}
|
|
|
|
var detectedType model.ContentType
|
|
switch format {
|
|
case "png":
|
|
if contentType != string(model.ContentTypePNG) {
|
|
return "", 0, 0, ErrInvalidImage
|
|
}
|
|
detectedType = model.ContentTypePNG
|
|
case "jpeg":
|
|
if contentType != string(model.ContentTypeJPEG) {
|
|
return "", 0, 0, ErrInvalidImage
|
|
}
|
|
detectedType = model.ContentTypeJPEG
|
|
default:
|
|
return "", 0, 0, ErrInvalidImage
|
|
}
|
|
|
|
select {
|
|
case s.decodeSlot <- struct{}{}:
|
|
defer func() { <-s.decodeSlot }()
|
|
case <-ctx.Done():
|
|
return "", 0, 0, ctx.Err()
|
|
}
|
|
if err := ctx.Err(); err != nil {
|
|
return "", 0, 0, err
|
|
}
|
|
if _, err := r.Seek(0, io.SeekStart); err != nil {
|
|
return "", 0, 0, err
|
|
}
|
|
if _, _, err := image.Decode(r); err != nil {
|
|
return "", 0, 0, ErrInvalidImage
|
|
}
|
|
|
|
return detectedType, cfg.Width, cfg.Height, nil
|
|
}
|
|
|
|
func (s *AttachmentService) ensureMember(ctx context.Context, userID, chatID uuid.UUID) error {
|
|
member, err := s.q.IsChatMember(ctx, db.IsChatMemberParams{
|
|
ChatID: chatID,
|
|
UserID: userID,
|
|
})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if !member {
|
|
return ErrAttachmentNotFound
|
|
}
|
|
|
|
return nil
|
|
}
|