ЛР 2 — PostgreSQL, сессии и Redis
Skeleton contracts / contracts (pull_request) Canceled after 0s

This commit is contained in:
Nik
2026-10-09 13:44:16 +03:00
parent 65003b6119
commit f87929c0d7
16 changed files with 494 additions and 29 deletions
+3 -10
View File
@@ -1,11 +1,4 @@
# Copy to .env for your LOCAL synthetic test environment; never commit .env.
# These are logical interface suggestions; map actual framework names in REPORT.md.
APP_HOST=0.0.0.0
APP_PORT=8080
APP_ENV=lab
POSTGRES_DB=messenger
POSTGRES_USER=messenger
POSTGRES_PASSWORD=change-me-local
SESSION_TTL_SECONDS=3600
# Choose credentials locally. File paths contain no secret values.
DATABASE_URL_FILE=/run/secrets/database_url
# Optional on 3, required use on 4 in lab2; Redis OR Valkey:
SESSION_STORE=postgres
CACHE_URL_FILE=/run/secrets/cache_url
+11
View File
@@ -0,0 +1,11 @@
FROM python:3.12.8-slim-bookworm
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY app ./app
COPY migrations ./migrations
COPY scripts ./scripts
RUN useradd --create-home --uid 10001 appuser && chown -R appuser:appuser /app
USER appuser
EXPOSE 8080
CMD ["sh", "-c", "python scripts/migrate.py && uvicorn app.main:app --host 0.0.0.0 --port 8080"]
+4 -1
View File
@@ -4,7 +4,7 @@ CA_FILE ?=
ACTION_SCRIPT ?=
TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",)
.PHONY: help check validate test load test-persistence
.PHONY: help check validate test load test-persistence level4
help:
@echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes"
@@ -24,3 +24,6 @@ load:
test-persistence:
@test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable restart hook"; exit 2)
$(PYTHON) tests/resilience.py --mode persistence --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS)
level4:
$(PYTHON) tests/level4.py
+55 -18
View File
@@ -1,37 +1,74 @@
# Отчёт — лабораторная 2
# Отчёт по лабораторной работе № 2
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- Студент: Борзов Никита
- Группа: БВТ2304
- Целевая оценка: 5
- Выбранный трек 5: трек 1, согласованность кэша
- Ветка/Commit/PR: заполняется после публикации
В этой работе я продолжил REST-мессенджер из лабораторной 1. In-memory-хранилище заменено на PostgreSQL, добавлены пароль при регистрации, Basic-аутентификация только для входа и непрозрачные Bearer-сессии. Redis используется для TTL-сессий и кэша списка чатов. Сессии записываются в Redis с AOF и переживают перезапуск API и Redis-volume.
Использованы контракт и публичные проверки из репозитория лабораторной 2, FastAPI, psycopg 3, PostgreSQL 16.4, Redis 7.4 и Argon2id из `argon2-cffi`. Код первой лабораторной и отчёт использованы как исходная предметная модель; при подготовке кода и проверки требований использовалась помощь ИИ, все команды и результаты проверены локально.
## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
Нужен Docker Desktop с Compose v2:
```sh
cp .env.example .env
docker compose --env-file .env config --quiet
docker compose --env-file .env up -d --build
docker compose ps
make check
make test BASE_URL=http://localhost:8080
make test-persistence ACTION_SCRIPT=scripts/restart.sh BASE_URL=http://localhost:8080
```
Миграция `scripts/migrate.py` запускается внутри API до Uvicorn и идемпотентна. Для остановки без удаления данных используется `docker compose stop`; намеренный сброс учебного стенда выполняется отдельно командой `docker compose down -v`.
## Архитектура и решения
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
```text
Клиент -> FastAPI/Uvicorn -> PostgreSQL
└── Redis (сессии TTL + кэш списка чатов)
```
PostgreSQL является источником истины для пользователей, чатов, членства и сообщений. Таблицы, внешние ключи, уникальность username и индекс истории описаны в `migrations/001_init.sql`. Создание чата и его участников выполняется одной транзакцией. Пул PostgreSQL ограничен десятью соединениями.
Пароли хешируются Argon2id и никогда не возвращаются в User. Redis хранит `session:<token>` с TTL из `SESSION_TTL_SECONDS`; токен случайный, длиной не менее 256 бит. Redis включён с AOF `everysec`, поэтому действующая сессия сохраняется при обычном перезапуске контейнера с volume. Кэш `chats:<user_id>` живёт 30 секунд и удаляется при создании чата. После записи сообщение читается только из PostgreSQL, поэтому кэш не может скрыть подтверждённую запись.
Курсор истории кодирует `(created_at, id)` и используется в параметризованном keyset-запросе. Все ответы получают `X-Request-Id` и `X-Instance-Id`, ошибки имеют единый контракт и не содержат SQL или stack trace.
## Доказательства критериев
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| Критерий | Команда/сценарий | Наблюдаемый результат | Файл |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
| Контракт и структура | `make check` | `PASS: offline skeleton structure` | вывод команды |
| OpenAPI-схема | `make validate PYTHON=.venv/bin/python` | `PASS: full OpenAPI 3.1 and JSON Schema validation` | вывод команды |
| Публичный 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` |
| Индекс истории | `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` |
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
## Исследовательский трек: согласованность кэша
Гипотеза: Redis-кэш уменьшит задержку повторного чтения списка чатов, а явная инвалидация после создания чата сохранит read-after-write.
Методика: один синтетический пользователь на локальном Docker Compose, холодный `GET /api/v1/chats`, 30 последовательных чтений и 20 одновременных чтений после удаления ключа. Счётчик SQL-запросов включён только в локальном debug-режиме. В последнем прогоне получены cold 3.221 ms, warm p50 1.992 ms, warm p95 2.350 ms; 20 конкурентных запросов выполнили 1 SQL-чтение благодаря блокировке, после удаления ключа и рестарта Redis восстановление выполнило 1 SQL-чтение. После `POST /api/v1/chats` ключ пользователя удаляется; следующий GET заново читает PostgreSQL и возвращает новый чат. Ограничение измерения — один ноутбук и небольшой синтетический набор данных, поэтому результат показывает поведение защиты от stampede и направление задержки, а не универсальный RPS.
## Эксперименты и отказы
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| Воздействие | Ожидание | Наблюдение | Потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
| Перезапуск API и Redis/PostgreSQL через `scripts/restart.sh` | старый токен и подтверждённые данные сохраняются | публичный persistence-тест прошёл | 0 подтверждённых сообщений |
| Неверный Basic-пароль | одинаковый 401 и Basic challenge | проверено smoke | нет |
| Logout и повторный запрос | токен становится недействительным | DELETE возвращает 204, повтор — 401 | нет |
| Redis временно недоступен | readiness 503, анонимный запрос не принимается | получен HTTP 503 с `unavailable`, после запуска Redis — `{"status":"ok"}` | нет; восстановление зависит от Redis |
| Короткий TTL | `SESSION_TTL_SECONDS=2 ... tests/level4.py` | прежний токен получил 401 после истечения, гонка регистрации дала 1×201 и 7×409 | нет |
## Ограничения и следующие шаги
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
Сессии зависят от Redis: при удалении его volume активные токены отзываются, хотя PostgreSQL-данные остаются. В обязательном API нет удаления пользователей/чатов и управления участниками. Для лаборатории 3 потребуется вынести идемпотентность сообщений и общие сессии на несколько API-реплик, сохранив этот PostgreSQL-контур.
View File
+262
View File
@@ -0,0 +1,262 @@
import base64, hashlib, json, os, secrets, threading, uuid
from datetime import datetime, timezone, timedelta
from pathlib import Path
from typing import Any
import redis
from argon2 import PasswordHasher
from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse, Response
from psycopg.rows import dict_row
from psycopg_pool import ConnectionPool
DATABASE_URL = os.getenv("DATABASE_URL", "postgresql://messenger:messenger@postgres:5432/messenger")
REDIS_URL = os.getenv("REDIS_URL", "redis://redis:6379/0")
SESSION_TTL = int(os.getenv("SESSION_TTL_SECONDS", "3600"))
INSTANCE_ID = os.getenv("INSTANCE_ID", uuid.uuid4().hex[:12])
ph = PasswordHasher()
pool = ConnectionPool(DATABASE_URL, min_size=1, max_size=int(os.getenv("DB_POOL_SIZE", "10")), timeout=5, kwargs={"row_factory": dict_row}, open=False)
cache = redis.Redis.from_url(REDIS_URL, decode_responses=True, socket_connect_timeout=1)
chat_cache_lock = threading.Lock()
cache_sql_reads = 0
app = FastAPI(title="MTUSI Messenger Lab 2", version="1.2.0")
def now(): return datetime.now(timezone.utc)
def iso(value): return value.astimezone(timezone.utc).isoformat().replace("+00:00", "Z")
def uid(value):
try: return uuid.UUID(str(value))
except (ValueError, TypeError): raise ValueError("invalid uuid")
def user_view(row): return {"id": str(row["id"]), "username": row["username"], "display_name": row["display_name"], "created_at": iso(row["created_at"])}
def chat_view(row, members=None):
return {"id": str(row["id"]), "title": row["title"], "member_ids": [str(x) for x in (members or [])], "created_at": iso(row["created_at"])}
def message_view(row):
return {"id": str(row["id"]), "chat_id": str(row["chat_id"]), "sender_id": str(row["sender_id"]), "text": row["text"], "created_at": iso(row["created_at"])}
def error(request, status, code, message, headers=None):
rid = getattr(request.state, "request_id", uuid.uuid4().hex)
h = {"X-Request-Id": rid, "X-Instance-Id": INSTANCE_ID}
if headers: h.update(headers)
return JSONResponse({"error": {"code": code, "message": message, "request_id": rid}}, status_code=status, headers=h)
@app.middleware("http")
async def request_context(request: Request, call_next):
request.state.request_id = request.headers.get("X-Request-Id") or uuid.uuid4().hex
try:
response = await call_next(request)
except Exception:
return error(request, 500, "internal_error", "Внутренняя ошибка")
response.headers["X-Request-Id"] = request.state.request_id
response.headers["X-Instance-Id"] = INSTANCE_ID
return response
@app.on_event("startup")
def startup():
pool.open(wait=True)
with pool.connection() as conn:
conn.execute("SELECT 1")
@app.on_event("shutdown")
def shutdown(): pool.close()
async def body(request):
try: value = await request.json()
except Exception: raise ValueError("malformed json")
if not isinstance(value, dict): raise ValueError("object expected")
return value
def require_fields(data, required, allowed):
if set(data) != set(required) if allowed is None else not set(data).issubset(set(allowed)) or not set(required).issubset(set(data)): raise ValueError("invalid fields")
def bearer(request):
value = request.headers.get("Authorization", "")
if not value.startswith("Bearer ") or len(value) < 40: return None
token = value[7:]
try:
raw = cache.get("session:" + token)
except Exception: raw = None
if not raw: return None
try: return json.loads(raw)
except Exception: return None
def auth(request):
session = bearer(request)
if not session: return None
with pool.connection() as conn:
return conn.execute("SELECT * FROM users WHERE id=%s", (session["user_id"],)).fetchone()
def auth_or_error(request):
user = auth(request)
if not user: return None, error(request, 401, "unauthorized", "Требуется действующая Bearer-сессия", {"WWW-Authenticate": 'Bearer realm="messenger"'})
return user, None
def member(conn, chat_id, user_id):
return conn.execute("SELECT 1 FROM chat_members WHERE chat_id=%s AND user_id=%s", (chat_id, user_id)).fetchone() is not None
@app.get("/health/live")
def live(): return {"status": "ok"}
@app.get("/health/ready")
def ready(request: Request):
try:
with pool.connection() as conn: conn.execute("SELECT 1")
cache.ping()
return {"status": "ok"}
except Exception: return error(request, 503, "unavailable", "Зависимость недоступна")
@app.get("/debug/cache-stats")
def cache_stats(request: Request):
if os.getenv("ENABLE_DEBUG_METRICS") != "1": return error(request, 404, "not_found", "Ресурс не найден")
return {"chat_list_sql_reads": cache_sql_reads}
@app.post("/api/v1/users", status_code=201)
async def create_user(request: Request):
try:
data = await body(request); require_fields(data, ["username", "display_name", "password"], ["username", "display_name", "password"])
username, display, password = data["username"], data["display_name"], data["password"]
if not isinstance(username, str) or not __import__("re").fullmatch(r"[a-z0-9_]{3,32}", username) or not isinstance(display, str) or not display.strip() or not 1 <= len(display) <= 100 or not isinstance(password, str) or not 12 <= len(password) <= 128: raise ValueError("invalid fields")
user_id, created = uuid.uuid4(), now(); hashed = ph.hash(password)
with pool.connection() as conn:
try: conn.execute("INSERT INTO users VALUES (%s,%s,%s,%s,%s)", (user_id, username, display, hashed, created)); conn.commit()
except Exception as exc:
conn.rollback()
if "unique" in str(exc).lower(): return error(request, 409, "conflict", "Имя пользователя уже занято")
raise
return user_view({"id": user_id, "username": username, "display_name": display, "created_at": created})
except ValueError: return error(request, 400, "invalid_request", "Неверные поля запроса")
@app.post("/api/v1/auth/sessions", status_code=201)
def create_session(request: Request):
header = request.headers.get("Authorization", "")
try:
if not header.startswith("Basic "): raise ValueError
decoded = base64.b64decode(header[6:], validate=True).decode("utf-8"); username, password = decoded.split(":", 1)
with pool.connection() as conn: row = conn.execute("SELECT * FROM users WHERE username=%s", (username,)).fetchone()
if not row: raise ValueError
ph.verify(row["password_hash"], password)
except Exception: return error(request, 401, "unauthorized", "Неверные учётные данные", {"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'})
token = secrets.token_urlsafe(32); expires = now() + timedelta(seconds=SESSION_TTL)
cache.setex("session:" + token, SESSION_TTL, json.dumps({"user_id": str(row["id"]), "expires_at": iso(expires)}))
return {"token": token, "token_type": "Bearer", "expires_at": iso(expires), "user": user_view(row)}
@app.delete("/api/v1/auth/sessions/current", status_code=204)
def logout(request: Request):
if not bearer(request): return error(request, 401, "unauthorized", "Сессия недействительна", {"WWW-Authenticate": 'Bearer realm="messenger"'})
cache.delete("session:" + request.headers["Authorization"][7:]); return Response(status_code=204)
@app.get("/api/v1/users/me")
def me(request: Request):
user, failure = auth_or_error(request)
if failure: return failure
return user_view(user)
@app.post("/api/v1/chats", status_code=201)
async def create_chat(request: Request):
user, failure = auth_or_error(request)
if failure: return failure
try:
data = await body(request); require_fields(data, ["title", "member_ids"], ["title", "member_ids"])
title, members = data["title"], data["member_ids"]
if not isinstance(title, str) or not title.strip() or not 1 <= len(title) <= 100 or not isinstance(members, list) or not 1 <= len(members) <= 100 or len(set(members)) != len(members): raise ValueError
ids = [uid(x) for x in members]; me_id = user["id"]
if me_id not in ids: raise ValueError
chat_id, created = uuid.uuid4(), now()
with pool.connection() as conn:
if conn.execute("SELECT count(*) AS n FROM users WHERE id = ANY(%s)", (ids,)).fetchone()["n"] != len(ids): raise ValueError
with conn.transaction():
conn.execute("INSERT INTO chats VALUES (%s,%s,%s)", (chat_id,title,created))
for member_id in ids:
conn.execute("INSERT INTO chat_members VALUES (%s,%s)", (chat_id, member_id))
for x in ids: cache.delete("chats:" + str(x))
return chat_view({"id": chat_id, "title": title, "created_at": created}, ids)
except ValueError: return error(request, 400, "invalid_request", "Неверные данные чата")
@app.get("/api/v1/chats")
def list_chats(request: Request, limit: int = 50, cursor: str | None = None):
global cache_sql_reads
user, failure = auth_or_error(request)
if failure: return failure
if limit < 1 or limit > 100: return error(request, 400, "invalid_request", "limit должен быть от 1 до 100")
if cursor == "": return error(request, 400, "invalid_request", "Неверный cursor")
key = "chats:" + str(user["id"])
after = None
if cursor:
try:
decoded = json.loads(base64.urlsafe_b64decode(cursor.encode() + b"=" * ((4 - len(cursor) % 4) % 4)))
if decoded[0] != "chats" or decoded[1] != str(user["id"]): raise ValueError
after = (datetime.fromisoformat(decoded[2].replace("Z", "+00:00")), uid(decoded[3]))
except Exception: return error(request, 400, "invalid_request", "Неверный cursor")
try:
cached = cache.get(key)
if cached:
result = json.loads(cached)
if after: result = [x for x in result if (datetime.fromisoformat(x["created_at"].replace("Z", "+00:00")), uuid.UUID(x["id"])) > after]
page = result[:limit]
next_cursor = None
if len(result) > limit and page:
tail = page[-1]; next_cursor = base64.urlsafe_b64encode(json.dumps(["chats", str(user["id"]), tail["created_at"], tail["id"]]).encode()).decode().rstrip("=")
return {"items": page, "next_cursor": next_cursor}
except Exception: pass
with chat_cache_lock:
try: cached = cache.get(key)
except Exception: cached = None
if cached:
result = json.loads(cached)
else:
with pool.connection() as conn:
rows = conn.execute("SELECT c.* FROM chats c JOIN chat_members m ON m.chat_id=c.id WHERE m.user_id=%s ORDER BY c.created_at,c.id", (user["id"],)).fetchall(); result=[]
for row in rows:
ids = [x["user_id"] for x in conn.execute("SELECT user_id FROM chat_members WHERE chat_id=%s ORDER BY user_id", (row["id"],)).fetchall()]; result.append(chat_view(row,ids))
cache_sql_reads += 1
try: cache.setex(key, 30, json.dumps(result))
except Exception: pass
if after: result = [x for x in result if (datetime.fromisoformat(x["created_at"].replace("Z", "+00:00")), uuid.UUID(x["id"])) > after]
page = result[:limit]
next_cursor = None
if len(result) > limit and page:
tail = page[-1]
next_cursor = base64.urlsafe_b64encode(json.dumps(["chats", str(user["id"]), iso(datetime.fromisoformat(tail["created_at"].replace("Z", "+00:00"))), tail["id"]]).encode()).decode().rstrip("=")
return {"items": page, "next_cursor": next_cursor}
@app.get("/api/v1/chats/{chat_id}")
def get_chat(chat_id: str, request: Request):
user, failure = auth_or_error(request)
if failure: return failure
try: cid=uid(chat_id)
except ValueError: return error(request,400,"invalid_request","Неверный UUID")
with pool.connection() as conn:
row=conn.execute("SELECT * FROM chats WHERE id=%s",(cid,)).fetchone()
if not row or not member(conn,cid,user["id"]): return error(request,404,"not_found","Чат не найден")
ids=[x["user_id"] for x in conn.execute("SELECT user_id FROM chat_members WHERE chat_id=%s",(cid,)).fetchall()]
return chat_view(row,ids)
@app.post("/api/v1/chats/{chat_id}/messages", status_code=201)
async def create_message(chat_id: str, request: Request):
user, failure = auth_or_error(request)
if failure: return failure
try: cid=uid(chat_id); data=await body(request); require_fields(data,["text"],["text"]); text=data["text"]
except ValueError: return error(request,400,"invalid_request","Неверные данные сообщения")
if not isinstance(text,str) or not text.strip() or not 1 <= len(text) <= 4000: return error(request,400,"invalid_request","Текст должен быть от 1 до 4000 символов")
with pool.connection() as conn:
if not member(conn,cid,user["id"]): return error(request,404,"not_found","Чат не найден")
mid, created=uuid.uuid4(),now(); conn.execute("INSERT INTO messages VALUES (%s,%s,%s,%s,%s)",(mid,cid,user["id"],text,created)); conn.commit()
return message_view({"id":mid,"chat_id":cid,"sender_id":user["id"],"text":text,"created_at":created})
@app.get("/api/v1/chats/{chat_id}/messages")
def list_messages(chat_id: str, request: Request, limit: int = 50, cursor: str | None = None):
user, failure = auth_or_error(request)
if failure: return failure
if limit<1 or limit>100: return error(request,400,"invalid_request","limit должен быть от 1 до 100")
if cursor == "": return error(request,400,"invalid_request","Неверный cursor")
try: cid=uid(chat_id)
except ValueError: return error(request,400,"invalid_request","Неверный UUID")
last=None
if cursor:
try:
last=json.loads(base64.urlsafe_b64decode(cursor.encode()+b"="*((4-len(cursor)%4)%4)))
if last[0] != "messages" or last[1] != str(cid): raise ValueError
last = last[2:]
except Exception: return error(request,400,"invalid_request","Неверный cursor")
with pool.connection() as conn:
if not member(conn,cid,user["id"]): return error(request,404,"not_found","Чат не найден")
if last:
try: rows=conn.execute("SELECT * FROM messages WHERE chat_id=%s AND (created_at,id)>(%s,%s) ORDER BY created_at,id LIMIT %s",(cid,datetime.fromisoformat(last[0].replace("Z","+00:00")),uid(last[1]),limit+1)).fetchall()
except Exception: return error(request,400,"invalid_request","Неверный cursor")
else: rows=conn.execute("SELECT * FROM messages WHERE chat_id=%s ORDER BY created_at,id LIMIT %s",(cid,limit+1)).fetchall()
more=len(rows)>limit; rows=rows[:limit]; next_cursor=None
if more:
tail=rows[-1]; next_cursor=base64.urlsafe_b64encode(json.dumps(["messages", str(cid), iso(tail["created_at"]),str(tail["id"])]).encode()).decode().rstrip("=")
return {"items":[message_view(x) for x in rows],"next_cursor":next_cursor}
+31
View File
@@ -0,0 +1,31 @@
services:
postgres:
image: postgres:16.4-alpine
environment:
POSTGRES_DB: ${POSTGRES_DB:-messenger}
POSTGRES_USER: ${POSTGRES_USER:-messenger}
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:-local-only-password}
volumes: ["postgres_data:/var/lib/postgresql/data"]
healthcheck: {test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER:-messenger} -d ${POSTGRES_DB:-messenger}"], interval: 3s, timeout: 3s, retries: 20}
redis:
image: redis:7.4.2-alpine
command: ["redis-server", "--appendonly", "yes", "--appendfsync", "everysec"]
volumes: ["redis_data:/data"]
healthcheck: {test: ["CMD", "redis-cli", "ping"], interval: 3s, timeout: 3s, retries: 20}
api:
build: .
image: mtusi-messenger-lab2:2.0
environment:
DATABASE_URL: postgresql://${POSTGRES_USER:-messenger}:${POSTGRES_PASSWORD:-local-only-password}@postgres:5432/${POSTGRES_DB:-messenger}
REDIS_URL: redis://redis:6379/0
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
INSTANCE_ID: api-1
ENABLE_DEBUG_METRICS: ${ENABLE_DEBUG_METRICS:-1}
ports: ["8080:8080"]
depends_on:
postgres: {condition: service_healthy}
redis: {condition: service_healthy}
healthcheck: {test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://localhost:8080/health/ready')"], interval: 5s, timeout: 3s, retries: 20}
volumes:
postgres_data:
redis_data:
+13
View File
@@ -0,0 +1,13 @@
QUERY PLAN
---------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=0.29..4.20 rows=50 width=78) (actual time=0.015..0.025 rows=50 loops=1)
Buffers: shared hit=3
-> Index Scan using messages_history_idx on messages (cost=0.29..782.88 rows=10002 width=78) (actual time=0.014..0.019 rows=50 loops=1)
Index Cond: (chat_id = 'c66537d0-8434-4560-b135-3fee9c032f46'::uuid)
Buffers: shared hit=3
Planning:
Buffers: shared hit=107
Planning Time: 0.418 ms
Execution Time: 0.045 ms
(9 rows)
+9
View File
@@ -0,0 +1,9 @@
{
"hypothesis": "a lock prevents concurrent cache stampede and invalidation preserves read-after-write",
"cold_ms": 3.221,
"warm_p50_ms": 1.992,
"warm_p95_ms": 2.35,
"sql_reads_for_20_concurrent_cold_requests": 1,
"sql_reads_after_redis_restart": 1,
"read_after_write": "POST /chats deletes chats:<user_id>"
}
+30
View File
@@ -0,0 +1,30 @@
"""Трек 1: конкурентный cache stampede и восстановление после Redis restart."""
import argparse, base64, json, statistics, subprocess, time, urllib.request, 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())
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=[]
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()
+19
View File
@@ -0,0 +1,19 @@
CREATE TABLE IF NOT EXISTS users (
id UUID PRIMARY KEY, username VARCHAR(32) UNIQUE NOT NULL,
display_name VARCHAR(100) NOT NULL, password_hash TEXT NOT NULL,
created_at TIMESTAMPTZ NOT NULL
);
CREATE TABLE IF NOT EXISTS chats (
id UUID PRIMARY KEY, title VARCHAR(100) NOT NULL, created_at TIMESTAMPTZ NOT NULL
);
CREATE TABLE IF NOT EXISTS chat_members (
chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
PRIMARY KEY (chat_id, user_id)
);
CREATE TABLE IF NOT EXISTS messages (
id UUID PRIMARY KEY, chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
sender_id UUID NOT NULL REFERENCES users(id), text TEXT NOT NULL,
created_at TIMESTAMPTZ NOT NULL
);
CREATE INDEX IF NOT EXISTS messages_history_idx ON messages(chat_id, created_at, id);
+5
View File
@@ -0,0 +1,5 @@
fastapi==0.115.6
uvicorn[standard]==0.34.0
psycopg[binary,pool]==3.2.3
redis==5.2.1
argon2-cffi==23.1.0
+7
View File
@@ -0,0 +1,7 @@
-- run inside postgres after loading >=10000 synthetic messages
EXPLAIN (ANALYZE, BUFFERS)
SELECT id, chat_id, sender_id, text, created_at
FROM messages
WHERE chat_id = :'chat_id'
ORDER BY created_at, id
LIMIT 50;
+10
View File
@@ -0,0 +1,10 @@
import os
import psycopg
from pathlib import Path
url = os.getenv("DATABASE_URL", "postgresql://messenger:messenger@postgres:5432/messenger")
with psycopg.connect(url) as conn:
for path in sorted(Path("migrations").glob("*.sql")):
conn.execute(path.read_text())
conn.commit()
print("migrations applied")
+6
View File
@@ -0,0 +1,6 @@
#!/bin/sh
set -eu
# Перезапускаем API и оба stateful-сервиса, не удаляя volumes.
docker compose up -d --build --remove-orphans
docker compose restart postgres redis api
docker compose ps
+29
View File
@@ -0,0 +1,29 @@
"""Небольшая проверка требований уровня 4."""
import base64, json, os, threading, time, urllib.error, urllib.request, uuid
BASE = os.getenv("BASE_URL", "http://localhost:8080")
def call(method, path, body=None, headers=None):
data = json.dumps(body, ensure_ascii=False).encode() if body is not None else None
h = {"Content-Type":"application/json"} if body is not None else {}; h.update(headers or {})
req = urllib.request.Request(BASE+path, data=data, headers=h, method=method)
try:
with urllib.request.urlopen(req, timeout=5) as r: return r.status, json.loads(r.read() or b"{}")
except urllib.error.HTTPError as e: return e.code, json.loads(e.read() or b"{}")
def main():
username = "race_"+uuid.uuid4().hex[:12]; password="Level4-password-123"; body={"username":username,"display_name":"Race","password":password}
results=[]
def register(): results.append(call("POST","/api/v1/users",body)[0])
threads=[threading.Thread(target=register) for _ in range(8)]
for t in threads:t.start()
for t in threads:t.join()
assert results.count(201)==1 and results.count(409)==7, results
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
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:
time.sleep(3); assert call("GET","/api/v1/users/me",headers=auth)[0]==401
print("PASS: registration race and optional short-TTL expiry")
if __name__ == "__main__": main()