forked from mtusi2026/mtusi2026lab3
Общие сессии и ключ идемпотентности позволяют продолжать чтение и запись, когда одна реплика остановлена.
460 lines
13 KiB
Go
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
|
|
}
|