forked from mtusi2026/mtusi2026lab2
Compare commits
5
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
132f1fb3e3 | ||
|
|
7dbccb2206 | ||
|
|
071d73614c | ||
|
|
1544277c0d | ||
|
|
f87929c0d7 |
+3
-10
@@ -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
@@ -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,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
|
||||
|
||||
@@ -1,37 +1,76 @@
|
||||
# Отчёт — лабораторная 2
|
||||
# Отчёт по лабораторной работе № 2
|
||||
|
||||
- Автор, группа: TODO
|
||||
- Целевая оценка; выбранный трек 5, если нужен: TODO
|
||||
- Commit/PR: TODO после публикации
|
||||
- Использованные источники, библиотеки и помощь ИИ: TODO
|
||||
- Студент: Борзов Никита
|
||||
- Группа: БВТ2304
|
||||
- Целевая оценка: 5
|
||||
- Выбранный трек 5: трек 1, согласованность кэша
|
||||
- Ветка: `solution/bvt2304-borzov`
|
||||
- Commit: `f87929c`
|
||||
- MR: https://gitea.privcloud.tech/mtusi2026/mtusi2026lab2/pulls/30
|
||||
|
||||
В этой работе я продолжил 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 включён; операции ограничены 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/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` |
|
||||
|
||||
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
|
||||
## Исследовательский трек: согласованность кэша
|
||||
|
||||
Гипотеза: Redis-кэш уменьшит задержку повторного чтения списка чатов, а явная инвалидация после создания чата сохранит read-after-write.
|
||||
|
||||
Методика: один синтетический пользователь на локальном 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.
|
||||
|
||||
## Эксперименты и отказы
|
||||
|
||||
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-контур.
|
||||
|
||||
+504
@@ -0,0 +1,504 @@
|
||||
import base64
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
import secrets
|
||||
import threading
|
||||
import uuid
|
||||
from datetime import datetime, timedelta, timezone
|
||||
|
||||
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_SECONDS = int(os.getenv('SESSION_TTL_SECONDS', '3600'))
|
||||
INSTANCE_ID = os.getenv('INSTANCE_ID', uuid.uuid4().hex[:12])
|
||||
DB_POOL_SIZE = int(os.getenv('DB_POOL_SIZE', '10'))
|
||||
|
||||
password_hasher = PasswordHasher()
|
||||
db_pool = ConnectionPool(
|
||||
DATABASE_URL, min_size=1, max_size=DB_POOL_SIZE, timeout=5,
|
||||
kwargs={'row_factory': dict_row}, open=False,
|
||||
)
|
||||
redis_client = redis.Redis.from_url(
|
||||
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')
|
||||
|
||||
|
||||
def utc_now():
|
||||
return datetime.now(timezone.utc)
|
||||
|
||||
|
||||
def format_time(value):
|
||||
return value.astimezone(timezone.utc).isoformat().replace('+00:00', 'Z')
|
||||
|
||||
|
||||
def parse_uuid(value):
|
||||
try:
|
||||
return uuid.UUID(str(value))
|
||||
except (TypeError, ValueError) as exc:
|
||||
raise ValueError('invalid uuid') from exc
|
||||
|
||||
|
||||
def user_response(row):
|
||||
return {
|
||||
'id': str(row['id']), 'username': row['username'],
|
||||
'display_name': row['display_name'], 'created_at': format_time(row['created_at']),
|
||||
}
|
||||
|
||||
|
||||
def chat_response(row, member_ids):
|
||||
return {
|
||||
'id': str(row['id']), 'title': row['title'],
|
||||
'member_ids': [str(item) for item in member_ids],
|
||||
'created_at': format_time(row['created_at']),
|
||||
}
|
||||
|
||||
|
||||
def message_response(row):
|
||||
return {
|
||||
'id': str(row['id']), 'chat_id': str(row['chat_id']),
|
||||
'sender_id': str(row['sender_id']), 'text': row['text'],
|
||||
'created_at': format_time(row['created_at']),
|
||||
}
|
||||
|
||||
|
||||
def error_response(request, status_code, code, message, extra_headers=None):
|
||||
request_id = getattr(request.state, 'request_id', uuid.uuid4().hex)
|
||||
headers = {'X-Request-Id': request_id, 'X-Instance-Id': INSTANCE_ID}
|
||||
if extra_headers:
|
||||
headers.update(extra_headers)
|
||||
return JSONResponse(
|
||||
status_code=status_code,
|
||||
content={'error': {'code': code, 'message': message, 'request_id': request_id}},
|
||||
headers=headers,
|
||||
)
|
||||
|
||||
|
||||
@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_response(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 start_application():
|
||||
db_pool.open(wait=True)
|
||||
with db_pool.connection() as connection:
|
||||
connection.execute('SELECT 1')
|
||||
|
||||
|
||||
@app.on_event('shutdown')
|
||||
def stop_application():
|
||||
db_pool.close()
|
||||
|
||||
|
||||
async def read_json_body(request):
|
||||
try:
|
||||
value = await request.json()
|
||||
except Exception as exc:
|
||||
raise ValueError('malformed json') from exc
|
||||
if not isinstance(value, dict):
|
||||
raise ValueError('request body must be an object')
|
||||
return value
|
||||
|
||||
|
||||
def require_fields(data, required):
|
||||
if set(data) != required:
|
||||
raise ValueError('unexpected or missing fields')
|
||||
|
||||
|
||||
def get_bearer_session(request):
|
||||
authorization = request.headers.get('Authorization', '')
|
||||
if not authorization.startswith('Bearer '):
|
||||
return None
|
||||
token = authorization.removeprefix('Bearer ')
|
||||
if len(token) < 40:
|
||||
return None
|
||||
try:
|
||||
value = redis_client.get('session:' + token)
|
||||
return json.loads(value) if value else None
|
||||
except Exception:
|
||||
return None
|
||||
|
||||
|
||||
def get_current_user(request):
|
||||
session = get_bearer_session(request)
|
||||
if session is None:
|
||||
return None
|
||||
with db_pool.connection() as connection:
|
||||
return connection.execute(
|
||||
'SELECT * FROM users WHERE id=%s', (session['user_id'],)
|
||||
).fetchone()
|
||||
|
||||
|
||||
def require_current_user(request):
|
||||
user = get_current_user(request)
|
||||
if user is None:
|
||||
return None, error_response(
|
||||
request, 401, 'unauthorized', 'Требуется действующая Bearer-сессия',
|
||||
{'WWW-Authenticate': 'Bearer realm="messenger"'},
|
||||
)
|
||||
return user, None
|
||||
|
||||
|
||||
def is_chat_member(connection, chat_id, user_id):
|
||||
row = connection.execute(
|
||||
'SELECT 1 FROM chat_members WHERE chat_id=%s AND user_id=%s',
|
||||
(chat_id, user_id),
|
||||
).fetchone()
|
||||
return row is not None
|
||||
|
||||
|
||||
def make_cursor(scope, owner_id, row):
|
||||
created_at = row['created_at']
|
||||
if isinstance(created_at, datetime):
|
||||
created_at = format_time(created_at)
|
||||
data = [scope, owner_id, created_at, str(row['id'])]
|
||||
return base64.urlsafe_b64encode(json.dumps(data).encode()).decode().rstrip('=')
|
||||
|
||||
|
||||
def read_cursor(cursor, expected_scope, expected_owner):
|
||||
try:
|
||||
padding = '=' * ((4 - len(cursor) % 4) % 4)
|
||||
value = json.loads(base64.urlsafe_b64decode((cursor + padding).encode()))
|
||||
if value[0] != expected_scope or value[1] != expected_owner:
|
||||
raise ValueError
|
||||
timestamp = datetime.fromisoformat(value[2].replace('Z', '+00:00'))
|
||||
return timestamp, parse_uuid(value[3])
|
||||
except (IndexError, TypeError, ValueError, json.JSONDecodeError) as exc:
|
||||
raise ValueError('invalid cursor') from exc
|
||||
|
||||
|
||||
def page_chats(items, limit, cursor_data, owner_id):
|
||||
if cursor_data:
|
||||
items = [
|
||||
item for item in items
|
||||
if (
|
||||
datetime.fromisoformat(item['created_at'].replace('Z', '+00:00')),
|
||||
uuid.UUID(item['id']),
|
||||
) > cursor_data
|
||||
]
|
||||
page = items[:limit]
|
||||
next_cursor = make_cursor('chats', owner_id, page[-1]) if len(items) > limit and page else None
|
||||
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'}
|
||||
|
||||
|
||||
@app.get('/health/ready')
|
||||
def health_ready(request: Request):
|
||||
try:
|
||||
with db_pool.connection() as connection:
|
||||
connection.execute('SELECT 1')
|
||||
redis_client.ping()
|
||||
except Exception:
|
||||
return error_response(request, 503, 'unavailable', 'Зависимость недоступна')
|
||||
return {'status': 'ok'}
|
||||
|
||||
|
||||
@app.get('/debug/cache-stats')
|
||||
def cache_stats(request: Request):
|
||||
if os.getenv('ENABLE_DEBUG_METRICS') != '1':
|
||||
return error_response(request, 404, 'not_found', 'Ресурс не найден')
|
||||
return {'chat_list_sql_reads': chat_cache_sql_reads}
|
||||
|
||||
|
||||
@app.post('/api/v1/users', status_code=201)
|
||||
async def create_user(request: Request):
|
||||
try:
|
||||
data = await read_json_body(request)
|
||||
require_fields(data, {'username', 'display_name', 'password'})
|
||||
username, display_name, password = data['username'], data['display_name'], data['password']
|
||||
if not isinstance(username, str) or not re.fullmatch(r'[a-z0-9_]{3,32}', username):
|
||||
raise ValueError('invalid username')
|
||||
if not isinstance(display_name, str) or not display_name.strip() or not 1 <= len(display_name) <= 100:
|
||||
raise ValueError('invalid display name')
|
||||
if not isinstance(password, str) or not 12 <= len(password) <= 128:
|
||||
raise ValueError('invalid password')
|
||||
|
||||
user_id, created_at = uuid.uuid4(), utc_now()
|
||||
password_hash = password_hasher.hash(password)
|
||||
with db_pool.connection() as connection:
|
||||
try:
|
||||
connection.execute(
|
||||
'INSERT INTO users VALUES (%s,%s,%s,%s,%s)',
|
||||
(user_id, username, display_name, password_hash, created_at),
|
||||
)
|
||||
connection.commit()
|
||||
except Exception as exc:
|
||||
connection.rollback()
|
||||
if 'unique' in str(exc).lower():
|
||||
return error_response(request, 409, 'conflict', 'Имя пользователя уже занято')
|
||||
raise
|
||||
return user_response({'id': user_id, 'username': username, 'display_name': display_name, 'created_at': created_at})
|
||||
except ValueError:
|
||||
return error_response(request, 400, 'invalid_request', 'Неверные поля запроса')
|
||||
|
||||
|
||||
@app.post('/api/v1/auth/sessions', status_code=201)
|
||||
def create_session(request: Request):
|
||||
authorization = request.headers.get('Authorization', '')
|
||||
try:
|
||||
if not authorization.startswith('Basic '):
|
||||
raise ValueError
|
||||
credentials = base64.b64decode(authorization.removeprefix('Basic '), validate=True).decode()
|
||||
username, password = credentials.split(':', 1)
|
||||
with db_pool.connection() as connection:
|
||||
user = connection.execute('SELECT * FROM users WHERE username=%s', (username,)).fetchone()
|
||||
if user is None:
|
||||
raise ValueError
|
||||
password_hasher.verify(user['password_hash'], password)
|
||||
except Exception:
|
||||
return error_response(
|
||||
request, 401, 'unauthorized', 'Неверные учётные данные',
|
||||
{'WWW-Authenticate': 'Basic realm="messenger", charset="UTF-8"'},
|
||||
)
|
||||
|
||||
token = secrets.token_urlsafe(32)
|
||||
expires_at = utc_now() + timedelta(seconds=SESSION_TTL_SECONDS)
|
||||
redis_client.setex(
|
||||
'session:' + token,
|
||||
SESSION_TTL_SECONDS,
|
||||
json.dumps({'user_id': str(user['id']), 'expires_at': format_time(expires_at)}),
|
||||
)
|
||||
return {
|
||||
'token': token, 'token_type': 'Bearer',
|
||||
'expires_at': format_time(expires_at), 'user': user_response(user),
|
||||
}
|
||||
|
||||
|
||||
@app.delete('/api/v1/auth/sessions/current', status_code=204)
|
||||
def logout(request: Request):
|
||||
if get_bearer_session(request) is None:
|
||||
return error_response(
|
||||
request, 401, 'unauthorized', 'Сессия недействительна',
|
||||
{'WWW-Authenticate': 'Bearer realm="messenger"'},
|
||||
)
|
||||
token = request.headers['Authorization'].removeprefix('Bearer ')
|
||||
redis_client.delete('session:' + token)
|
||||
return Response(status_code=204)
|
||||
|
||||
|
||||
@app.get('/api/v1/users/me')
|
||||
def get_me(request: Request):
|
||||
user, failure = require_current_user(request)
|
||||
return failure if failure else user_response(user)
|
||||
|
||||
|
||||
@app.post('/api/v1/chats', status_code=201)
|
||||
async def create_chat(request: Request):
|
||||
user, failure = require_current_user(request)
|
||||
if failure:
|
||||
return failure
|
||||
try:
|
||||
data = await read_json_body(request)
|
||||
require_fields(data, {'title', 'member_ids'})
|
||||
title, member_values = data['title'], data['member_ids']
|
||||
if not isinstance(title, str) or not title.strip() or not 1 <= len(title) <= 100:
|
||||
raise ValueError('invalid title')
|
||||
if not isinstance(member_values, list) or not 1 <= len(member_values) <= 100:
|
||||
raise ValueError('invalid members')
|
||||
if len(set(member_values)) != len(member_values):
|
||||
raise ValueError('duplicate members')
|
||||
member_ids = [parse_uuid(value) for value in member_values]
|
||||
if user['id'] not in member_ids:
|
||||
raise ValueError('current user must be a member')
|
||||
|
||||
chat_id, created_at = uuid.uuid4(), utc_now()
|
||||
with db_pool.connection() as connection:
|
||||
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))
|
||||
for member_id in member_ids:
|
||||
try:
|
||||
redis_client.delete('chats:' + str(member_id))
|
||||
except Exception:
|
||||
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: str = '50', cursor: str | None = None):
|
||||
global chat_cache_sql_reads
|
||||
user, failure = require_current_user(request)
|
||||
if failure:
|
||||
return failure
|
||||
try:
|
||||
limit = parse_limit(limit)
|
||||
except ValueError:
|
||||
return error_response(request, 400, 'invalid_request', 'limit должен быть от 1 до 100')
|
||||
|
||||
cursor_data = None
|
||||
if cursor is not None:
|
||||
if not cursor:
|
||||
return error_response(request, 400, 'invalid_request', 'Неверный cursor')
|
||||
try:
|
||||
cursor_data = read_cursor(cursor, 'chats', str(user['id']))
|
||||
except ValueError:
|
||||
return error_response(request, 400, 'invalid_request', 'Неверный cursor')
|
||||
|
||||
cache_key = 'chats:' + str(user['id'])
|
||||
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 = None if cache_needs_refresh else redis_client.get(cache_key)
|
||||
except Exception:
|
||||
cached = None
|
||||
if cached:
|
||||
chats = json.loads(cached)
|
||||
else:
|
||||
with db_pool.connection() as connection:
|
||||
rows = connection.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()
|
||||
chats = []
|
||||
for row in rows:
|
||||
members = connection.execute(
|
||||
'SELECT user_id FROM chat_members WHERE chat_id=%s ORDER BY user_id', (row['id'],)
|
||||
).fetchall()
|
||||
chats.append(chat_response(row, [item['user_id'] for item in members]))
|
||||
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']))
|
||||
|
||||
|
||||
@app.get('/api/v1/chats/{chat_id}')
|
||||
def get_chat(chat_id: str, request: Request):
|
||||
user, failure = require_current_user(request)
|
||||
if failure:
|
||||
return failure
|
||||
try:
|
||||
parsed_chat_id = parse_uuid(chat_id)
|
||||
except ValueError:
|
||||
return error_response(request, 400, 'invalid_request', 'Неверный UUID')
|
||||
with db_pool.connection() as connection:
|
||||
chat = connection.execute('SELECT * FROM chats WHERE id=%s', (parsed_chat_id,)).fetchone()
|
||||
if chat is None or not is_chat_member(connection, parsed_chat_id, user['id']):
|
||||
return error_response(request, 404, 'not_found', 'Чат не найден')
|
||||
members = connection.execute('SELECT user_id FROM chat_members WHERE chat_id=%s', (parsed_chat_id,)).fetchall()
|
||||
return chat_response(chat, [item['user_id'] for item in members])
|
||||
|
||||
|
||||
@app.post('/api/v1/chats/{chat_id}/messages', status_code=201)
|
||||
async def create_message(chat_id: str, request: Request):
|
||||
user, failure = require_current_user(request)
|
||||
if failure:
|
||||
return failure
|
||||
try:
|
||||
parsed_chat_id = parse_uuid(chat_id)
|
||||
data = await read_json_body(request)
|
||||
require_fields(data, {'text'})
|
||||
text = data['text']
|
||||
if not isinstance(text, str) or not text.strip() or not 1 <= len(text) <= 4000:
|
||||
raise ValueError('invalid text')
|
||||
except ValueError:
|
||||
return error_response(request, 400, 'invalid_request', 'Неверные данные сообщения')
|
||||
|
||||
with db_pool.connection() as connection:
|
||||
if not is_chat_member(connection, parsed_chat_id, user['id']):
|
||||
return error_response(request, 404, 'not_found', 'Чат не найден')
|
||||
message_id, created_at = uuid.uuid4(), utc_now()
|
||||
connection.execute(
|
||||
'INSERT INTO messages VALUES (%s,%s,%s,%s,%s)',
|
||||
(message_id, parsed_chat_id, user['id'], text, created_at),
|
||||
)
|
||||
connection.commit()
|
||||
return message_response({'id': message_id, 'chat_id': parsed_chat_id, 'sender_id': user['id'], 'text': text, 'created_at': created_at})
|
||||
|
||||
|
||||
@app.get('/api/v1/chats/{chat_id}/messages')
|
||||
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
|
||||
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)
|
||||
except ValueError:
|
||||
return error_response(request, 400, 'invalid_request', 'Неверный UUID')
|
||||
|
||||
cursor_data = None
|
||||
if cursor is not None:
|
||||
if not cursor:
|
||||
return error_response(request, 400, 'invalid_request', 'Неверный cursor')
|
||||
try:
|
||||
cursor_data = read_cursor(cursor, 'messages', str(parsed_chat_id))
|
||||
except ValueError:
|
||||
return error_response(request, 400, 'invalid_request', 'Неверный cursor')
|
||||
|
||||
with db_pool.connection() as connection:
|
||||
if not is_chat_member(connection, parsed_chat_id, user['id']):
|
||||
return error_response(request, 404, 'not_found', 'Чат не найден')
|
||||
if cursor_data:
|
||||
rows = connection.execute(
|
||||
'SELECT * FROM messages WHERE chat_id=%s AND (created_at,id)>(%s,%s) '
|
||||
'ORDER BY created_at,id LIMIT %s',
|
||||
(parsed_chat_id, cursor_data[0], cursor_data[1], limit + 1),
|
||||
).fetchall()
|
||||
else:
|
||||
rows = connection.execute(
|
||||
'SELECT * FROM messages WHERE chat_id=%s ORDER BY created_at,id LIMIT %s',
|
||||
(parsed_chat_id, limit + 1),
|
||||
).fetchall()
|
||||
|
||||
rows_to_return = rows[:limit]
|
||||
next_cursor = make_cursor('messages', str(parsed_chat_id), rows_to_return[-1]) if len(rows) > limit else None
|
||||
return {'items': [message_response(row) for row in rows_to_return], 'next_cursor': next_cursor}
|
||||
@@ -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:
|
||||
@@ -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)
|
||||
|
||||
@@ -0,0 +1,10 @@
|
||||
{
|
||||
"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,
|
||||
"cache_rebuilt_after_redis_restart": true
|
||||
}
|
||||
Executable
+106
@@ -0,0 +1,106 @@
|
||||
"""Трек 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
|
||||
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():
|
||||
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):
|
||||
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()
|
||||
@@ -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);
|
||||
@@ -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
|
||||
@@ -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;
|
||||
Executable
+10
@@ -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")
|
||||
Executable
+6
@@ -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
|
||||
@@ -0,0 +1,32 @@
|
||||
"""Небольшая проверка требований уровня 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]
|
||||
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:
|
||||
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()
|
||||
Reference in New Issue
Block a user