Files
mtusi2026lab3/internal/store/postgres.go
T
iDizZ d065cffb4e Добавить две реплики API за HAProxy и проверку отказа одной из них.
Общие сессии и ключ идемпотентности позволяют продолжать чтение и запись, когда одна реплика остановлена.
2026-11-06 17:31:40 +03:00

460 lines
13 KiB
Go

package store
import (
"context"
"errors"
"net"
"time"
"github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/pgconn"
"github.com/jackc/pgx/v5/pgxpool"
)
// PG — источник истины для пользователей, чатов и сообщений.
// Запросы только с параметрами. Пул ограничен, у сессии соединения есть statement_timeout.
type PG struct {
pool *pgxpool.Pool
idemTTL time.Duration
}
func Open(ctx context.Context, databaseURL string, maxConns int32) (*PG, error) {
cfg, err := pgxpool.ParseConfig(databaseURL)
if err != nil {
return nil, err
}
if maxConns < 1 {
maxConns = 10
}
cfg.MaxConns = maxConns
cfg.MinConns = 1
cfg.MaxConnLifetime = 30 * time.Minute
cfg.MaxConnIdleTime = 5 * time.Minute
cfg.HealthCheckPeriod = 30 * time.Second
cfg.ConnConfig.ConnectTimeout = 3 * time.Second
cfg.ConnConfig.RuntimeParams["application_name"] = "messenger"
cfg.ConnConfig.RuntimeParams["statement_timeout"] = "5000"
cfg.ConnConfig.RuntimeParams["lock_timeout"] = "3000"
cfg.ConnConfig.RuntimeParams["idle_in_transaction_session_timeout"] = "10000"
pool, err := pgxpool.NewWithConfig(ctx, cfg)
if err != nil {
return nil, err
}
pingCtx, cancel := context.WithTimeout(ctx, 3*time.Second)
defer cancel()
if err := pool.Ping(pingCtx); err != nil {
pool.Close()
return nil, err
}
return &PG{pool: pool, idemTTL: 24 * time.Hour}, nil
}
// SetIdempotencyTTL задаёт, сколько хранить результат POST сообщения.
func (p *PG) SetIdempotencyTTL(ttl time.Duration) {
if ttl > 0 {
p.idemTTL = ttl
}
}
func (p *PG) Close() { p.pool.Close() }
func (p *PG) Pool() *pgxpool.Pool { return p.pool }
func (p *PG) Ping(ctx context.Context) error {
return mapDB(p.pool.Ping(ctx))
}
func (p *PG) CreateUser(ctx context.Context, username, displayName, passwordHash string) (User, error) {
u := User{
ID: newID(),
Username: username,
DisplayName: displayName,
CreatedAt: time.Now().UTC().Truncate(time.Microsecond),
}
_, err := p.pool.Exec(ctx, `
INSERT INTO users (id, username, display_name, password_hash, created_at)
VALUES ($1, $2, $3, $4, $5)`,
u.ID, u.Username, u.DisplayName, passwordHash, u.CreatedAt)
if err != nil {
return User{}, mapDB(err)
}
return u, nil
}
func (p *PG) User(ctx context.Context, id string) (User, error) {
row := p.pool.QueryRow(ctx, `
SELECT id::text, username, display_name, created_at
FROM users WHERE id = $1`, id)
return scanUser(row)
}
func (p *PG) UserByUsername(ctx context.Context, username string) (User, string, error) {
var u User
var hash string
err := p.pool.QueryRow(ctx, `
SELECT id::text, username, display_name, created_at, password_hash
FROM users WHERE username = $1`, username).Scan(&u.ID, &u.Username, &u.DisplayName, &u.CreatedAt, &hash)
if err != nil {
return User{}, "", mapDB(err)
}
u.CreatedAt = u.CreatedAt.UTC()
return u, hash, nil
}
// CreateChat пишет чат и всех участников в одной транзакции.
// Если кого-то из списка нет, COMMIT не случается и строка чата не остаётся.
func (p *PG) CreateChat(ctx context.Context, title string, memberIDs []string, caller string) (Chat, error) {
seen := make(map[string]struct{}, len(memberIDs))
for _, id := range memberIDs {
if _, dup := seen[id]; dup {
return Chat{}, ErrInvalid
}
seen[id] = struct{}{}
}
if _, ok := seen[caller]; !ok {
return Chat{}, ErrInvalid
}
tx, err := p.pool.Begin(ctx)
if err != nil {
return Chat{}, mapDB(err)
}
defer func() { _ = tx.Rollback(ctx) }()
c := Chat{
ID: newID(),
Title: title,
MemberIDs: append([]string(nil), memberIDs...),
CreatedAt: time.Now().UTC().Truncate(time.Microsecond),
}
if _, err := tx.Exec(ctx, `INSERT INTO chats (id, title, created_at) VALUES ($1, $2, $3)`, c.ID, c.Title, c.CreatedAt); err != nil {
return Chat{}, mapDB(err)
}
var n int
if err := tx.QueryRow(ctx, `SELECT count(*) FROM users WHERE id::text = ANY($1::text[])`, memberIDs).Scan(&n); err != nil {
return Chat{}, mapDB(err)
}
if n != len(memberIDs) {
return Chat{}, ErrInvalid
}
for i, id := range memberIDs {
if _, err := tx.Exec(ctx, `
INSERT INTO chat_members (chat_id, user_id, position) VALUES ($1, $2, $3)`,
c.ID, id, i); err != nil {
return Chat{}, mapDB(err)
}
}
if err := tx.Commit(ctx); err != nil {
return Chat{}, mapDB(err)
}
return c, nil
}
func (p *PG) ChatFor(ctx context.Context, chatID, userID string) (Chat, error) {
var c Chat
err := p.pool.QueryRow(ctx, `
SELECT c.id::text, c.title, c.created_at
FROM chats c
JOIN chat_members cm ON cm.chat_id = c.id AND cm.user_id = $2
WHERE c.id = $1`, chatID, userID).Scan(&c.ID, &c.Title, &c.CreatedAt)
if err != nil {
return Chat{}, mapDB(err)
}
c.CreatedAt = c.CreatedAt.UTC()
ids, err := p.memberIDs(ctx, p.pool, []string{c.ID})
if err != nil {
return Chat{}, err
}
c.MemberIDs = ids[c.ID]
if c.MemberIDs == nil {
c.MemberIDs = []string{}
}
return c, nil
}
func (p *PG) ListChats(ctx context.Context, userID string, cur *Cursor, limit int) ([]Chat, bool, error) {
hasCursor := cur != nil
at := time.Time{}
var id any
if hasCursor {
at = cur.At
id = cur.ID
}
rows, err := p.pool.Query(ctx, `
SELECT c.id::text, c.title, c.created_at
FROM chats c
JOIN chat_members cm ON cm.chat_id = c.id AND cm.user_id = $1
WHERE NOT $2::bool OR (c.created_at, c.id) > ($3::timestamptz, $4::uuid)
ORDER BY c.created_at, c.id
LIMIT $5`, userID, hasCursor, at, id, limit+1)
if err != nil {
return nil, false, mapDB(err)
}
defer rows.Close()
items := make([]Chat, 0)
ids := make([]string, 0)
for rows.Next() {
var c Chat
if err := rows.Scan(&c.ID, &c.Title, &c.CreatedAt); err != nil {
return nil, false, mapDB(err)
}
c.CreatedAt = c.CreatedAt.UTC()
items = append(items, c)
ids = append(ids, c.ID)
}
if err := rows.Err(); err != nil {
return nil, false, mapDB(err)
}
hasMore := len(items) > limit
if hasMore {
items = items[:limit]
ids = ids[:limit]
}
members, err := p.memberIDs(ctx, p.pool, ids)
if err != nil {
return nil, false, err
}
for i := range items {
items[i].MemberIDs = members[items[i].ID]
if items[i].MemberIDs == nil {
items[i].MemberIDs = []string{}
}
}
return items, hasMore, nil
}
func (p *PG) AddMessage(ctx context.Context, chatID, senderID, text, idemKey, fingerprint string) (Message, error) {
if idemKey == "" || fingerprint == "" {
return Message{}, ErrInvalid
}
var last error
for attempt := 0; attempt < 5; attempt++ {
msg, retry, err := p.addMessageOnce(ctx, chatID, senderID, text, idemKey, fingerprint)
if !retry {
return msg, err
}
last = err
}
if last == nil {
last = ErrUnavailable
}
return Message{}, ErrUnavailable
}
// addMessageOnce пишет сообщение и ключ одной транзакцией.
// retry=true значит, что параллельная реплика заняла тот же ключ раньше: свою вставку откатываем и читаем её результат.
func (p *PG) addMessageOnce(ctx context.Context, chatID, senderID, text, idemKey, fingerprint string) (Message, bool, error) {
tx, err := p.pool.Begin(ctx)
if err != nil {
return Message{}, false, mapDB(err)
}
defer func() { _ = tx.Rollback(ctx) }()
var member int
if err := tx.QueryRow(ctx, `
SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2`, chatID, senderID).Scan(&member); err != nil {
return Message{}, false, mapDB(err)
}
var storedFP, messageID string
var expires time.Time
err = tx.QueryRow(ctx, `
SELECT fingerprint, message_id::text, expires_at
FROM message_idempotency
WHERE user_id = $1 AND chat_id = $2 AND idem_key = $3
FOR UPDATE`, senderID, chatID, idemKey).Scan(&storedFP, &messageID, &expires)
if err == nil {
if expires.After(time.Now()) {
if storedFP != fingerprint {
return Message{}, false, ErrIdempotencyMismatch
}
msg, err := scanMessage(tx.QueryRow(ctx, `
SELECT id::text, chat_id::text, sender_id::text, text, created_at
FROM messages WHERE id = $1`, messageID))
if err != nil {
return Message{}, false, err
}
if err := tx.Commit(ctx); err != nil {
return Message{}, false, mapDB(err)
}
return msg, false, nil
}
if _, err := tx.Exec(ctx, `
DELETE FROM message_idempotency
WHERE user_id = $1 AND chat_id = $2 AND idem_key = $3`, senderID, chatID, idemKey); err != nil {
return Message{}, false, mapDB(err)
}
} else if !errors.Is(err, pgx.ErrNoRows) {
return Message{}, false, mapDB(err)
}
now := time.Now().UTC().Truncate(time.Microsecond)
m := Message{
ID: newID(),
ChatID: chatID,
SenderID: senderID,
Text: text,
CreatedAt: now,
}
if _, err := tx.Exec(ctx, `
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
VALUES ($1, $2, $3, $4, $5)`, m.ID, m.ChatID, m.SenderID, m.Text, m.CreatedAt); err != nil {
return Message{}, retryable(err), mapDB(err)
}
recorded := time.Now().UTC().Truncate(time.Microsecond)
if _, err := tx.Exec(ctx, `
INSERT INTO message_idempotency
(user_id, chat_id, idem_key, fingerprint, message_id, created_at, expires_at)
VALUES ($1, $2, $3, $4, $5, $6, $7)`,
senderID, chatID, idemKey, fingerprint, m.ID, recorded, recorded.Add(p.idemTTL)); err != nil {
return Message{}, retryable(err), mapDB(err)
}
if err := tx.Commit(ctx); err != nil {
return Message{}, retryable(err), mapDB(err)
}
return m, false, nil
}
func retryable(err error) bool {
var pgErr *pgconn.PgError
if errors.As(err, &pgErr) {
switch pgErr.Code {
case "23505", "40001", "40P01":
return true
}
}
return false
}
func (p *PG) ListMessages(ctx context.Context, chatID, userID string, cur *Cursor, limit int) ([]Message, bool, error) {
var member int
err := p.pool.QueryRow(ctx, `
SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2`, chatID, userID).Scan(&member)
if err != nil {
return nil, false, mapDB(err)
}
if cur != nil {
var one int
err := p.pool.QueryRow(ctx, `
SELECT 1 FROM messages
WHERE chat_id = $1 AND id = $2 AND created_at = $3`, chatID, cur.ID, cur.At).Scan(&one)
if errors.Is(err, pgx.ErrNoRows) {
return nil, false, ErrBadCursor
}
if err != nil {
return nil, false, mapDB(err)
}
}
hasCursor := cur != nil
at := time.Time{}
var id any
if hasCursor {
at = cur.At
id = cur.ID
}
rows, err := p.pool.Query(ctx, `
SELECT id::text, chat_id::text, sender_id::text, text, created_at
FROM messages
WHERE chat_id = $1
AND (NOT $2::bool OR (created_at, id) > ($3::timestamptz, $4::uuid))
ORDER BY created_at, id
LIMIT $5`, chatID, hasCursor, at, id, limit+1)
if err != nil {
return nil, false, mapDB(err)
}
defer rows.Close()
items := make([]Message, 0)
for rows.Next() {
m, err := scanMessage(rows)
if err != nil {
return nil, false, err
}
items = append(items, m)
}
if err := rows.Err(); err != nil {
return nil, false, mapDB(err)
}
hasMore := len(items) > limit
if hasMore {
items = items[:limit]
}
return items, hasMore, nil
}
type queryer interface {
Query(ctx context.Context, sql string, args ...any) (pgx.Rows, error)
}
func (p *PG) memberIDs(ctx context.Context, q queryer, chatIDs []string) (map[string][]string, error) {
out := make(map[string][]string, len(chatIDs))
if len(chatIDs) == 0 {
return out, nil
}
rows, err := q.Query(ctx, `
SELECT chat_id::text, user_id::text
FROM chat_members
WHERE chat_id::text = ANY($1::text[])
ORDER BY chat_id, position`, chatIDs)
if err != nil {
return nil, mapDB(err)
}
defer rows.Close()
for rows.Next() {
var chatID, userID string
if err := rows.Scan(&chatID, &userID); err != nil {
return nil, mapDB(err)
}
out[chatID] = append(out[chatID], userID)
}
if err := rows.Err(); err != nil {
return nil, mapDB(err)
}
return out, nil
}
func scanMessage(row pgx.Row) (Message, error) {
var m Message
if err := row.Scan(&m.ID, &m.ChatID, &m.SenderID, &m.Text, &m.CreatedAt); err != nil {
return Message{}, mapDB(err)
}
m.CreatedAt = m.CreatedAt.UTC()
return m, nil
}
func scanUser(row pgx.Row) (User, error) {
var u User
err := row.Scan(&u.ID, &u.Username, &u.DisplayName, &u.CreatedAt)
if err != nil {
return User{}, mapDB(err)
}
u.CreatedAt = u.CreatedAt.UTC()
return u, nil
}
func mapDB(err error) error {
if err == nil {
return nil
}
if errors.Is(err, pgx.ErrNoRows) {
return ErrNotFound
}
if errors.Is(err, context.DeadlineExceeded) || errors.Is(err, context.Canceled) {
return ErrUnavailable
}
var pgErr *pgconn.PgError
if errors.As(err, &pgErr) {
switch pgErr.Code {
case "23505":
return ErrConflict
case "23503", "23514", "22P02":
return ErrInvalid
case "57014", "55P03":
return ErrUnavailable
}
}
var netErr net.Error
if errors.As(err, &netErr) {
return ErrUnavailable
}
return err
}