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