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) } } } }