Files

137 lines
4.2 KiB
Go

package postgres
import (
"context"
"fmt"
"time"
"github.com/google/uuid"
"github.com/jackc/pgx/v5"
"gitea.privcloud.tech/dizi/mtusi2026lab7/internal/model"
)
func (s *Store) ClaimOutboxEvents(
ctx context.Context,
limit int,
leaseDuration time.Duration,
) ([]model.OutboxEvent, error) {
if limit < 1 || limit > 1000 || leaseDuration <= 0 {
return nil, model.ErrInvalidInput
}
claimToken := uuid.NewString()
query := `
WITH candidates AS (
SELECT id
FROM outbox_events
WHERE published_at IS NULL
AND available_at <= clock_timestamp()
AND (claim_until IS NULL OR claim_until <= clock_timestamp())
ORDER BY available_at, id
LIMIT $1
FOR UPDATE SKIP LOCKED
)
UPDATE outbox_events event
SET claim_token = $2,
claim_until = clock_timestamp() + $3 * INTERVAL '1 millisecond',
publish_tries = event.publish_tries + 1
FROM candidates
WHERE event.id = candidates.id
RETURNING event.id, event.topic, event.partition_key, event.payload, event.job_id,
event.attempt, event.available_at, event.publish_tries, event.claim_token,
event.claim_until, event.last_error_code, event.created_at`
rows, err := s.pool.Query(ctx, query, limit, claimToken, leaseDuration.Milliseconds())
if err != nil {
return nil, fmt.Errorf("claim outbox events: %w", err)
}
defer rows.Close()
events, err := pgx.CollectRows(rows, pgx.RowToFunc[model.OutboxEvent](func(row pgx.CollectableRow) (model.OutboxEvent, error) {
var event model.OutboxEvent
err := row.Scan(
&event.ID, &event.Topic, &event.PartitionKey, &event.Payload, &event.JobID,
&event.Attempt, &event.AvailableAt, &event.PublishTries, &event.LeaseToken,
&event.LeaseUntil, &event.LastErrorCode, &event.CreatedAt,
)
return event, err
}))
if err != nil {
return nil, fmt.Errorf("scan claimed outbox events: %w", err)
}
return events, nil
}
func (s *Store) MarkOutboxPublished(ctx context.Context, eventID, leaseToken string) (bool, error) {
const query = `
UPDATE outbox_events
SET published_at = clock_timestamp(), claim_token = NULL, claim_until = NULL,
last_error_code = NULL
WHERE id = $1 AND claim_token = $2 AND published_at IS NULL
AND claim_until > clock_timestamp()`
result, err := s.pool.Exec(ctx, query, eventID, leaseToken)
if err != nil {
return false, fmt.Errorf("mark outbox event published: %w", err)
}
return result.RowsAffected() == 1, nil
}
func (s *Store) ReleaseOutboxEvent(
ctx context.Context,
eventID string,
leaseToken string,
errorCode string,
nextAttemptAt time.Time,
) (bool, error) {
if !validErrorCode(errorCode) || nextAttemptAt.IsZero() {
return false, model.ErrInvalidInput
}
const query = `
UPDATE outbox_events
SET available_at = $3, claim_token = NULL, claim_until = NULL, last_error_code = $4
WHERE id = $1 AND claim_token = $2 AND published_at IS NULL
AND claim_until > clock_timestamp()`
result, err := s.pool.Exec(ctx, query, eventID, leaseToken, nextAttemptAt.UTC(), errorCode)
if err != nil {
return false, fmt.Errorf("release outbox event: %w", err)
}
return result.RowsAffected() == 1, nil
}
func (s *Store) RecoverExpiredOutboxEvents(ctx context.Context, now time.Time) (int, error) {
if now.IsZero() {
now = time.Now().UTC()
}
const query = `
UPDATE outbox_events
SET claim_token = NULL, claim_until = NULL
WHERE published_at IS NULL AND claim_until <= $1`
result, err := s.pool.Exec(ctx, query, now.UTC())
if err != nil {
return 0, fmt.Errorf("recover expired outbox events: %w", err)
}
return int(result.RowsAffected()), nil
}
func (s *Store) DeletePublishedOutboxEvents(ctx context.Context, publishedBefore time.Time, limit int) (int, error) {
if publishedBefore.IsZero() || limit < 1 || limit > 1000 {
return 0, model.ErrInvalidInput
}
const query = `
WITH candidates AS (
SELECT id
FROM outbox_events
WHERE published_at < $1
ORDER BY published_at, id
LIMIT $2
FOR UPDATE SKIP LOCKED
)
DELETE FROM outbox_events event
USING candidates
WHERE event.id = candidates.id`
result, err := s.pool.Exec(ctx, query, publishedBefore.UTC(), limit)
if err != nil {
return 0, fmt.Errorf("delete published outbox events: %w", err)
}
return int(result.RowsAffected()), nil
}