Files
mtusi2026lab5/internal/worker/worker.go
T

172 lines
3.1 KiB
Go

package worker
import (
"context"
"encoding/json"
"log/slog"
"sync"
"time"
"github.com/google/uuid"
"github.com/jackc/pgx/v5/pgxpool"
amqp "github.com/rabbitmq/amqp091-go"
"mtusi2026-messenger/internal/config"
"mtusi2026-messenger/internal/db"
"mtusi2026-messenger/internal/model"
"mtusi2026-messenger/internal/rabbitmq"
s3store "mtusi2026-messenger/internal/s3"
)
type Worker struct {
pool *pgxpool.Pool
q *db.Queries
s3 *s3store.Client
brokerURL string
cfg config.WorkerConfig
maxBytes, maxPixels int
decodeSlot chan struct{}
log *slog.Logger
}
func New(
pool *pgxpool.Pool,
s3 *s3store.Client,
brokerURL string,
cfg config.WorkerConfig,
maxBytes, maxPixels int,
log *slog.Logger,
) *Worker {
return &Worker{
pool: pool,
q: db.New(pool),
s3: s3,
brokerURL: brokerURL,
cfg: cfg,
maxBytes: maxBytes,
maxPixels: maxPixels,
decodeSlot: make(chan struct{}, 1),
log: log,
}
}
func (w *Worker) Run(ctx context.Context) {
var wg sync.WaitGroup
wg.Add(1)
go func() {
defer wg.Done()
w.recoverLoop(ctx)
}()
for range w.cfg.Concurrency {
wg.Add(1)
go func() {
defer wg.Done()
w.consumeLoop(ctx)
}()
}
wg.Wait()
}
func (w *Worker) consumeLoop(ctx context.Context) {
for ctx.Err() == nil {
client, err := rabbitmq.New(w.brokerURL)
if err == nil {
err = w.consume(ctx, client)
_ = client.Close()
}
if ctx.Err() != nil {
return
}
w.log.Warn("worker consumer reconnect", "error", err)
if !wait(ctx, 2*time.Second) {
return
}
}
}
func (w *Worker) consume(ctx context.Context, client *rabbitmq.Client) error {
stop := context.AfterFunc(ctx, func() {
_ = client.Close()
})
defer stop()
deliveries, err := client.Consume(ctx, 1)
if err != nil {
return err
}
for {
select {
case <-ctx.Done():
return ctx.Err()
case delivery, ok := <-deliveries:
if !ok {
return amqp.ErrClosed
}
var job model.AttachmentJob
if json.Unmarshal(delivery.Body, &job) != nil ||
job.SchemaVersion != 1 ||
job.Type != "attachment.process.v1" ||
job.JobID == uuid.Nil ||
job.AttachmentID == uuid.Nil ||
job.PipelineVersion != 1 ||
job.Attempt < 1 ||
job.CreatedAt.IsZero() {
if err := delivery.Reject(false); err != nil {
return err
}
w.log.Warn("invalid attachment job rejected")
continue
}
err := w.handle(ctx, job)
if err == nil {
if err := delivery.Ack(false); err != nil {
return err
}
} else {
if ctx.Err() != nil {
return ctx.Err()
}
w.log.Warn(
"attachment job not acknowledged",
"job_id",
job.JobID,
"attempt",
job.Attempt,
"error",
err,
)
if !wait(ctx, time.Second) {
return ctx.Err()
}
if err := delivery.Nack(false, true); err != nil {
return err
}
}
}
}
}
func wait(ctx context.Context, duration time.Duration) bool {
timer := time.NewTimer(duration)
defer timer.Stop()
select {
case <-ctx.Done():
return false
case <-timer.C:
return true
}
}