forked from mtusi2026/mtusi2026lab4
286 lines
6.8 KiB
Go
286 lines
6.8 KiB
Go
package postgres
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"crypto/sha256"
|
|
"errors"
|
|
"fmt"
|
|
"time"
|
|
|
|
"github.com/google/uuid"
|
|
"github.com/jackc/pgx/v5"
|
|
|
|
"gitea.privcloud.tech/dizi/mtusi2026lab4/internal/model"
|
|
)
|
|
|
|
const expiredIdempotencyCleanupBatch = 100
|
|
|
|
func (s *Store) CreateMessage(
|
|
ctx context.Context,
|
|
chatID string,
|
|
senderID string,
|
|
text string,
|
|
idempotencyKey string,
|
|
idempotencyTTL time.Duration,
|
|
) (model.Message, bool, error) {
|
|
var (
|
|
tx pgx.Tx
|
|
err error
|
|
visible bool
|
|
requestHash [sha256.Size]byte
|
|
message model.Message
|
|
replay bool
|
|
)
|
|
|
|
tx, err = s.pool.BeginTx(ctx, pgx.TxOptions{})
|
|
if err != nil {
|
|
return model.Message{}, false, fmt.Errorf("begin create message transaction: %w", err)
|
|
}
|
|
defer func() { _ = tx.Rollback(context.WithoutCancel(ctx)) }()
|
|
|
|
visible, err = chatVisibleInTransaction(ctx, tx, chatID, senderID)
|
|
if err != nil {
|
|
return model.Message{}, false, err
|
|
}
|
|
if !visible {
|
|
return model.Message{}, false, ErrNotFound
|
|
}
|
|
if err = deleteExpiredIdempotencyRecords(ctx, tx, expiredIdempotencyCleanupBatch); err != nil {
|
|
return model.Message{}, false, err
|
|
}
|
|
|
|
requestHash = sha256.Sum256([]byte(text))
|
|
message, replay, err = createIdempotentMessage(
|
|
ctx, tx, chatID, senderID, text, idempotencyKey, requestHash[:], idempotencyTTL,
|
|
)
|
|
if err != nil {
|
|
return model.Message{}, false, err
|
|
}
|
|
if err := tx.Commit(ctx); err != nil {
|
|
return model.Message{}, false, fmt.Errorf("commit create message transaction: %w", err)
|
|
}
|
|
return message, replay, nil
|
|
}
|
|
|
|
func chatVisibleInTransaction(ctx context.Context, tx pgx.Tx, chatID, userID string) (bool, error) {
|
|
const query = `
|
|
SELECT EXISTS (
|
|
SELECT 1
|
|
FROM chat_members
|
|
WHERE chat_id = $1 AND user_id = $2
|
|
)`
|
|
|
|
var visible bool
|
|
if err := tx.QueryRow(ctx, query, chatID, userID).Scan(&visible); err != nil {
|
|
return false, fmt.Errorf("check chat visibility: %w", err)
|
|
}
|
|
return visible, nil
|
|
}
|
|
|
|
func createIdempotentMessage(
|
|
ctx context.Context,
|
|
tx pgx.Tx,
|
|
chatID string,
|
|
senderID string,
|
|
text string,
|
|
idempotencyKey string,
|
|
requestHash []byte,
|
|
idempotencyTTL time.Duration,
|
|
) (model.Message, bool, error) {
|
|
for {
|
|
var (
|
|
record idempotencyRecord
|
|
found bool
|
|
err error
|
|
messageID string
|
|
reserved bool
|
|
message model.Message
|
|
)
|
|
|
|
record, found, err = lockIdempotencyRecord(ctx, tx, senderID, chatID, idempotencyKey)
|
|
if err != nil {
|
|
return model.Message{}, false, err
|
|
}
|
|
if found && record.active {
|
|
if !bytes.Equal(record.requestHash, requestHash) {
|
|
return model.Message{}, false, ErrIdempotencyConflict
|
|
}
|
|
message, err = messageByID(ctx, tx, record.messageID)
|
|
return message, true, err
|
|
}
|
|
if found {
|
|
if err := deleteIdempotencyRecord(ctx, tx, senderID, chatID, idempotencyKey); err != nil {
|
|
return model.Message{}, false, err
|
|
}
|
|
}
|
|
|
|
messageID = uuid.NewString()
|
|
reserved, err = reserveIdempotencyKey(
|
|
ctx, tx, senderID, chatID, idempotencyKey, requestHash, messageID, idempotencyTTL,
|
|
)
|
|
if err != nil {
|
|
return model.Message{}, false, err
|
|
}
|
|
if !reserved {
|
|
continue
|
|
}
|
|
|
|
message, err = insertMessage(ctx, tx, messageID, chatID, senderID, text)
|
|
return message, false, err
|
|
}
|
|
}
|
|
|
|
func deleteExpiredIdempotencyRecords(ctx context.Context, tx pgx.Tx, limit int) error {
|
|
const query = `
|
|
WITH expired AS (
|
|
SELECT ctid
|
|
FROM message_idempotency
|
|
WHERE expires_at <= statement_timestamp()
|
|
ORDER BY expires_at
|
|
LIMIT $1
|
|
FOR UPDATE SKIP LOCKED
|
|
)
|
|
DELETE FROM message_idempotency records
|
|
USING expired
|
|
WHERE records.ctid = expired.ctid`
|
|
|
|
if _, err := tx.Exec(ctx, query, limit); err != nil {
|
|
return fmt.Errorf("delete expired idempotency records: %w", err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type idempotencyRecord struct {
|
|
requestHash []byte
|
|
messageID string
|
|
active bool
|
|
}
|
|
|
|
func lockIdempotencyRecord(
|
|
ctx context.Context,
|
|
tx pgx.Tx,
|
|
userID string,
|
|
chatID string,
|
|
key string,
|
|
) (idempotencyRecord, bool, error) {
|
|
const query = `
|
|
SELECT request_hash, message_id, expires_at > statement_timestamp()
|
|
FROM message_idempotency
|
|
WHERE user_id = $1 AND chat_id = $2 AND key = $3
|
|
FOR UPDATE`
|
|
|
|
var (
|
|
record idempotencyRecord
|
|
err error
|
|
)
|
|
err = tx.QueryRow(ctx, query, userID, chatID, key).Scan(
|
|
&record.requestHash,
|
|
&record.messageID,
|
|
&record.active,
|
|
)
|
|
if errors.Is(err, pgx.ErrNoRows) {
|
|
return idempotencyRecord{}, false, nil
|
|
}
|
|
if err != nil {
|
|
return idempotencyRecord{}, false, fmt.Errorf("lock idempotency key: %w", err)
|
|
}
|
|
return record, true, nil
|
|
}
|
|
|
|
func deleteIdempotencyRecord(ctx context.Context, tx pgx.Tx, userID, chatID, key string) error {
|
|
const query = `
|
|
DELETE FROM message_idempotency
|
|
WHERE user_id = $1 AND chat_id = $2 AND key = $3`
|
|
if _, err := tx.Exec(ctx, query, userID, chatID, key); err != nil {
|
|
return fmt.Errorf("delete expired idempotency key: %w", err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func reserveIdempotencyKey(
|
|
ctx context.Context,
|
|
tx pgx.Tx,
|
|
userID string,
|
|
chatID string,
|
|
key string,
|
|
requestHash []byte,
|
|
messageID string,
|
|
ttl time.Duration,
|
|
) (bool, error) {
|
|
const query = `
|
|
INSERT INTO message_idempotency (user_id, chat_id, key, request_hash, message_id, expires_at)
|
|
VALUES ($1, $2, $3, $4, $5, statement_timestamp() + $6 * INTERVAL '1 second')
|
|
ON CONFLICT (user_id, chat_id, key) DO NOTHING
|
|
RETURNING true`
|
|
|
|
var (
|
|
inserted bool
|
|
err error
|
|
)
|
|
err = tx.QueryRow(ctx, query, userID, chatID, key, requestHash, messageID, int64(ttl/time.Second)).Scan(&inserted)
|
|
if errors.Is(err, pgx.ErrNoRows) {
|
|
return false, nil
|
|
}
|
|
if err != nil {
|
|
return false, fmt.Errorf("reserve idempotency key: %w", err)
|
|
}
|
|
return inserted, nil
|
|
}
|
|
|
|
func insertMessage(
|
|
ctx context.Context,
|
|
tx pgx.Tx,
|
|
messageID string,
|
|
chatID string,
|
|
senderID string,
|
|
text string,
|
|
) (model.Message, error) {
|
|
const query = `
|
|
INSERT INTO messages (id, chat_id, sender_id, text)
|
|
VALUES ($1, $2, $3, $4)
|
|
RETURNING id, chat_id, sender_id, text, created_at`
|
|
|
|
var (
|
|
message model.Message
|
|
err error
|
|
)
|
|
err = tx.QueryRow(ctx, query, messageID, chatID, senderID, text).Scan(
|
|
&message.ID,
|
|
&message.ChatID,
|
|
&message.SenderID,
|
|
&message.Text,
|
|
&message.CreatedAt,
|
|
)
|
|
if err != nil {
|
|
return model.Message{}, fmt.Errorf("insert message: %w", err)
|
|
}
|
|
return message, nil
|
|
}
|
|
|
|
func messageByID(ctx context.Context, tx pgx.Tx, messageID string) (model.Message, error) {
|
|
const query = `
|
|
SELECT id, chat_id, sender_id, text, created_at
|
|
FROM messages
|
|
WHERE id = $1`
|
|
|
|
var (
|
|
message model.Message
|
|
err error
|
|
)
|
|
err = tx.QueryRow(ctx, query, messageID).Scan(
|
|
&message.ID,
|
|
&message.ChatID,
|
|
&message.SenderID,
|
|
&message.Text,
|
|
&message.CreatedAt,
|
|
)
|
|
if errors.Is(err, pgx.ErrNoRows) {
|
|
return model.Message{}, fmt.Errorf("idempotency result message not found")
|
|
}
|
|
if err != nil {
|
|
return model.Message{}, fmt.Errorf("get idempotency result message: %w", err)
|
|
}
|
|
return message, nil
|
|
}
|