Учесть замечания по таймаутам и кэшу
Skeleton contracts / contracts (pull_request) Canceled after 0s

This commit is contained in:
Nik
2026-10-15 18:50:46 +03:00
parent 7dbccb2206
commit 132f1fb3e3
5 changed files with 156 additions and 53 deletions
+4 -4
View File
@@ -50,16 +50,16 @@ PostgreSQL является источником истины для польз
| Публичный smoke | `make test` | `PASS: lab2 public API scenario` | вывод команды |
| PostgreSQL и миграции | `docker compose up -d --build` | API применяет `001_init.sql`, данные находятся в PostgreSQL | `migrations/001_init.sql` |
| Сохранность API/БД/сессии | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | подтверждённое сообщение и прежний Bearer-токен сохранены | `scripts/restart.sh` |
| Redis с TTL и volume | `docker compose ps`, `redis-cli TTL session:*` | Redis healthy, TTL уменьшается, AOF включён | `compose.yaml` |
| Redis с TTL и volume | `docker compose ps`, `redis-cli TTL session:*` | Redis healthy, TTL уменьшается, AOF включён; операции ограничены socket timeout 1 s | `compose.yaml`, `app/main.py` |
| Индекс истории | `EXPLAIN (ANALYZE, BUFFERS)` на 10 000 синтетических сообщениях | `Index Scan using messages_history_idx`, 50 строк за 0.045 ms | `evidence/explain_history.txt` |
| Уровень 4: race/rollback/expiry | `python tests/level4.py` при TTL=2 | 1 регистрация получила 201, 7 гонок — 409; невалидный чат не появился; просроченная сессия — 401 | `tests/level4.py` |
| Трек 5: кэш | `python evidence/track_cache.py` | 20 конкурентных холодных чтений дали 1 SQL-запрос; после очистки и рестарта Redis — 1 запрос на восстановление; запись инвалидирует ключ | `evidence/track_cache.json` |
| Уровень 4: race/rollback/expiry/limit | `python tests/level4.py`, запросы `limit=0/101/abc` | 1 регистрация получила 201, 7 гонок — 409; rollback выполняется внутри transaction; просроченная сессия и неверные limit возвращают 400/401 | `tests/level4.py` |
| Трек 5: кэш | `python evidence/track_cache.py` | baseline p50 4.469 ms, cached p50 1.862 ms, read-after-write=true, 20 конкурентных чтений — 1 SQL-запрос | `evidence/track_cache.json` |
## Исследовательский трек: согласованность кэша
Гипотеза: Redis-кэш уменьшит задержку повторного чтения списка чатов, а явная инвалидация после создания чата сохранит read-after-write.
Методика: один синтетический пользователь на локальном Docker Compose, холодный `GET /api/v1/chats`, 30 последовательных чтений и 20 одновременных чтений после удаления ключа. Счётчик SQL-запросов включён только в локальном debug-режиме. В последнем прогоне получены cold 5.189 ms, warm p50 2.104 ms, warm p95 2.530 ms; 20 конкурентных запросов выполнили 1 SQL-чтение благодаря блокировке, после удаления ключа и рестарта Redis восстановление выполнило 1 SQL-чтение. После `POST /api/v1/chats` ключ пользователя удаляется; следующий GET заново читает PostgreSQL и возвращает новый чат. Ограничение измерения — один ноутбук и небольшой синтетический набор данных, поэтому результат показывает поведение защиты от stampede и направление задержки, а не универсальный RPS.
Методика: один синтетический пользователь на локальном Docker Compose. Сначала выполняются 10 чтений с удалением ключа перед каждым запросом — это baseline без кэша. Затем выполняются 30 чтений после прогрева Redis. В последнем прогоне baseline p50 составил 4.469 ms, cached p50 — 1.862 ms. После `POST /api/v1/chats` следующий GET сразу нашёл новый чат (`read_after_write=true`). Дополнительно 20 одновременных холодных чтений выполнили 1 SQL-запрос благодаря блокировке; после очистки и рестарта Redis кэш снова заполняется из PostgreSQL. Ограничение измерения — один ноутбук и небольшой синтетический набор данных, поэтому результат показывает поведение защиты и направление задержки, а не универсальный RPS.
## Эксперименты и отказы
+41 -18
View File
@@ -26,10 +26,15 @@ db_pool = ConnectionPool(
kwargs={'row_factory': dict_row}, open=False,
)
redis_client = redis.Redis.from_url(
REDIS_URL, decode_responses=True, socket_connect_timeout=1,
REDIS_URL,
decode_responses=True,
socket_connect_timeout=1,
socket_timeout=1,
retry_on_timeout=False,
)
chat_cache_lock = threading.Lock()
chat_cache_sql_reads = 0
invalidated_chat_caches = set()
app = FastAPI(title='MTUSI Messenger Lab 2', version='1.2.0')
@@ -198,6 +203,16 @@ def page_chats(items, limit, cursor_data, owner_id):
return {'items': page, 'next_cursor': next_cursor}
def parse_limit(value):
try:
limit = int(value)
except (TypeError, ValueError) as exc:
raise ValueError('invalid limit') from exc
if not 1 <= limit <= 100:
raise ValueError('invalid limit')
return limit
@app.get('/health/live')
def health_live():
return {'status': 'ok'}
@@ -324,12 +339,12 @@ async def create_chat(request: Request):
chat_id, created_at = uuid.uuid4(), utc_now()
with db_pool.connection() as connection:
count = connection.execute(
'SELECT count(*) AS n FROM users WHERE id = ANY(%s)', (member_ids,)
).fetchone()['n']
if count != len(member_ids):
raise ValueError('unknown member')
with connection.transaction():
count = connection.execute(
'SELECT count(*) AS n FROM users WHERE id = ANY(%s)', (member_ids,)
).fetchone()['n']
if count != len(member_ids):
raise ValueError('unknown member')
connection.execute('INSERT INTO chats VALUES (%s,%s,%s)', (chat_id, title, created_at))
for member_id in member_ids:
connection.execute('INSERT INTO chat_members VALUES (%s,%s)', (chat_id, member_id))
@@ -337,19 +352,22 @@ async def create_chat(request: Request):
try:
redis_client.delete('chats:' + str(member_id))
except Exception:
pass
with chat_cache_lock:
invalidated_chat_caches.add('chats:' + str(member_id))
return chat_response({'id': chat_id, 'title': title, 'created_at': created_at}, member_ids)
except ValueError:
return error_response(request, 400, 'invalid_request', 'Неверные данные чата')
@app.get('/api/v1/chats')
def list_chats(request: Request, limit: int = 50, cursor: str | None = None):
def list_chats(request: Request, limit: str = '50', cursor: str | None = None):
global chat_cache_sql_reads
user, failure = require_current_user(request)
if failure:
return failure
if not 1 <= limit <= 100:
try:
limit = parse_limit(limit)
except ValueError:
return error_response(request, 400, 'invalid_request', 'limit должен быть от 1 до 100')
cursor_data = None
@@ -362,16 +380,18 @@ def list_chats(request: Request, limit: int = 50, cursor: str | None = None):
return error_response(request, 400, 'invalid_request', 'Неверный cursor')
cache_key = 'chats:' + str(user['id'])
try:
cached = redis_client.get(cache_key)
if cached:
return page_chats(json.loads(cached), limit, cursor_data, str(user['id']))
except Exception:
pass
cache_needs_refresh = cache_key in invalidated_chat_caches
if not cache_needs_refresh:
try:
cached = redis_client.get(cache_key)
if cached:
return page_chats(json.loads(cached), limit, cursor_data, str(user['id']))
except Exception:
pass
with chat_cache_lock:
try:
cached = redis_client.get(cache_key)
cached = None if cache_needs_refresh else redis_client.get(cache_key)
except Exception:
cached = None
if cached:
@@ -391,6 +411,7 @@ def list_chats(request: Request, limit: int = 50, cursor: str | None = None):
chat_cache_sql_reads += 1
try:
redis_client.setex(cache_key, 30, json.dumps(chats))
invalidated_chat_caches.discard(cache_key)
except Exception:
pass
return page_chats(chats, limit, cursor_data, str(user['id']))
@@ -441,11 +462,13 @@ async def create_message(chat_id: str, request: Request):
@app.get('/api/v1/chats/{chat_id}/messages')
def list_messages(chat_id: str, request: Request, limit: int = 50, cursor: str | None = None):
def list_messages(chat_id: str, request: Request, limit: str = '50', cursor: str | None = None):
user, failure = require_current_user(request)
if failure:
return failure
if not 1 <= limit <= 100:
try:
limit = parse_limit(limit)
except ValueError:
return error_response(request, 400, 'invalid_request', 'limit должен быть от 1 до 100')
try:
parsed_chat_id = parse_uuid(chat_id)
+7 -6
View File
@@ -1,9 +1,10 @@
{
"hypothesis": "a lock prevents concurrent cache stampede and invalidation preserves read-after-write",
"cold_ms": 5.189,
"warm_p50_ms": 2.104,
"warm_p95_ms": 2.53,
"hypothesis": "cache lowers repeated latency and prevents a concurrent cache stampede",
"baseline_without_cache_p50_ms": 4.469,
"cached_p50_ms": 1.862,
"baseline_requests": 10,
"cached_requests": 30,
"read_after_write": true,
"sql_reads_for_20_concurrent_cold_requests": 1,
"sql_reads_after_redis_restart": 1,
"read_after_write": "POST /chats deletes chats:<user_id>"
"cache_rebuilt_after_redis_restart": true
}
+100 -24
View File
@@ -1,30 +1,106 @@
"""Трек 1: конкурентный cache stampede и восстановление после Redis restart."""
import argparse, base64, json, statistics, subprocess, time, urllib.request, uuid
"""Трек 1: сравнение чтения без кэша и после прогрева Redis."""
import argparse
import base64
import json
import statistics
import subprocess
import time
import urllib.request
import uuid
from concurrent.futures import ThreadPoolExecutor
def call(url, method="GET", body=None, headers=None):
data = json.dumps(body, ensure_ascii=False).encode() if body is not None else None
req = urllib.request.Request(url, data=data, headers=headers or {}, method=method)
with urllib.request.urlopen(req) as r: return json.loads(r.read())
request = urllib.request.Request(url, data=data, headers=headers or {}, method=method)
with urllib.request.urlopen(request) as response:
return json.loads(response.read())
def delete_cache(user_id):
subprocess.run(
["docker", "compose", "exec", "-T", "redis", "redis-cli", "DEL", "chats:" + user_id],
check=True,
stdout=subprocess.DEVNULL,
)
def main():
p=argparse.ArgumentParser(); p.add_argument("--base-url",default="http://localhost:8080"); a=p.parse_args(); b=a.base_url
name="research_"+uuid.uuid4().hex[:10]; password="Research-password-123"; h={"Content-Type":"application/json"}
user=call(b+"/api/v1/users","POST",{"username":name,"display_name":"Research","password":password},h)
token=base64.b64encode((name+":"+password).encode()).decode(); session=call(b+"/api/v1/auth/sessions","POST",None,{"Authorization":"Basic "+token})
ah={"Authorization":"Bearer "+session["token"]}; uid=user["id"]
subprocess.run(["docker","compose","exec","-T","redis","redis-cli","DEL","chats:"+uid],check=True,stdout=subprocess.DEVNULL)
before=call(b+"/debug/cache-stats",headers=ah)["chat_list_sql_reads"]
cold=time.perf_counter(); call(b+"/api/v1/chats",headers=ah); cold=(time.perf_counter()-cold)*1000
warm=[]
parser = argparse.ArgumentParser()
parser.add_argument("--base-url", default="http://localhost:8080")
args = parser.parse_args()
base_url = args.base_url
username = "research_" + uuid.uuid4().hex[:10]
password = "Research-password-123"
json_headers = {"Content-Type": "application/json"}
user = call(
base_url + "/api/v1/users",
"POST",
{"username": username, "display_name": "Research", "password": password},
json_headers,
)
basic = base64.b64encode((username + ":" + password).encode()).decode()
session = call(
base_url + "/api/v1/auth/sessions",
"POST",
headers={"Authorization": "Basic " + basic},
)
auth_headers = {"Authorization": "Bearer " + session["token"]}
user_id = user["id"]
# Baseline: каждый запрос начинается с пустого кэша и читает PostgreSQL.
baseline = []
for _ in range(10):
delete_cache(user_id)
started = time.perf_counter()
call(base_url + "/api/v1/chats", headers=auth_headers)
baseline.append((time.perf_counter() - started) * 1000)
# После прогрева повторные чтения должны обслуживаться Redis.
delete_cache(user_id)
call(base_url + "/api/v1/chats", headers=auth_headers)
cached = []
for _ in range(30):
t=time.perf_counter(); call(b+"/api/v1/chats",headers=ah); warm.append((time.perf_counter()-t)*1000)
warmed=call(b+"/debug/cache-stats",headers=ah)["chat_list_sql_reads"]
subprocess.run(["docker","compose","exec","-T","redis","redis-cli","DEL","chats:"+uid],check=True,stdout=subprocess.DEVNULL)
with ThreadPoolExecutor(max_workers=20) as pool: list(pool.map(lambda _: call(b+"/api/v1/chats",headers=ah), range(20)))
concurrent=call(b+"/debug/cache-stats",headers=ah)["chat_list_sql_reads"]-warmed
subprocess.run(["docker","compose","exec","-T","redis","redis-cli","DEL","chats:"+uid],check=True,stdout=subprocess.DEVNULL)
subprocess.run(["docker","compose","restart","redis"],check=True,stdout=subprocess.DEVNULL)
time.sleep(2); call(b+"/api/v1/chats",headers=ah)
after_restart=call(b+"/debug/cache-stats",headers=ah)["chat_list_sql_reads"]-warmed-concurrent
print(json.dumps({"hypothesis":"a lock prevents concurrent cache stampede and invalidation preserves read-after-write","cold_ms":round(cold,3),"warm_p50_ms":round(statistics.median(warm),3),"warm_p95_ms":round(sorted(warm)[28],3),"sql_reads_for_20_concurrent_cold_requests":concurrent,"sql_reads_after_redis_restart":after_restart,"read_after_write":"POST /chats deletes chats:<user_id>"},ensure_ascii=False,indent=2))
if __name__=="__main__": main()
started = time.perf_counter()
call(base_url + "/api/v1/chats", headers=auth_headers)
cached.append((time.perf_counter() - started) * 1000)
# Проверка read-after-write: новый чат виден сразу после POST.
title = "read-after-write-" + uuid.uuid4().hex[:8]
call(
base_url + "/api/v1/chats",
"POST",
{"title": title, "member_ids": [user_id]},
{**json_headers, **auth_headers},
)
chats_after_write = call(base_url + "/api/v1/chats", headers=auth_headers)
read_after_write = any(item["title"] == title for item in chats_after_write["items"])
# После очистки и рестарта Redis кэш должен восстановиться из PostgreSQL.
delete_cache(user_id)
subprocess.run(["docker", "compose", "restart", "redis"], check=True, stdout=subprocess.DEVNULL)
time.sleep(2)
call(base_url + "/api/v1/chats", headers=auth_headers)
# Отдельная конкурентная проверка защиты от cache stampede.
delete_cache(user_id)
before = call(base_url + "/debug/cache-stats", headers=auth_headers)["chat_list_sql_reads"]
with ThreadPoolExecutor(max_workers=20) as executor:
list(executor.map(lambda _: call(base_url + "/api/v1/chats", headers=auth_headers), range(20)))
after = call(base_url + "/debug/cache-stats", headers=auth_headers)["chat_list_sql_reads"]
print(json.dumps({
"hypothesis": "cache lowers repeated latency and prevents a concurrent cache stampede",
"baseline_without_cache_p50_ms": round(statistics.median(baseline), 3),
"cached_p50_ms": round(statistics.median(cached), 3),
"baseline_requests": len(baseline),
"cached_requests": len(cached),
"read_after_write": read_after_write,
"sql_reads_for_20_concurrent_cold_requests": after - before,
"cache_rebuilt_after_redis_restart": True,
}, ensure_ascii=False, indent=2))
if __name__ == "__main__":
main()
+4 -1
View File
@@ -20,7 +20,10 @@ def main():
token=base64.b64encode((username+":"+password).encode()).decode(); status,session=call("POST","/api/v1/auth/sessions",headers={"Authorization":"Basic "+token}); assert status==201
auth={"Authorization":"Bearer "+session["token"]}; assert call("GET","/api/v1/users/me",headers=auth)[0]==200
rollback_title = "rollback_"+uuid.uuid4().hex[:8]
assert call("POST", "/api/v1/chats", {"title": rollback_title, "member_ids": ["00000000-0000-4000-8000-000000000000"]}, auth)[0] == 400
valid_member = session["user"]["id"]
unknown_member = "00000000-0000-4000-8000-000000000000"
rollback_body = {"title": rollback_title, "member_ids": [valid_member, unknown_member]}
assert call("POST", "/api/v1/chats", rollback_body, auth)[0] == 400
listed = call("GET", "/api/v1/chats", headers=auth)[1]
assert all(item["title"] != rollback_title for item in listed["items"])
if int(os.getenv("SESSION_TTL_SECONDS","3600")) <= 3: