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 { key := "final/" + j.AttachmentID + "/" + v.Name sum, err := s3.PutBytes(ctx, key, 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 } }