From 132f1fb3e37d99616cd03e5626765ee6ab9acb21 Mon Sep 17 00:00:00 2001 From: Nik <121254636+nikikiki19@users.noreply.github.com> Date: Thu, 15 Oct 2026 18:50:46 +0300 Subject: [PATCH] =?UTF-8?q?=D0=A3=D1=87=D0=B5=D1=81=D1=82=D1=8C=20=D0=B7?= =?UTF-8?q?=D0=B0=D0=BC=D0=B5=D1=87=D0=B0=D0=BD=D0=B8=D1=8F=20=D0=BF=D0=BE?= =?UTF-8?q?=20=D1=82=D0=B0=D0=B9=D0=BC=D0=B0=D1=83=D1=82=D0=B0=D0=BC=20?= =?UTF-8?q?=D0=B8=20=D0=BA=D1=8D=D1=88=D1=83?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- REPORT.md | 8 +-- app/main.py | 59 ++++++++++++------ evidence/track_cache.json | 13 ++-- evidence/track_cache.py | 124 ++++++++++++++++++++++++++++++-------- tests/level4.py | 5 +- 5 files changed, 156 insertions(+), 53 deletions(-) diff --git a/REPORT.md b/REPORT.md index d382dde8..49311366 100644 --- a/REPORT.md +++ b/REPORT.md @@ -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. ## Эксперименты и отказы diff --git a/app/main.py b/app/main.py index 69886640..f054f4c0 100644 --- a/app/main.py +++ b/app/main.py @@ -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) diff --git a/evidence/track_cache.json b/evidence/track_cache.json index 095dc2ca..58bb6e75 100644 --- a/evidence/track_cache.json +++ b/evidence/track_cache.json @@ -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:" + "cache_rebuilt_after_redis_restart": true } diff --git a/evidence/track_cache.py b/evidence/track_cache.py index 7e25f224..987f2b92 100755 --- a/evidence/track_cache.py +++ b/evidence/track_cache.py @@ -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:"},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() diff --git a/tests/level4.py b/tests/level4.py index 8d6947e7..4698541f 100644 --- a/tests/level4.py +++ b/tests/level4.py @@ -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: