forked from mtusi2026/mtusi2026lab5
161 lines
4.2 KiB
Go
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)
|
|
}
|
|
}
|
|
}
|
|
}
|