forked from mtusi2026/mtusi2026lab3
235 lines
7.1 KiB
Go
235 lines
7.1 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"crypto/sha256"
|
|
"database/sql"
|
|
"embed"
|
|
"encoding/hex"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"time"
|
|
|
|
"github.com/lib/pq"
|
|
"github.com/redis/go-redis/v9"
|
|
"mtusi2026lab3/models"
|
|
)
|
|
|
|
//go:embed migrations/*.sql
|
|
var migrations embed.FS
|
|
|
|
func verifySchema(ctx context.Context, db *sql.DB) error {
|
|
entries, err := migrations.ReadDir("migrations")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
for _, entry := range entries {
|
|
data, err := migrations.ReadFile("migrations/" + entry.Name())
|
|
if err != nil {
|
|
return err
|
|
}
|
|
sum := sha256.Sum256(data)
|
|
var checksum string
|
|
if err = db.QueryRowContext(ctx, `SELECT checksum FROM schema_migrations WHERE name=$1`, entry.Name()).Scan(&checksum); err != nil {
|
|
return err
|
|
}
|
|
if checksum != hex.EncodeToString(sum[:]) {
|
|
return fmt.Errorf("migration mismatch: %s", entry.Name())
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type store struct {
|
|
db *sql.DB
|
|
cache *redis.Client
|
|
metrics *cacheMetrics
|
|
chatCache bool
|
|
chatMetrics *cacheMetrics
|
|
}
|
|
|
|
// A transaction-scoped advisory lock serializes migrations across starting API processes.
|
|
func migrate(ctx context.Context, db *sql.DB) error {
|
|
tx, err := db.BeginTx(ctx, nil)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer tx.Rollback()
|
|
if _, err = tx.ExecContext(ctx, `SELECT pg_advisory_xact_lock(202602)`); err != nil {
|
|
return err
|
|
}
|
|
if _, err = tx.ExecContext(ctx, `CREATE TABLE IF NOT EXISTS schema_migrations (name text PRIMARY KEY, checksum text NOT NULL, applied_at timestamptz NOT NULL DEFAULT clock_timestamp())`); err != nil {
|
|
return err
|
|
}
|
|
entries, err := migrations.ReadDir("migrations")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
for _, entry := range entries {
|
|
data, err := migrations.ReadFile("migrations/" + entry.Name())
|
|
if err != nil {
|
|
return err
|
|
}
|
|
sum := sha256.Sum256(data)
|
|
checksum := hex.EncodeToString(sum[:])
|
|
var previous string
|
|
err = tx.QueryRowContext(ctx, `SELECT checksum FROM schema_migrations WHERE name=$1`, entry.Name()).Scan(&previous)
|
|
if err == nil {
|
|
if previous != checksum {
|
|
return fmt.Errorf("changed migration %s", entry.Name())
|
|
}
|
|
continue
|
|
}
|
|
if !errors.Is(err, sql.ErrNoRows) {
|
|
return err
|
|
}
|
|
if _, err = tx.ExecContext(ctx, string(data)); err != nil {
|
|
return err
|
|
}
|
|
if _, err = tx.ExecContext(ctx, `INSERT INTO schema_migrations(name,checksum) VALUES($1,$2)`, entry.Name(), checksum); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return tx.Commit()
|
|
}
|
|
|
|
func scanUser(row interface{ Scan(...any) error }) (models.User, error) {
|
|
var u models.User
|
|
err := row.Scan(&u.ID, &u.Username, &u.DisplayName, &u.CreatedAt)
|
|
u.CreatedAt = u.CreatedAt.UTC()
|
|
return u, err
|
|
}
|
|
|
|
func (s *store) user(ctx context.Context, id models.UUID) (models.User, error) {
|
|
key := "profile:v1:" + string(id)
|
|
if s.cache != nil {
|
|
cacheCtx, cancel := context.WithTimeout(ctx, 150*time.Millisecond)
|
|
data, err := s.cache.Get(cacheCtx, key).Bytes()
|
|
cancel()
|
|
var u models.User
|
|
if err == nil && json.Unmarshal(data, &u) == nil && u.ID == id {
|
|
s.metrics.hits.Add(1)
|
|
return u, nil
|
|
}
|
|
s.metrics.misses.Add(1)
|
|
if err != nil && !errors.Is(err, redis.Nil) {
|
|
s.metrics.failures.Add(1)
|
|
}
|
|
}
|
|
u, err := scanUser(s.db.QueryRowContext(ctx, `SELECT id,username,display_name,created_at FROM users WHERE id=$1`, id))
|
|
if err == nil && s.cache != nil {
|
|
data, _ := json.Marshal(u)
|
|
cacheCtx, cancel := context.WithTimeout(ctx, 150*time.Millisecond)
|
|
if s.cache.Set(cacheCtx, key, data, 5*time.Minute).Err() != nil {
|
|
s.metrics.failures.Add(1)
|
|
}
|
|
cancel()
|
|
}
|
|
return u, err
|
|
}
|
|
|
|
func (s *store) createChat(ctx context.Context, title string, members []models.UUID) (models.Chat, error) {
|
|
tx, err := s.db.BeginTx(ctx, nil)
|
|
if err != nil {
|
|
return models.Chat{}, err
|
|
}
|
|
defer tx.Rollback()
|
|
chat := models.Chat{ID: models.UUID(newID()), Title: title, MemberIDs: members}
|
|
err = tx.QueryRowContext(ctx, `INSERT INTO chats(id,title) VALUES($1,$2) RETURNING created_at`, chat.ID, title).Scan(&chat.CreatedAt)
|
|
if err != nil {
|
|
return chat, err
|
|
}
|
|
for i, id := range members {
|
|
if _, err = tx.ExecContext(ctx, `INSERT INTO chat_members(chat_id,user_id,position) VALUES($1,$2,$3)`, chat.ID, id, i); err != nil {
|
|
return chat, err
|
|
}
|
|
}
|
|
err = tx.Commit()
|
|
chat.CreatedAt = chat.CreatedAt.UTC()
|
|
return chat, err
|
|
}
|
|
|
|
func scanChat(row interface{ Scan(...any) error }) (models.Chat, error) {
|
|
var c models.Chat
|
|
var members pq.StringArray
|
|
err := row.Scan(&c.ID, &c.Title, &c.CreatedAt, &members)
|
|
c.CreatedAt = c.CreatedAt.UTC()
|
|
c.MemberIDs = make([]models.UUID, len(members))
|
|
for i, m := range members {
|
|
c.MemberIDs[i] = models.UUID(m)
|
|
}
|
|
return c, err
|
|
}
|
|
|
|
const chatColumns = `c.id,c.title,c.created_at,ARRAY(SELECT user_id::text FROM chat_members WHERE chat_id=c.id ORDER BY position)`
|
|
|
|
func (s *store) chat(ctx context.Context, id, user models.UUID) (models.Chat, error) {
|
|
// Chat metadata/membership are immutable in the mandatory API. Cache only
|
|
// positive access scoped by user; sessions are ALWAYS checked in PostgreSQL.
|
|
key := "chat:v1:" + string(id) + ":" + string(user)
|
|
if s.chatCache && s.cache != nil {
|
|
cacheCtx, cancel := context.WithTimeout(ctx, 150*time.Millisecond)
|
|
data, err := s.cache.Get(cacheCtx, key).Bytes()
|
|
cancel()
|
|
var chat models.Chat
|
|
if err == nil && json.Unmarshal(data, &chat) == nil && chat.ID == id {
|
|
for _, member := range chat.MemberIDs {
|
|
if member == user {
|
|
s.chatMetrics.hits.Add(1)
|
|
return chat, nil
|
|
}
|
|
}
|
|
}
|
|
s.chatMetrics.misses.Add(1)
|
|
if err != nil && !errors.Is(err, redis.Nil) {
|
|
s.chatMetrics.failures.Add(1)
|
|
}
|
|
}
|
|
chat, err := scanChat(s.db.QueryRowContext(ctx, `SELECT `+chatColumns+` FROM chats c WHERE c.id=$1 AND EXISTS(SELECT 1 FROM chat_members WHERE chat_id=c.id AND user_id=$2)`, id, user))
|
|
if err == nil && s.chatCache && s.cache != nil {
|
|
data, _ := json.Marshal(chat)
|
|
cacheCtx, cancel := context.WithTimeout(ctx, 150*time.Millisecond)
|
|
if s.cache.Set(cacheCtx, key, data, 5*time.Minute).Err() != nil {
|
|
s.chatMetrics.failures.Add(1)
|
|
}
|
|
cancel()
|
|
}
|
|
return chat, err
|
|
}
|
|
|
|
func (s *store) chats(ctx context.Context, user models.UUID, p cursor, limit int) ([]models.Chat, error) {
|
|
rows, err := s.db.QueryContext(ctx, `SELECT `+chatColumns+` FROM chats c WHERE EXISTS(SELECT 1 FROM chat_members WHERE chat_id=c.id AND user_id=$1) AND (c.created_at,c.id)>($2,$3::uuid) ORDER BY c.created_at,c.id LIMIT $4`, user, p.CreatedAt, p.ID, limit+1)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []models.Chat{}
|
|
for rows.Next() {
|
|
c, err := scanChat(rows)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, c)
|
|
}
|
|
return items, rows.Err()
|
|
}
|
|
|
|
func (s *store) messages(ctx context.Context, chat models.UUID, p cursor, limit int) ([]models.Message, error) {
|
|
rows, err := s.db.QueryContext(ctx, `SELECT id,chat_id,sender_id,text,created_at FROM messages WHERE chat_id=$1 AND (created_at,id)>($2,$3::uuid) ORDER BY created_at,id LIMIT $4`, chat, p.CreatedAt, p.ID, limit+1)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []models.Message{}
|
|
for rows.Next() {
|
|
var m models.Message
|
|
if err = rows.Scan(&m.ID, &m.ChatID, &m.SenderID, &m.Text, &m.CreatedAt); err != nil {
|
|
return nil, err
|
|
}
|
|
m.CreatedAt = m.CreatedAt.UTC()
|
|
items = append(items, m)
|
|
}
|
|
return items, rows.Err()
|
|
}
|