Files
mtusi2026lab3/src/store.go
T

637 lines
21 KiB
Go
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
package main
import (
"context"
"encoding/base64"
"errors"
"log/slog"
"strings"
"sync"
"time"
"github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/pgconn"
"github.com/jackc/pgx/v5/pgxpool"
)
// Фиксированная ширина (6 знаков) => строки курсора сравниваются
// лексикографически так же, как время. Формат: RFC 3339 UTC с "Z".
const tsLayout = "2006-01-02T15:04:05.000000Z"
var (
errConflict = errors.New("conflict")
errInvalid = errors.New("invalid")
errNotFound = errors.New("not found")
errUnauthorized = errors.New("unauthorized")
)
type User struct {
ID string `json:"id"`
Username string `json:"username"`
DisplayName string `json:"display_name"`
CreatedAt string `json:"created_at"`
}
type Chat struct {
ID string `json:"id"`
Title string `json:"title"`
MemberIDs []string `json:"member_ids"`
CreatedAt string `json:"created_at"`
}
type Message struct {
ID string `json:"id"`
ChatID string `json:"chat_id"`
SenderID string `json:"sender_id"`
Text string `json:"text"`
CreatedAt string `json:"created_at"`
}
type Session struct {
Token string `json:"token"`
TokenType string `json:"token_type"`
ExpiresAt string `json:"expires_at"`
User User `json:"user"`
}
func formatTS(t time.Time) string { return t.UTC().Format(tsLayout) }
// Store — тонкая обёртка над *pgxpool.Pool (+ опциональный Redis-кэш сессий).
// Пул соединений и его лимиты настраиваются в openPool; здесь только запросы.
type Store struct {
db *pgxpool.Pool
cache *sessionCache // nil => кэш не настроен, работаем только с Postgres
sessionTTL time.Duration
revoked sync.Map // string(token_hash) -> time.Time: см. denyLocally
}
func NewStore(db *pgxpool.Pool, cache *sessionCache, sessionTTL time.Duration) *Store {
return &Store{db: db, cache: cache, sessionTTL: sessionTTL}
}
// isUniqueViolation: SQLSTATE 23505 — PostgreSQL error code для unique_violation.
func isUniqueViolation(err error) bool {
var pgErr *pgconn.PgError
return errors.As(err, &pgErr) && pgErr.Code == "23505"
}
// isForeignKeyViolation: SQLSTATE 23503 — ссылка на несуществующую строку
// (например, неизвестный user_id в chat_members).
func isForeignKeyViolation(err error) bool {
var pgErr *pgconn.PgError
return errors.As(err, &pgErr) && pgErr.Code == "23503"
}
func (s *Store) CreateUser(ctx context.Context, username, displayName, passwordHash string) (User, error) {
ctx, cancel := withTimeout(ctx)
defer cancel()
u := User{ID: newUUID(), Username: username, DisplayName: displayName}
var createdAt time.Time
err := s.db.QueryRow(ctx,
`INSERT INTO users (id, username, display_name, password_hash)
VALUES ($1, $2, $3, $4) RETURNING created_at`,
u.ID, username, displayName, passwordHash).Scan(&createdAt)
if err != nil {
if isUniqueViolation(err) {
return User{}, errConflict
}
return User{}, err
}
u.CreatedAt = formatTS(createdAt)
return u, nil
}
func (s *Store) GetUser(ctx context.Context, id string) (User, error) {
ctx, cancel := withTimeout(ctx)
defer cancel()
var u User
var createdAt time.Time
err := s.db.QueryRow(ctx,
`SELECT id, username, display_name, created_at FROM users WHERE id = $1`,
id).Scan(&u.ID, &u.Username, &u.DisplayName, &createdAt)
if errors.Is(err, pgx.ErrNoRows) {
return User{}, errNotFound
}
if err != nil {
return User{}, err
}
u.CreatedAt = formatTS(createdAt)
return u, nil
}
// AuthenticateUser проверяет Basic username:password. Несуществующий
// username и неверный пароль дают одну и ту же ошибку — чтобы ответ не
// раскрывал, какой username существует.
func (s *Store) AuthenticateUser(ctx context.Context, username, password string) (User, error) {
ctx, cancel := withTimeout(ctx)
defer cancel()
var u User
var createdAt time.Time
var hash string
err := s.db.QueryRow(ctx,
`SELECT id, username, display_name, password_hash, created_at FROM users WHERE username = $1`,
username).Scan(&u.ID, &u.Username, &u.DisplayName, &hash, &createdAt)
if errors.Is(err, pgx.ErrNoRows) {
return User{}, errUnauthorized
}
if err != nil {
return User{}, err
}
ok, err := verifyPassword(hash, password)
if err != nil || !ok {
return User{}, errUnauthorized
}
u.CreatedAt = formatTS(createdAt)
return u, nil
}
// CreateChat — атомарная составная операция: вставка чата и всех строк
// членства в одной транзакции. Неизвестный участник нарушает FK на
// chat_members.user_id -> откат целиком, ни чат, ни частичный список
// участников не остаются в БД.
func (s *Store) CreateChat(ctx context.Context, title string, memberIDs []string) (Chat, error) {
ctx, cancel := withTimeout(ctx)
defer cancel()
tx, err := s.db.Begin(ctx)
if err != nil {
return Chat{}, err
}
defer tx.Rollback(ctx) //nolint:errcheck — не влияет после успешного Commit
c := Chat{ID: newUUID(), Title: title, MemberIDs: memberIDs}
var createdAt time.Time
if err := tx.QueryRow(ctx,
`INSERT INTO chats (id, title) VALUES ($1, $2) RETURNING created_at`,
c.ID, title).Scan(&createdAt); err != nil {
return Chat{}, err
}
if _, err := tx.Exec(ctx,
`INSERT INTO chat_members (chat_id, user_id)
SELECT $1, unnest($2::uuid[])`,
c.ID, memberIDs); err != nil {
if isForeignKeyViolation(err) {
return Chat{}, errInvalid
}
return Chat{}, err
}
if err := tx.Commit(ctx); err != nil {
return Chat{}, err
}
c.CreatedAt = formatTS(createdAt)
return c, nil
}
// GetChat возвращает чат, только если userID — его участник; чужой и
// несуществующий чат неразличимы (оба errNotFound — так и задано в контракте).
func (s *Store) GetChat(ctx context.Context, userID, chatID string) (Chat, error) {
ctx, cancel := withTimeout(ctx)
defer cancel()
var c Chat
var createdAt time.Time
err := s.db.QueryRow(ctx,
`SELECT c.id, 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, &createdAt)
if errors.Is(err, pgx.ErrNoRows) {
return Chat{}, errNotFound
}
if err != nil {
return Chat{}, err
}
members, err := s.chatMembers(ctx, c.ID)
if err != nil {
return Chat{}, err
}
c.MemberIDs = members
c.CreatedAt = formatTS(createdAt)
return c, nil
}
func (s *Store) chatMembers(ctx context.Context, chatID string) ([]string, error) {
rows, err := s.db.Query(ctx,
`SELECT user_id FROM chat_members WHERE chat_id = $1`, chatID)
if err != nil {
return nil, err
}
defer rows.Close()
// make(..., 0), не var out []string: nil-слайс маршалится в JSON как
// null, а не [] — контракт (и smoke-тест) ожидает массив даже пустой.
out := make([]string, 0)
for rows.Next() {
var id string
if err := rows.Scan(&id); err != nil {
return nil, err
}
out = append(out, id)
}
return out, rows.Err()
}
func (s *Store) AddMessage(ctx context.Context, userID, chatID, text string) (Message, error) {
ctx, cancel := withTimeout(ctx)
defer cancel()
var isMember bool
if err := s.db.QueryRow(ctx,
`SELECT EXISTS(SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2)`,
chatID, userID).Scan(&isMember); err != nil {
return Message{}, err
}
if !isMember {
return Message{}, errNotFound
}
m := Message{ID: newUUID(), ChatID: chatID, SenderID: userID, Text: text}
var createdAt time.Time
err := s.db.QueryRow(ctx,
`INSERT INTO messages (id, chat_id, sender_id, text, created_at)
VALUES ($1, $2, $3, $4, clock_timestamp()) RETURNING created_at`,
m.ID, chatID, userID, text).Scan(&createdAt)
if err != nil {
return Message{}, err
}
m.CreatedAt = formatTS(createdAt)
return m, nil
}
// ListMessages — keyset-пагинация: fetch limit+1 строк, чтобы одним запросом
// узнать и страницу, и есть ли следующая, без отдельного COUNT(*).
func (s *Store) ListMessages(ctx context.Context, userID, chatID string, after *pos, limit int) ([]Message, bool, error) {
ctx, cancel := withTimeout(ctx)
defer cancel()
var isMember bool
if err := s.db.QueryRow(ctx,
`SELECT EXISTS(SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2)`,
chatID, userID).Scan(&isMember); err != nil {
return nil, false, err
}
if !isMember {
return nil, false, errNotFound
}
var rows pgx.Rows
var err error
if after == nil {
rows, err = s.db.Query(ctx,
`SELECT id, chat_id, sender_id, text, created_at FROM messages
WHERE chat_id = $1
ORDER BY created_at, id
LIMIT $2`,
chatID, limit+1)
} else {
rows, err = s.db.Query(ctx,
`SELECT id, chat_id, sender_id, text, created_at FROM messages
WHERE chat_id = $1 AND (created_at, id) > ($2::timestamptz, $3::uuid)
ORDER BY created_at, id
LIMIT $4`,
chatID, after.ts, after.id, limit+1)
}
if err != nil {
return nil, false, err
}
defer rows.Close()
// make(..., 0), не var out []Message: nil-слайс маршалится в JSON как
// null, а не [] — "items" в ответе должен быть массивом даже пустым.
out := make([]Message, 0)
for rows.Next() {
var m Message
var createdAt time.Time
if err := rows.Scan(&m.ID, &m.ChatID, &m.SenderID, &m.Text, &createdAt); err != nil {
return nil, false, err
}
m.CreatedAt = formatTS(createdAt)
out = append(out, m)
}
if err := rows.Err(); err != nil {
return nil, false, err
}
more := len(out) > limit
if more {
out = out[:limit]
}
return out, more, nil
}
func (s *Store) ListChats(ctx context.Context, userID string, after *pos, limit int) ([]Chat, bool, error) {
ctx, cancel := withTimeout(ctx)
defer cancel()
var rows pgx.Rows
var err error
if after == nil {
rows, err = s.db.Query(ctx,
`SELECT c.id, c.title, c.created_at
FROM chats c JOIN chat_members cm ON cm.chat_id = c.id
WHERE cm.user_id = $1
ORDER BY c.created_at, c.id
LIMIT $2`,
userID, limit+1)
} else {
rows, err = s.db.Query(ctx,
`SELECT c.id, c.title, c.created_at
FROM chats c JOIN chat_members cm ON cm.chat_id = c.id
WHERE cm.user_id = $1 AND (c.created_at, c.id) > ($2::timestamptz, $3::uuid)
ORDER BY c.created_at, c.id
LIMIT $4`,
userID, after.ts, after.id, limit+1)
}
if err != nil {
return nil, false, err
}
defer rows.Close()
// make(..., 0), не var out []Chat: та же причина, что в ListMessages.
out := make([]Chat, 0)
for rows.Next() {
var c Chat
var createdAt time.Time
if err := rows.Scan(&c.ID, &c.Title, &createdAt); err != nil {
return nil, false, err
}
c.CreatedAt = formatTS(createdAt)
out = append(out, c)
}
if err := rows.Err(); err != nil {
return nil, false, err
}
more := len(out) > limit
if more {
out = out[:limit]
}
// member_ids для каждого чата страницы — одним batched-запросом, не N+1.
if len(out) > 0 {
ids := make([]string, len(out))
for i, c := range out {
ids[i] = c.ID
}
memberRows, err := s.db.Query(ctx,
`SELECT chat_id, user_id FROM chat_members WHERE chat_id = ANY($1::uuid[])`,
ids)
if err != nil {
return nil, false, err
}
members := make(map[string][]string, len(out))
for memberRows.Next() {
var chatID, memberID string
if err := memberRows.Scan(&chatID, &memberID); err != nil {
memberRows.Close()
return nil, false, err
}
members[chatID] = append(members[chatID], memberID)
}
memberRows.Close()
if err := memberRows.Err(); err != nil {
return nil, false, err
}
for i := range out {
out[i].MemberIDs = members[out[i].ID]
}
}
return out, more, nil
}
// --- сессии ------------------------------------------------------------
// CreateSession выдаёт новый opaque bearer-токен поверх уже
// аутентифицированного пользователя (см. AuthenticateUser) и кладёт его в
// Postgres (источник истины) и, если настроен, в кэш.
func (s *Store) CreateSession(ctx context.Context, u User) (Session, error) {
ctx, cancel := withTimeout(ctx)
defer cancel()
token, err := newSessionToken()
if err != nil {
return Session{}, err
}
hash := hashToken(token)
expiresAt := time.Now().UTC().Add(s.sessionTTL)
if _, err := s.db.Exec(ctx,
`INSERT INTO sessions (token_hash, user_id, expires_at) VALUES ($1, $2, $3)`,
hash, u.ID, expiresAt); err != nil {
return Session{}, err
}
// Avoid caching positive auth decisions across replicas.
_ = expiresAt
return Session{
Token: token,
TokenType: "Bearer",
ExpiresAt: formatTS(expiresAt),
User: u,
}, nil
}
// ValidateSession — горячий путь: сначала кэш (если настроен), затем
// Postgres. Любой сбой кэша (промах ИЛИ ошибка связи) просто идёт в
// Postgres — отказ Redis никогда не трактуется как "токен валиден" и
// никогда не трактуется как "запрос анонимный, но пропустим".
func (s *Store) ValidateSession(ctx context.Context, token string) (User, bool, error) {
ctx, cancel := withTimeout(ctx)
defer cancel()
hash := hashToken(token)
// Multi-replica correctness: never trust a positive Redis cache hit.
// PostgreSQL is authoritative for revocation on every request.
var u User
var createdAt, expiresAt time.Time
err := s.db.QueryRow(ctx,
`SELECT u.id, u.username, u.display_name, u.created_at, s.expires_at
FROM sessions s JOIN users u ON u.id = s.user_id
WHERE s.token_hash = $1 AND s.revoked_at IS NULL AND s.expires_at > now()`,
hash).Scan(&u.ID, &u.Username, &u.DisplayName, &createdAt, &expiresAt)
if errors.Is(err, pgx.ErrNoRows) {
return User{}, false, nil
}
if err != nil {
return User{}, false, err
}
u.CreatedAt = formatTS(createdAt)
// Avoid caching positive auth decisions across replicas.
_ = expiresAt
return u, true, nil
}
func (s *Store) RevokeSession(ctx context.Context, token string) error {
ctx, cancel := withTimeout(ctx)
defer cancel()
hash := hashToken(token)
if _, err := s.db.Exec(ctx,
`UPDATE sessions SET revoked_at = now() WHERE token_hash = $1 AND revoked_at IS NULL`,
hash); err != nil {
return err
}
// All replicas check PostgreSQL, so a failed Redis DEL cannot resurrect a token.
_ = s.cache.invalidate(ctx, hash, s.sessionTTL)
return nil
}
// denyLocally/locallyRevoked — in-memory deny-list отозванных токенов на
// случай, когда Redis не позволил инвалидировать запись. Записи живут не
// дольше срока сессии и вычищаются при добавлении новых.
func (s *Store) denyLocally(hash []byte, until time.Time) {
now := time.Now()
s.revoked.Range(func(k, v any) bool {
if now.After(v.(time.Time)) {
s.revoked.Delete(k)
}
return true
})
s.revoked.Store(string(hash), until)
}
// ReconcileRevoked вызывается при старте процесса, ДО приёма запросов.
// Локальный deny-list и надгробия живут недолго или только в памяти и не
// переживают рестарт API, а запись в Redis, которую logout не смог
// инвалидировать, — переживает. Источник истины об отзыве — Postgres
// (revoked_at), поэтому для каждой отозванной и ещё не истёкшей сессии
// повторяем инвалидацию кэша; если Redis по-прежнему не даёт ни DEL, ни
// SET — токен заносится в локальный deny-list уже из БД. Ошибка чтения из
// Postgres фатальна для старта: без неё нельзя гарантировать, что отозванный
// токен не оживёт из кэша.
func (s *Store) ReconcileRevoked(ctx context.Context) error {
if s.cache == nil {
return nil
}
rows, err := s.db.Query(ctx,
`SELECT token_hash, expires_at FROM sessions
WHERE revoked_at IS NOT NULL AND expires_at > now()`)
if err != nil {
return err
}
type revokedSession struct {
hash []byte
expiresAt time.Time
}
var revoked []revokedSession
for rows.Next() {
var r revokedSession
if err := rows.Scan(&r.hash, &r.expiresAt); err != nil {
rows.Close()
return err
}
revoked = append(revoked, r)
}
rows.Close() // освобождаем соединение до походов в Redis
if err := rows.Err(); err != nil {
return err
}
for _, r := range revoked {
if !s.cache.invalidate(ctx, r.hash, time.Until(r.expiresAt)) {
s.denyLocally(r.hash, r.expiresAt)
}
}
slog.Info("отозванные сессии сверены с кэшем", "count", len(revoked))
return nil
}
func (s *Store) locallyRevoked(hash []byte) bool {
v, ok := s.revoked.Load(string(hash))
if !ok {
return false
}
if time.Now().After(v.(time.Time)) {
s.revoked.Delete(string(hash))
return false
}
return true
}
func (s *Store) Ready(ctx context.Context) error {
ctx, cancel := withTimeout(ctx)
defer cancel()
return s.db.Ping(ctx)
}
// --- keyset cursor -----------------------------------------------------
// pos — позиция последнего отданного элемента. Курсор привязан к scope
// ("m:<chat_id>" или "c:<user_id>"), поэтому курсор чужого чата даёт 400.
type pos struct{ ts, id string }
func encodeCursor(scope, ts, id string) string {
return base64.RawURLEncoding.EncodeToString([]byte(scope + "|" + ts + "|" + id))
}
func decodeCursor(scope, raw string) (*pos, bool) {
b, err := base64.RawURLEncoding.DecodeString(raw)
if err != nil {
return nil, false
}
parts := strings.Split(string(b), "|")
if len(parts) != 3 || parts[0] != scope || parts[1] == "" || parts[2] == "" {
return nil, false
}
// Непустые строки — не значит валидные. ts должен быть настоящей меткой
// времени нашего формата, id — настоящим UUID: без этого структурно
// похожий, но мусорный курсор тихо дал бы пустую страницу вместо 400.
if _, err := time.Parse(tsLayout, parts[1]); err != nil {
return nil, false
}
if !uuidRe.MatchString(parts[2]) {
return nil, false
}
return &pos{ts: parts[1], id: parts[2]}, true
}
func (s *Store) AddMessageIdempotent(parent context.Context, userID, chatID, key, body string) (Message, error) {
ctx, cancel := context.WithTimeout(parent, 8*time.Second)
defer cancel()
tx, err := s.db.Begin(ctx)
if err != nil {
return Message{}, err
}
defer tx.Rollback(ctx)
var member bool
if err = tx.QueryRow(ctx, `SELECT EXISTS(SELECT 1 FROM chat_members WHERE chat_id=$1 AND user_id=$2)`, chatID, userID).Scan(&member); err != nil {
return Message{}, err
}
if !member {
return Message{}, errNotFound
}
// The request fingerprint is canonical for lab3: text plus the normalized empty attachment list.
fingerprint := body
var existingID *string
var oldFingerprint string
err = tx.QueryRow(ctx, `INSERT INTO message_idempotency (user_id,chat_id,key,body_fingerprint,message_id,expires_at)
VALUES ($1,$2,$3,$4,NULL,now()+interval '24 hours')
ON CONFLICT (user_id,chat_id,key) DO UPDATE SET key=EXCLUDED.key
RETURNING message_id,body_fingerprint`, userID, chatID, key, fingerprint).Scan(&existingID, &oldFingerprint)
if err != nil {
return Message{}, err
}
if oldFingerprint != fingerprint {
return Message{}, errConflict
}
if existingID != nil {
var m Message
var t time.Time
err = tx.QueryRow(ctx, `SELECT id,chat_id,sender_id,text,created_at FROM messages WHERE id=$1`, *existingID).Scan(&m.ID, &m.ChatID, &m.SenderID, &m.Text, &t)
if err != nil {
return Message{}, err
}
m.CreatedAt = formatTS(t)
if err = tx.Commit(ctx); err != nil {
return Message{}, err
}
return m, nil
}
m := Message{ID: newUUID(), ChatID: chatID, SenderID: userID, Text: body}
var t time.Time
err = tx.QueryRow(ctx, `INSERT INTO messages(id,chat_id,sender_id,text,created_at) VALUES($1,$2,$3,$4,clock_timestamp()) RETURNING created_at`, m.ID, chatID, userID, body).Scan(&t)
if err != nil {
return Message{}, err
}
m.CreatedAt = formatTS(t)
_, err = tx.Exec(ctx, `UPDATE message_idempotency SET message_id=$4 WHERE user_id=$1 AND chat_id=$2 AND key=$3`, userID, chatID, key, m.ID)
if err != nil {
return Message{}, err
}
if err = tx.Commit(ctx); err != nil {
return Message{}, err
}
return m, nil
}