lab2: fix review round 2 — cache versioning, UUID normalization, cursor validation, ready deps
Skeleton contracts / contracts (pull_request) Canceled after 0s

This commit is contained in:
2026-10-10 07:46:39 +03:00
parent 40f260612f
commit 6e3515d71b
8 changed files with 160 additions and 57 deletions
+6 -6
View File
@@ -1,7 +1,7 @@
Limit (cost=0.29..4.45 rows=50 width=64) (actual time=0.030..0.039 rows=50 loops=1)
Buffers: shared hit=3
Limit (cost=0.29..77.21 rows=50 width=64) (actual time=0.284..0.443 rows=50 loops=1)
Buffers: shared hit=1 read=3
-> Index Scan using messages_chat_created_id_idx on messages
Index Cond: (chat_id = '...'::uuid)
Buffers: shared hit=3
Planning Time: 0.560 ms
Execution Time: 0.069 ms
Index Cond: ((chat_id = 'aa29af3d-b946-4358-b7e6-eb6aedaf1ee0'::uuid) AND (ROW(created_at, id) > ROW('1970-01-01 00:00:00+00'::timestamp with time zone, '00000000-0000-0000-0000-000000000000'::uuid)))
Buffers: shared hit=1 read=3
Planning Time: 0.762 ms
Execution Time: 0.496 ms
+1 -1
View File
@@ -1,6 +1,6 @@
=== /health/ready with postgres stopped ===
HTTP/1.1 503 Service Unavailable
{"error":{"code":"unavailable","message":"Сервис недоступен","request_id":"..."}}
{"error":{"code":"unavailable","message":"Сервис недоступен","request_id":"4f7910a29991bfebaa3aa40f"}}
=== /health/ready after postgres start ===
HTTP/1.1 200 OK
+34 -3
View File
@@ -4,6 +4,7 @@ import (
"context"
"encoding/json"
"fmt"
"log/slog"
"time"
"github.com/redis/go-redis/v9"
@@ -28,6 +29,29 @@ func cacheKey(chatID, cursor string, limit int) string {
return fmt.Sprintf("messages:%s:%s:%d", chatID, cursor, limit)
}
func versionKey(chatID string) string {
return "chat_version:" + chatID
}
// GetVersion возвращает текущую версию чата. 0, если ключа нет.
func (c *MessageCache) GetVersion(ctx context.Context, chatID string) int64 {
v, err := c.client.Get(ctx, versionKey(chatID)).Int64()
if err != nil {
return 0
}
return v
}
// IncrVersion увеличивает версию чата. Используется в Send для инвалидации.
func (c *MessageCache) IncrVersion(ctx context.Context, chatID string) int64 {
v, err := c.client.Incr(ctx, versionKey(chatID)).Result()
if err != nil {
slog.Warn("redis incr version failed", "chat_id", chatID, "err", err)
return 0
}
return v
}
func (c *MessageCache) Get(ctx context.Context, chatID, cursor string, limit int) ([]*domain.Message, string, bool) {
raw, err := c.client.Get(ctx, cacheKey(chatID, cursor, limit)).Bytes()
if err != nil {
@@ -42,11 +66,18 @@ func (c *MessageCache) Get(ctx context.Context, chatID, cursor string, limit int
func (c *MessageCache) Set(ctx context.Context, chatID, cursor string, limit int, items []*domain.Message, next string) {
e := cacheEntry{Items: items, NextCursor: next}
raw, _ := json.Marshal(e)
_ = c.client.Set(ctx, cacheKey(chatID, cursor, limit), raw, 30*time.Second).Err()
raw, err := json.Marshal(e)
if err != nil {
slog.Warn("marshal cache entry failed", "err", err)
return
}
if err := c.client.Set(ctx, cacheKey(chatID, cursor, limit), raw, 30*time.Second).Err(); err != nil {
// Redis недоступен — не падаем, работаем без кэша.
slog.Warn("redis set failed", "chat_id", chatID, "err", err)
}
}
// Invalidate удаляет все ключи для чата через SCAN (безопасно на больших объёмах).
// Invalidate удаляет все ключи messages:{chatID}:* через SCAN.
func (c *MessageCache) Invalidate(ctx context.Context, chatID string) error {
pattern := fmt.Sprintf("messages:%s:*", chatID)
iter := c.client.Scan(ctx, 0, pattern, 100).Iterator()
+17 -3
View File
@@ -28,16 +28,27 @@ func (s *ChatService) Create(ctx context.Context, callerID, title string, member
return nil, ErrInvalidInput
}
// Нормализация UUID: убираем разницу регистра.
normalized := make([]string, 0, len(memberIDs))
seen := make(map[string]struct{}, len(memberIDs))
callerFound := false
callerParsed, err := uuid.Parse(callerID)
if err != nil {
return nil, ErrInvalidInput
}
callerID = callerParsed.String()
for _, id := range memberIDs {
if _, err := uuid.Parse(id); err != nil {
parsed, err := uuid.Parse(id)
if err != nil {
return nil, ErrInvalidInput
}
id = parsed.String()
if _, dup := seen[id]; dup {
return nil, ErrInvalidInput
}
seen[id] = struct{}{}
normalized = append(normalized, id)
if id == callerID {
callerFound = true
}
@@ -58,7 +69,7 @@ func (s *ChatService) Create(ctx context.Context, callerID, title string, member
c := &domain.Chat{
ID: newID(),
Title: title,
MemberIDs: memberIDs,
MemberIDs: normalized,
CreatedAt: nowUTC(),
}
if err := s.chats.Create(ctx, c); err != nil {
@@ -68,9 +79,12 @@ func (s *ChatService) Create(ctx context.Context, callerID, title string, member
}
func (s *ChatService) Get(ctx context.Context, callerID, chatID string) (*domain.Chat, error) {
if _, err := uuid.Parse(chatID); err != nil {
parsed, err := uuid.Parse(chatID)
if err != nil {
return nil, ErrInvalidInput
}
chatID = parsed.String()
ok, err := s.chats.IsMember(ctx, chatID, callerID)
if err != nil {
if errors.Is(err, repository.ErrNotFound) {
+12 -3
View File
@@ -4,27 +4,36 @@ import (
"encoding/base64"
"strings"
"time"
"github.com/google/uuid"
)
// encodeCursor кодирует (scope, created_at, id) в base64.
func encodeCursor(scope string, createdAt time.Time, id string) string {
raw := scope + "|" + createdAt.UTC().Format(time.RFC3339Nano) + "|" + id
return base64.RawURLEncoding.EncodeToString([]byte(raw))
}
// decodeCursor декодирует и проверяет scope.
func decodeCursor(cursor, expectedScope string) (time.Time, string, error) {
raw, err := base64.RawURLEncoding.DecodeString(cursor)
if err != nil {
return time.Time{}, "", ErrInvalidInput
}
parts := strings.SplitN(string(raw), "|", 3)
if len(parts) != 3 || parts[0] != expectedScope {
if len(parts) != 3 {
return time.Time{}, "", ErrInvalidInput
}
if _, err := uuid.Parse(parts[0]); err != nil {
return time.Time{}, "", ErrInvalidInput
}
if parts[0] != expectedScope {
return time.Time{}, "", ErrInvalidInput
}
t, err := time.Parse(time.RFC3339Nano, parts[1])
if err != nil {
return time.Time{}, "", ErrInvalidInput
}
if _, err := uuid.Parse(parts[2]); err != nil {
return time.Time{}, "", ErrInvalidInput
}
return t, parts[2], nil
}
+24 -4
View File
@@ -23,9 +23,12 @@ func NewMessageService(messages repository.MessageRepository, chats repository.C
}
func (s *MessageService) Send(ctx context.Context, senderID, chatID, text string) (*domain.Message, error) {
if _, err := uuid.Parse(chatID); err != nil {
parsed, err := uuid.Parse(chatID)
if err != nil {
return nil, ErrInvalidInput
}
chatID = parsed.String()
if !validateText(text) {
return nil, ErrInvalidInput
}
@@ -50,16 +53,23 @@ func (s *MessageService) Send(ctx context.Context, senderID, chatID, text string
if err := s.messages.Create(ctx, m); err != nil {
return nil, err
}
// Инвалидация через увеличение версии чата + удаление старых ключей.
// Ошибки Redis игнорируем — при недоступности кэш просто устареет по TTL.
if s.cache != nil {
s.cache.IncrVersion(ctx, chatID)
_ = s.cache.Invalidate(ctx, chatID)
}
return m, nil
}
func (s *MessageService) List(ctx context.Context, callerID, chatID, cursor string, limit int) ([]*domain.Message, string, error) {
if _, err := uuid.Parse(chatID); err != nil {
parsed, err := uuid.Parse(chatID)
if err != nil {
return nil, "", ErrInvalidInput
}
chatID = parsed.String()
if limit < 1 || limit > 100 {
return nil, "", ErrInvalidInput
}
@@ -75,9 +85,15 @@ func (s *MessageService) List(ctx context.Context, callerID, chatID, cursor stri
return nil, "", ErrNotFound
}
// Проверяем кэш. Если версия изменилась между GetVersion и Get — не используем.
var versionBefore int64
if s.cache != nil {
versionBefore = s.cache.GetVersion(ctx, chatID)
if items, next, hit := s.cache.Get(ctx, chatID, cursor, limit); hit {
return items, next, nil
// Проверяем, что версия не изменилась с момента Set
if s.cache.GetVersion(ctx, chatID) == versionBefore {
return items, next, nil
}
}
}
@@ -106,8 +122,12 @@ func (s *MessageService) List(ctx context.Context, callerID, chatID, cursor stri
next = encodeCursor(chatID, last.CreatedAt, last.ID)
}
// Записываем в кэш только если версия не изменилась за время чтения БД.
if s.cache != nil {
s.cache.Set(ctx, chatID, cursor, limit, items, next)
versionAfter := s.cache.GetVersion(ctx, chatID)
if versionBefore == versionAfter {
s.cache.Set(ctx, chatID, cursor, limit, items, next)
}
}
return items, next, nil
}
+35
View File
@@ -0,0 +1,35 @@
#!/bin/bash
set -eu
BASE=http://localhost:8080
CHAT_ID=${1:?usage: $0 <chat_id> <token>}
TOKEN=${2:?usage: $0 <chat_id> <token>}
echo "=== SQL/latency measurement ==="
echo "Chat: $CHAT_ID"
# Сброс pg_stat_statements
docker compose exec -T postgres psql -U messenger -d messenger -c \
"CREATE EXTENSION IF NOT EXISTS pg_stat_statements;" > /dev/null
docker compose exec -T postgres psql -U messenger -d messenger -c \
"SELECT pg_stat_statements_reset();" > /dev/null
echo "--- Run WITH cache ---"
hey -n 5000 -c 100 -H "Authorization: Bearer $TOKEN" \
"$BASE/api/v1/chats/$CHAT_ID/messages?limit=50" > /tmp/cache_on.txt
SQL_ON=$(docker compose exec -T postgres psql -U messenger -d messenger -t -A -c \
"SELECT COALESCE(SUM(calls),0) FROM pg_stat_statements WHERE query LIKE '%FROM messages%';")
echo "RPS (cache ON):"
grep -E "Requests/sec" /tmp/cache_on.txt
echo "p95 (cache ON):"
grep -E "95%% in" /tmp/cache_on.txt
echo "SQL queries (cache ON): $SQL_ON"
echo ""
echo "--- Run WITHOUT cache (manually flush Redis before each request is impractical) ---"
echo "To measure without cache: stop Redis, run hey, then start Redis."
echo " docker compose stop redis"
echo " hey -n 5000 -c 100 ..."
echo " docker compose start redis"
+31 -37
View File
@@ -4,58 +4,52 @@ set -eu
BASE=http://localhost:8080
CHAT_ID=aa29af3d-b946-4358-b7e6-eb6aedaf1ee0
# 1. СНАЧАЛА чистим Redis (до логина!)
# FLUSHALL до логина — иначе сессия удалится
docker compose exec redis redis-cli FLUSHALL > /dev/null
echo "Redis flushed"
# 2. Теперь логинимся — сессия создаётся и живёт
CRED=$(printf "explainuser:Example-only-not-a-real-secret-123" | base64 -w0)
TOKEN=$(curl -s -X POST "$BASE/api/v1/auth/sessions" -H "Authorization: Basic $CRED" \
| python3 -c "import sys,json; sys.stdout.write(json.load(sys.stdin)['token'])")
echo "TOKEN=[$TOKEN]"
# 3. Проверка, что токен работает
CODE=$(curl -s -o /dev/null -w "%{http_code}" "$BASE/api/v1/chats/$CHAT_ID/messages?limit=50" -H "Authorization: Bearer $TOKEN")
CODE=$(curl -s -o /dev/null -w "%{http_code}" "$BASE/api/v1/chats/$CHAT_ID/messages?limit=50" \
-H "Authorization: Bearer $TOKEN")
echo "/messages status: $CODE"
if [ "$CODE" != "200" ]; then
echo "STOP: /messages returned $CODE"
exit 1
fi
# === BUG MODE ===
curl -s -X POST "$BASE/debug/cache/off" > /dev/null
echo "=== BUG MODE (invalidation OFF) ==="
# === СИМУЛЯЦИЯ STALE READ ===
# Прямо кладём в кэш устаревшую страницу (в обход API).
echo ""
echo "=== SIMULATE STALE READ ==="
docker compose exec redis redis-cli SET "messages:$CHAT_ID::50" \
'{"items":[{"id":"11111111-1111-4111-8111-111111111111","chat_id":"'$CHAT_ID'","sender_id":"11111111-1111-4111-8111-111111111111","text":"STALE_FROM_CACHE","created_at":"2020-01-01T00:00:00Z"}],"next_cursor":""}' > /dev/null
echo "Manually injected old page into cache"
curl -s "$BASE/api/v1/chats/$CHAT_ID/messages?limit=50" -H "Authorization: Bearer $TOKEN" > /tmp/read1.json
echo "Read1 items: $(python3 -c 'import json; print(len(json.load(open("/tmp/read1.json"))["items"]))')"
# GET должен вернуть старую страницу
curl -s "$BASE/api/v1/chats/$CHAT_ID/messages?limit=50" -H "Authorization: Bearer $TOKEN" > /tmp/stale.json
if grep -q "STALE_FROM_CACHE" /tmp/stale.json; then
echo "READ: STALE_FROM_CACHE found → STALE READ CONFIRMED"
else
echo "READ: cache was not used (unexpected)"
fi
echo "Redis cache keys:"
# === ЗАЩИТА: Send инвалидирует кэш ===
echo ""
echo "=== SEND INVALIDATES CACHE ==="
curl -s -X POST "$BASE/api/v1/chats/$CHAT_ID/messages" \
-H "Content-Type: application/json" -H "Authorization: Bearer $TOKEN" \
-d '{"text":"FIXED_MARKER"}' > /dev/null
echo "Sent FIXED_MARKER"
echo "Cache keys after Send:"
docker compose exec redis redis-cli KEYS 'messages:*'
curl -s -X POST "$BASE/api/v1/chats/$CHAT_ID/messages" \
-H "Content-Type: application/json" -H "Authorization: Bearer $TOKEN" \
-d '{"text":"STALE_MARKER_XYZ"}' > /dev/null
DB=$(docker compose exec -T postgres psql -U messenger -d messenger -t -A \
-c "SELECT COUNT(*) FROM messages WHERE text='STALE_MARKER_XYZ';")
echo "DB STALE_MARKER_XYZ: $DB"
curl -s "$BASE/api/v1/chats/$CHAT_ID/messages?limit=50" -H "Authorization: Bearer $TOKEN" > /tmp/read2.json
echo "Read2 STALE count: $(grep -c STALE_MARKER_XYZ /tmp/read2.json)"
# === FIXED MODE ===
curl -s -X POST "$BASE/debug/cache/on" > /dev/null
echo "=== FIXED MODE (invalidation ON) ==="
curl -s -X POST "$BASE/api/v1/chats/$CHAT_ID/messages" \
-H "Content-Type: application/json" -H "Authorization: Bearer $TOKEN" \
-d '{"text":"FIXED_MARKER_ABC"}' > /dev/null
curl -s "$BASE/api/v1/chats/$CHAT_ID/messages?limit=50" -H "Authorization: Bearer $TOKEN" > /tmp/read3.json
echo "Read3 FIXED count: $(grep -c FIXED_MARKER_ABC /tmp/read3.json)"
echo ""
echo "=== SUMMARY ==="
echo "DB STALE: $DB"
echo "Read2 (bug): $(grep -c STALE_MARKER_XYZ /tmp/read2.json)"
echo "Read3 (fixed): $(grep -c FIXED_MARKER_ABC /tmp/read3.json)"
# GET должен вернуть свежие данные из БД
curl -s "$BASE/api/v1/chats/$CHAT_ID/messages?limit=50" -H "Authorization: Bearer $TOKEN" > /tmp/fixed.json
if grep -q "FIXED_MARKER" /tmp/fixed.json; then
echo "READ: FIXED_MARKER found → CACHE INVALIDATED, fresh data"
fi