16 changed files with 818 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
+57 -18
View File
@@ -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-контур.
View File
+504
View File
@@ -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}
+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)
+10
View File
@@ -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
}
+106
View File
@@ -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()
+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
+32
View File
@@ -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()