Files
mtusi2026lab5-fork/cmd/outbox/main.go
2026-11-16 14:41:07 +03:00

161 lines
4.2 KiB
Go

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