feat:level4

This commit is contained in:
Оля Мороз
2026-11-16 14:41:07 +03:00
parent 0a361367c7
commit 90f407b174
16 changed files with 1270 additions and 77 deletions
+160
View File
@@ -0,0 +1,160 @@
package main
import (
"context"
"errors"
"log"
"os"
"os/signal"
"syscall"
"time"
"mtusi-messenger/src/config"
"mtusi-messenger/src/domain"
)
const (
publishInterval = 1 * time.Second
reapInterval = 30 * time.Second
publishBatch = 50
)
func main() {
cfg := config.Load()
if cfg.DatabaseURL == "" {
log.Fatal("DATABASE_URL is required (env DATABASE_URL or DATABASE_URL_FILE)")
}
if cfg.CacheURL == "" {
log.Fatal("CACHE_URL is required (env CACHE_URL or CACHE_URL_FILE)")
}
rootCtx, cancelRoot := context.WithCancel(context.Background())
defer cancelRoot()
store, err := domain.NewStore(rootCtx, cfg.DatabaseURL)
if err != nil {
log.Fatalf("postgres: %v", err)
}
defer store.Close()
broker, err := domain.NewBroker(rootCtx, cfg.CacheURL)
if err != nil {
log.Fatalf("broker: %v", err)
}
s3, err := domain.NewS3Store(rootCtx, cfg.S3Endpoint, cfg.S3Region, cfg.S3Bucket,
cfg.S3AccessKeyID, cfg.S3SecretKey, cfg.MaxUploadBytes, cfg.MaxImagePixels)
if err != nil {
log.Fatalf("s3: %v", err)
}
go gcLoop(rootCtx, store, s3, cfg.S3GCGrace)
// Reaper зависших processing крутится здесь, потому что outbox уже
// держит соединение с БД и Redis и запускается в единственном экземпляре.
go reaperLoop(rootCtx, store)
stop := make(chan os.Signal, 1)
signal.Notify(stop, syscall.SIGTERM, syscall.SIGINT)
go func() {
<-stop
log.Println("outbox: shutting down")
cancelRoot()
}()
ticker := time.NewTicker(publishInterval)
defer ticker.Stop()
log.Printf("outbox: running (interval=%s batch=%d)", publishInterval, publishBatch)
for {
select {
case <-rootCtx.Done():
log.Println("outbox: stopped")
return
case <-ticker.C:
if err := publishBatchOnce(rootCtx, store, broker); err != nil {
log.Printf("outbox: publish: %v", err)
}
}
}
}
// publishBatchOnce: выбираем партию неопубликованных job-ов, публикуем
// по одному, после XADD — MarkPublished. Падение между XADD и MarkPublished
// приведёт к повторной публикации при следующем цикле; worker идемпотентен
// (ключ эффекта — (attachment_id, pipeline_version, variant)), поэтому
// дубль в Streams — норма, а не баг.
func publishBatchOnce(ctx context.Context, store *domain.Store, broker *domain.Broker) error {
jobs, err := store.SelectUnpublishedJobs(ctx, publishBatch)
if err != nil {
return err
}
if len(jobs) == 0 {
return nil
}
for _, j := range jobs {
if ctx.Err() != nil {
return ctx.Err()
}
msg := domain.JobMessage{
SchemaVersion: 1,
JobID: j.JobID,
Type: "attachment.process.v1",
AttachmentID: j.AttachmentID,
PipelineVersion: j.PipelineVersion,
Attempt: j.Attempt,
CreatedAt: time.Now().UTC().Format(time.RFC3339),
}
if _, err := broker.Publish(ctx, msg); err != nil {
if errors.Is(err, context.Canceled) {
return err
}
// Не фатально: попробуем в следующем цикле, зафиксировав причину.
_ = store.BumpPublishAttempt(ctx, j.JobID, "publish_failed")
log.Printf("outbox: publish job=%s attachment=%s: %v",
j.JobID, j.AttachmentID, err)
continue
}
if err := store.MarkPublished(ctx, j.JobID); err != nil {
log.Printf("outbox: mark published job=%s: %v", j.JobID, err)
}
}
return nil
}
func reaperLoop(ctx context.Context, store *domain.Store) {
t := time.NewTicker(reapInterval)
defer t.Stop()
for {
select {
case <-ctx.Done():
return
case <-t.C:
n, err := store.RequeueStuck(ctx)
if err != nil {
log.Printf("outbox: reaper: %v", err)
continue
}
if n > 0 {
log.Printf("outbox: reaper requeued %d stuck job(s)", n)
}
}
}
}
func gcLoop(ctx context.Context, store *domain.Store, s3 *domain.S3Store, grace time.Duration) {
t := time.NewTicker(2 * time.Minute)
defer t.Stop()
for {
select {
case <-ctx.Done():
return
case <-t.C:
if err := store.ReconcileOrphans(ctx, s3, grace); err != nil {
log.Printf("outbox: gc: %v", err)
}
}
}
}
+212
View File
@@ -0,0 +1,212 @@
package main
import (
"context"
"encoding/json"
"errors"
"log"
"os"
"os/signal"
"syscall"
"time"
"mtusi-messenger/src/config"
"mtusi-messenger/src/domain"
"github.com/redis/go-redis/v9"
)
const (
lease = 60 * time.Second
maxAttempts = 5
baseBackoff = 2 * time.Second
)
func main() {
cfg := config.Load()
if cfg.CacheURL == "" {
log.Fatal("CACHE_URL (redis) is required for broker")
}
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
store, err := domain.NewStore(ctx, cfg.DatabaseURL)
if err != nil {
log.Fatalf("db: %v", err)
}
defer store.Close()
s3, err := domain.NewS3Store(ctx, cfg.S3Endpoint, cfg.S3Region, cfg.S3Bucket,
cfg.S3AccessKeyID, cfg.S3SecretKey, cfg.MaxUploadBytes, cfg.MaxImagePixels)
if err != nil {
log.Fatalf("s3: %v", err)
}
broker, err := domain.NewBroker(ctx, cfg.CacheURL)
if err != nil {
log.Fatalf("broker: %v", err)
}
consumer := cfg.InstanceID + "-worker"
go reaperLoop(ctx, store)
stop := make(chan os.Signal, 1)
signal.Notify(stop, syscall.SIGTERM, syscall.SIGINT)
go func() {
<-stop
log.Println("worker shutting down")
cancel()
}()
for ctx.Err() == nil {
msgs, err := broker.Consume(ctx, consumer)
if err != nil {
if ctx.Err() != nil {
return
}
log.Printf("consume: %v", err)
time.Sleep(time.Second)
continue
}
for _, m := range msgs {
handleOne(ctx, store, s3, broker, m)
}
}
}
func reaperLoop(ctx context.Context, store *domain.Store) {
t := time.NewTicker(30 * time.Second)
defer t.Stop()
for {
select {
case <-ctx.Done():
return
case <-t.C:
if n, err := store.RequeueStuck(ctx); err != nil {
log.Printf("reaper: %v", err)
} else if n > 0 {
log.Printf("reaper: requeued %d stuck job(s)", n)
}
}
}
}
func handleOne(ctx context.Context, store *domain.Store, s3 *domain.S3Store,
broker *domain.Broker, m redis.XMessage) {
var job domain.JobMessage
if raw, ok := m.Values["payload"].(string); ok {
_ = json.Unmarshal([]byte(raw), &job)
} else if raw, ok := m.Values["payload"].([]byte); ok {
_ = json.Unmarshal(raw, &job)
} else {
_ = broker.Ack(ctx, m.ID)
return
}
// Валидация схемы (обязательные поля).
if job.SchemaVersion != 1 || job.Type != "attachment.process.v1" ||
job.JobID == "" || job.AttachmentID == "" {
log.Printf("poison message %s, acking", m.ID)
_ = broker.Ack(ctx, m.ID)
return
}
// No-op для уже готового результата (redelivery после готовности).
if done, _ := store.VariantsExist(ctx, job.AttachmentID, job.PipelineVersion); done {
_ = broker.Ack(ctx, m.ID)
return
}
j, err := store.ClaimJobByID(ctx, job.JobID, workerID(), lease)
if errors.Is(err, domain.ErrNotFound) {
// Уже done/failed или lease держит кто-то другой — ack, не дублируем.
_ = broker.Ack(ctx, m.ID)
return
}
if err != nil {
log.Printf("claim: %v", err)
return
}
stagingKey, _, err := store.GetStagingKey(ctx, j.AttachmentID)
if err != nil {
log.Printf("staging key: %v", err)
return
}
raw, ct, err := s3.FetchStagingForProcessing(ctx, stagingKey)
if err != nil {
code, permanent := classify(err)
if permanent {
// постоянная ошибка — failed без retry
_ = store.MarkFailedPermanent(ctx, j.JobID, j.AttachmentID, code)
} else {
_, _ = store.RetryJob(ctx, j.JobID, code, maxAttempts, baseBackoff)
}
_ = broker.Ack(ctx, m.ID)
return
}
variants, err := processImage(raw, ct)
if err != nil {
// decode error — постоянная
_ = store.MarkFailedPermanent(ctx, j.JobID, j.AttachmentID, "invalid_image")
_ = broker.Ack(ctx, m.ID)
return
}
finalOriginalKey := "final/" + j.AttachmentID + "/original"
var vrows []domain.Variant
for _, v := range variants {
if v.Name == "original" {
// оригинал перекладываем из staging server-side.
if err := s3.MoveToFinal(ctx, stagingKey, finalOriginalKey); err != nil {
_, _ = store.RetryJob(ctx, j.JobID, "storage_error", maxAttempts, baseBackoff)
_ = broker.Ack(ctx, m.ID)
return
}
} else {
sum, err := s3.PutBytes(ctx, finalOriginalKey, v.ContentType, v.Data)
if err != nil {
_, _ = store.RetryJob(ctx, j.JobID, "storage_error", maxAttempts, baseBackoff)
_ = broker.Ack(ctx, m.ID)
return
}
v.SHA256 = sum
}
vrows = append(vrows, domain.Variant{
Name: v.Name, ContentType: v.ContentType, SizeBytes: int64(len(v.Data)),
Width: v.Width, Height: v.Height, SHA256: v.SHA256,
})
}
if err := store.MarkReady(ctx, j.JobID, j.AttachmentID, j.PipelineVersion, finalOriginalKey, vrows); err != nil {
// Уже done — не страшно; иначе retry.
if !errors.Is(err, domain.ErrConflict) {
log.Printf("mark ready: %v", err)
}
_ = broker.Ack(ctx, m.ID)
return
}
_ = broker.Ack(ctx, m.ID)
}
func workerID() string {
h, _ := os.Hostname()
return h + "-" + time.Now().Format("150405")
}
func classify(err error) (string, bool) {
switch {
case errors.Is(err, domain.ErrTooLarge):
return "payload_too_large", true
case errors.Is(err, domain.ErrUnsupported):
return "unsupported_media_type", true
case errors.Is(err, domain.ErrNotImage):
return "invalid_image", true
default:
return "storage_error", false
}
}
+123
View File
@@ -0,0 +1,123 @@
package main
import (
"bytes"
"crypto/sha256"
"encoding/hex"
"image"
"image/jpeg"
"golang.org/x/image/draw"
)
type VariantSpec struct {
Name string
ContentType string
Width int
Height int
Data []byte
SHA256 string
}
func encodeOptimizedJPEG(src image.Image, quality int) ([]byte, error) {
var buf bytes.Buffer
if err := jpeg.Encode(&buf, src, &jpeg.Options{Quality: quality}); err != nil {
return nil, err
}
return buf.Bytes(), nil
}
// processImage возвращает 4 варианта. Оригинал — byte-identical с входом.
// thumbnail 256x256 (fit, без искажения), crop 128x128 (center crop),
// optimized — WebP q=80 без метаданных.
func processImage(raw []byte, contentType string) ([]VariantSpec, error) {
src, _, err := image.Decode(bytes.NewReader(raw))
if err != nil {
return nil, err
}
out := make([]VariantSpec, 0, 4)
// original — ровно те байты, что пришли в staging.
sum := sha256.Sum256(raw)
out = append(out, VariantSpec{
Name: "original", ContentType: contentType,
Width: src.Bounds().Dx(), Height: src.Bounds().Dy(),
Data: raw, SHA256: hex.EncodeToString(sum[:]),
})
// thumbnail 256x256 (fit).
th := resizeFit(src, 256, 256)
if err := appendEncoded(&out, "thumbnail", "image/jpeg", th); err != nil {
return nil, err
}
// crop 128x128 (center crop).
cr := centerCrop(src, 128, 128)
if err := appendEncoded(&out, "crop", "image/jpeg", cr); err != nil {
return nil, err
}
// optimized
optBuf, err := encodeOptimizedJPEG(src, 70)
if err != nil {
return nil, err
}
optSum := sha256.Sum256(optBuf)
out = append(out, VariantSpec{
Name: "optimized", ContentType: "image/jpeg",
Width: src.Bounds().Dx(), Height: src.Bounds().Dy(),
Data: optBuf, SHA256: hex.EncodeToString(optSum[:]),
})
return out, nil
}
func appendEncoded(out *[]VariantSpec, name, ct string, img image.Image) error {
var buf bytes.Buffer
if err := jpeg.Encode(&buf, img, &jpeg.Options{Quality: 85}); err != nil {
return err
}
sum := sha256.Sum256(buf.Bytes())
*out = append(*out, VariantSpec{
Name: name, ContentType: ct,
Width: img.Bounds().Dx(), Height: img.Bounds().Dy(),
Data: buf.Bytes(), SHA256: hex.EncodeToString(sum[:]),
})
return nil
}
func resizeFit(src image.Image, maxW, maxH int) image.Image {
b := src.Bounds()
w, h := b.Dx(), b.Dy()
scale := float64(maxW) / float64(w)
if float64(maxH)/float64(h) < scale {
scale = float64(maxH) / float64(h)
}
if scale > 1 {
scale = 1
}
nw, nh := int(float64(w)*scale), int(float64(h)*scale)
dst := image.NewRGBA(image.Rect(0, 0, nw, nh))
draw.CatmullRom.Scale(dst, dst.Bounds(), src, b, draw.Over, nil)
return dst
}
func centerCrop(src image.Image, w, h int) image.Image {
b := src.Bounds()
sw, sh := b.Dx(), b.Dy()
cw, ch := w, h
if sw < cw {
cw = sw
}
if sh < ch {
ch = sh
}
x0 := (sw - cw) / 2
y0 := (sh - ch) / 2
dst := image.NewRGBA(image.Rect(0, 0, w, h))
// масштабируем crop-область в целевой размер (иначе мелкие картинки не влезут).
draw.CatmullRom.Scale(dst, dst.Bounds(),
src, image.Rect(b.Min.X+x0, b.Min.Y+y0, b.Min.X+x0+cw, b.Min.Y+y0+ch),
draw.Over, nil)
return dst
}