Files
mtusi2026lab6/backend/internal/storage/postgres/attachments.go
T

353 lines
10 KiB
Go

package postgres
import (
"context"
"log"
"time"
"github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/pgxpool"
"high-loud-apps-labs/internal/domain"
)
type AttachmentRepo struct {
pool *pgxpool.Pool
}
func NewAttachmentRepo(pool *pgxpool.Pool) *AttachmentRepo {
return &AttachmentRepo{pool: pool}
}
func (r *AttachmentRepo) Create(ctx context.Context, a *domain.Attachment) error {
const q = `
INSERT INTO attachments
(id, chat_id, owner_id, filename, content_type, size_bytes, sha256,
object_key, status, error_code, created_at, updated_at)
VALUES ($1::uuid, $2::uuid, $3::uuid, $4, $5, $6, $7, $8, $9, NULL, $10, $10)`
_, err := r.pool.Exec(ctx, q,
a.ID, a.ChatID, a.OwnerID, a.Filename, a.ContentType, a.SizeBytes,
a.SHA256, a.ObjectKey, string(a.Status), a.CreatedAt,
)
if err != nil {
if uniqueViolation(err) {
return &domain.AlreadyExistsError{
Entity: "attachment",
Field: "object_key",
Value: a.ObjectKey,
}
}
if foreignKeyViolation(err) {
return &domain.NotFoundError{Entity: "chat", ID: a.ChatID}
}
if checkViolation(err) {
return &domain.ValidationError{
Field: "attachment",
Message: "нарушено ограничение целостности",
}
}
return mapError(err)
}
return nil
}
func (r *AttachmentRepo) CreateInTx(ctx context.Context, tx domain.Tx, a *domain.Attachment) error {
const q = `
INSERT INTO attachments
(id, chat_id, owner_id, filename, content_type, size_bytes, sha256,
object_key, status, error_code,
attempts, pipeline_version, staging_key,
created_at, updated_at)
VALUES ($1::uuid, $2::uuid, $3::uuid, $4, $5, $6, $7, $8, $9, NULL,
0, $10, $11, $12, $12)
`
return tx.Exec(ctx, q,
a.ID, a.ChatID, a.OwnerID, a.Filename, a.ContentType, a.SizeBytes,
a.SHA256, a.ObjectKey, string(a.Status),
a.PipelineVersion, a.StagingKey, a.CreatedAt,
)
}
func (r *AttachmentRepo) GetByID(ctx context.Context, id string) (*domain.Attachment, error) {
const q = `
SELECT id, chat_id, owner_id, filename, content_type, size_bytes, sha256,
object_key, status, error_code, created_at, updated_at,
attempts, next_attempt_at, locked_until, pipeline_version, staging_key
FROM attachments
WHERE id = $1::uuid
`
a := &domain.Attachment{}
var status string
err := r.pool.QueryRow(ctx, q, id).
Scan(&a.ID, &a.ChatID, &a.OwnerID, &a.Filename, &a.ContentType,
&a.SizeBytes, &a.SHA256, &a.ObjectKey, &status, &a.ErrorCode,
&a.CreatedAt, &a.UpdatedAt,
&a.Attempts, &a.NextAttemptAt, &a.LockedUntil, &a.PipelineVersion, &a.StagingKey)
if err != nil {
return nil, notFound(err, "attachment", id)
}
a.Status = domain.AttachmentStatus(status)
rows, err := r.pool.Query(ctx, `
SELECT name, object_key, content_type, size_bytes, width, height, sha256, created_at
FROM attachment_variants
WHERE attachment_id = $1::uuid
ORDER BY name
`, id)
if err != nil {
log.Printf("GetByID: ошибка запроса variants: %v", err)
} else {
defer rows.Close()
for rows.Next() {
var v domain.AttachmentVariant
v.AttachmentID = id
if err := rows.Scan(&v.Name, &v.ObjectKey, &v.ContentType, &v.SizeBytes, &v.Width, &v.Height, &v.SHA256, &v.CreatedAt); err != nil {
log.Printf("GetByID: ошибка Scan variant: %v", err)
} else {
a.Variants = append(a.Variants, v)
}
}
}
return a, nil
}
func (r *AttachmentRepo) MarkReady(ctx context.Context, id string) error {
const q = `
UPDATE attachments
SET status = 'ready', updated_at = now()
WHERE id = $1::uuid AND status = 'pending'
`
tag, err := r.pool.Exec(ctx, q, id)
if err != nil {
return mapError(err)
}
if tag.RowsAffected() > 0 {
return nil
}
var status string
err = r.pool.QueryRow(ctx, `SELECT status FROM attachments WHERE id = $1::uuid`, id).
Scan(&status)
if err != nil {
return notFound(err, "attachment", id)
}
switch domain.AttachmentStatus(status) {
case domain.AttachmentStatusReady:
return nil
case domain.AttachmentStatusFailed:
return &domain.ConflictError{Reason: "нельзя перевести failed-вложение в ready"}
default:
return &domain.ConflictError{Reason: "некорректное состояние вложения"}
}
}
func (r *AttachmentRepo) MarkFailed(ctx context.Context, id, errorCode string) error {
if errorCode == "" {
return &domain.ValidationError{Field: "error_code", Message: "не может быть пустым"}
}
const q = `
UPDATE attachments
SET status = 'failed', error_code = $2, updated_at = now()
WHERE id = $1::uuid AND status = 'pending'
`
tag, err := r.pool.Exec(ctx, q, id, errorCode)
if err != nil {
return mapError(err)
}
if tag.RowsAffected() > 0 {
return nil
}
var status string
err = r.pool.QueryRow(ctx, `SELECT status FROM attachments WHERE id = $1::uuid`, id).
Scan(&status)
if err != nil {
return notFound(err, "attachment", id)
}
switch domain.AttachmentStatus(status) {
case domain.AttachmentStatusFailed, domain.AttachmentStatusReady:
return nil
default:
return &domain.ConflictError{Reason: "некорректное состояние вложения"}
}
}
func (r *AttachmentRepo) ExistingKeys(ctx context.Context, keys []string) ([]string, error) {
if len(keys) == 0 {
return []string{}, nil
}
const q = `SELECT object_key FROM attachments WHERE object_key = ANY($1::text[])`
rows, err := r.pool.Query(ctx, q, keys)
if err != nil {
return nil, mapError(err)
}
defer rows.Close()
out := make([]string, 0, len(keys))
for rows.Next() {
var k string
if err := rows.Scan(&k); err != nil {
return nil, mapError(err)
}
out = append(out, k)
}
return out, mapError(rows.Err())
}
func (r *AttachmentRepo) ClaimForProcessing(ctx context.Context, id string, version int, lease time.Duration) (*domain.Attachment, error) {
const q = `
UPDATE attachments
SET status = 'processing', locked_until = now() + $2, updated_at = now(), attempts = attempts + 1
WHERE id = $1::uuid AND status = 'queued' AND pipeline_version = $3
RETURNING id, chat_id, staging_key, pipeline_version, object_key, content_type, attempts
`
var a domain.Attachment
err := r.pool.QueryRow(ctx, q, id, lease, version).Scan(&a.ID, &a.ChatID, &a.StagingKey, &a.PipelineVersion, &a.ObjectKey, &a.ContentType, &a.Attempts)
if err != nil {
if err == pgx.ErrNoRows {
return nil, nil
}
return nil, mapError(err)
}
return &a, nil
}
func (r *AttachmentRepo) CompleteJob(ctx context.Context, id string, pipelineVersion int, variants []domain.AttachmentVariant) (bool, error) {
tx, err := r.pool.Begin(ctx)
if err != nil {
return false, mapError(err)
}
defer func() { _ = tx.Rollback(ctx) }()
const q = `
UPDATE attachments
SET status = 'ready', locked_until = NULL, updated_at = now()
WHERE id = $1::uuid AND pipeline_version = $2 AND status = 'processing'
`
tag, err := tx.Exec(ctx, q, id, pipelineVersion)
if err != nil {
return false, mapError(err)
}
if tag.RowsAffected() == 0 {
return false, nil
}
variantRepo := NewAttachmentVariantRepo(r.pool)
for _, v := range variants {
if err := variantRepo.Upsert(ctx, &pgxTx{tx: tx}, &v); err != nil {
log.Printf("CompleteJob: ошибка Upsert %s: %v", v.Name, err)
return false, err
} else {
log.Printf("CompleteJob: успешно добавлен вариант %s", v.Name)
}
}
return true, mapError(tx.Commit(ctx))
}
func (r *AttachmentRepo) FailJob(ctx context.Context, id string, errorCode string) error {
const q = `
UPDATE attachments
SET status = 'failed', error_code = $2, locked_until = NULL, updated_at = now()
WHERE id = $1::uuid AND status = 'processing'
`
_, err := r.pool.Exec(ctx, q, id, errorCode)
return mapError(err)
}
func (r *AttachmentRepo) ScheduleRetry(ctx context.Context, id string, nextAttemptAt time.Time, errorCode string) error {
const q = `
UPDATE attachments
SET status = 'queued', error_code = NULL, next_attempt_at = $2, locked_until = NULL, updated_at = now()
WHERE id = $1::uuid AND status = 'processing'
`
_, err := r.pool.Exec(ctx, q, id, nextAttemptAt)
return mapError(err)
}
func (r *AttachmentRepo) ResetForReplay(ctx context.Context, tx domain.Tx, id string) error {
const q = `
UPDATE attachments
SET status = 'queued', attempts = 0, error_code = NULL, locked_until = NULL, next_attempt_at = NULL, updated_at = now()
WHERE id = $1::uuid AND status = 'failed'
`
return tx.Exec(ctx, q, id)
}
// для сверщика.
func (r *AttachmentRepo) ListExpiredLeases(ctx context.Context, limit int) ([]domain.Attachment, error) {
const q = `
SELECT id, chat_id, owner_id, filename, content_type, size_bytes, sha256,
object_key, status, error_code, created_at, updated_at,
attempts, next_attempt_at, locked_until, pipeline_version, staging_key
FROM attachments
WHERE status = 'processing' AND locked_until < now()
ORDER BY locked_until
LIMIT $1
`
rows, err := r.pool.Query(ctx, q, limit)
if err != nil {
return nil, mapError(err)
}
defer rows.Close()
var out []domain.Attachment
for rows.Next() {
var a domain.Attachment
var status string
err := rows.Scan(&a.ID, &a.ChatID, &a.OwnerID, &a.Filename, &a.ContentType,
&a.SizeBytes, &a.SHA256, &a.ObjectKey, &status, &a.ErrorCode,
&a.CreatedAt, &a.UpdatedAt, &a.Attempts, &a.NextAttemptAt, &a.LockedUntil,
&a.PipelineVersion, &a.StagingKey)
if err != nil {
return nil, mapError(err)
}
a.Status = domain.AttachmentStatus(status)
out = append(out, a)
}
return out, mapError(rows.Err())
}
func (r *AttachmentRepo) ResetLease(ctx context.Context, id string) error {
const q = `
UPDATE attachments
SET status = 'queued', locked_until = NULL, updated_at = now()
WHERE id = $1::uuid AND status = 'processing' AND locked_until < now()
`
_, err := r.pool.Exec(ctx, q, id)
return mapError(err)
}
func (r *AttachmentRepo) ListStagingToCleanup(ctx context.Context, limit int) ([]domain.Attachment, error) {
const q = `
SELECT id, staging_key
FROM attachments
WHERE status = 'ready' AND staging_key IS NOT NULL
LIMIT $1
`
rows, err := r.pool.Query(ctx, q, limit)
if err != nil {
return nil, mapError(err)
}
defer rows.Close()
var out []domain.Attachment
for rows.Next() {
var a domain.Attachment
if err := rows.Scan(&a.ID, &a.StagingKey); err != nil {
return nil, mapError(err)
}
out = append(out, a)
}
return out, mapError(rows.Err())
}
func (r *AttachmentRepo) ClearStagingKey(ctx context.Context, id string) error {
const q = `UPDATE attachments SET staging_key = NULL WHERE id = $1::uuid`
_, err := r.pool.Exec(ctx, q, id)
return mapError(err)
}
var _ domain.AttachmentRepository = (*AttachmentRepo)(nil)