forked from mtusi2026/mtusi2026lab5
172 lines
3.1 KiB
Go
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
|
|
}
|
|
}
|