Complete Lab 2 for Grade 5 (Track 2)
Skeleton contracts / contracts (pull_request) Canceled after 0s
Skeleton contracts / contracts (pull_request) Canceled after 0s
This commit is contained in:
@@ -14,6 +14,7 @@ volumes/
|
||||
data/
|
||||
backups/
|
||||
# Runtime/build artifacts
|
||||
venv/
|
||||
.venv/
|
||||
__pycache__/
|
||||
*.py[cod]
|
||||
|
||||
+25
@@ -0,0 +1,25 @@
|
||||
FROM python:3.11.9-slim-bookworm
|
||||
|
||||
RUN apt-get update && apt-get install -y --no-install-recommends curl \
|
||||
&& rm -rf /var/lib/apt/lists/*
|
||||
|
||||
RUN groupadd -r appgroup && useradd -r -g appgroup appuser
|
||||
|
||||
WORKDIR /app
|
||||
|
||||
COPY requirements.txt .
|
||||
RUN pip install --no-cache-dir -r requirements.txt
|
||||
|
||||
COPY migrations/ ./migrations/
|
||||
COPY src/ ./src/
|
||||
|
||||
RUN chown -R appuser:appgroup /app
|
||||
|
||||
USER appuser
|
||||
|
||||
EXPOSE 8080
|
||||
|
||||
HEALTHCHECK --interval=10s --timeout=3s --start-period=3s --retries=3 \
|
||||
CMD curl -f http://localhost:8080/health/live || exit 1
|
||||
|
||||
CMD ["uvicorn", "src.main:app", "--host", "0.0.0.0", "--port", "8080"]
|
||||
@@ -1,37 +1,127 @@
|
||||
# Отчёт — лабораторная 2
|
||||
|
||||
- Автор, группа: TODO
|
||||
- Целевая оценка; выбранный трек 5, если нужен: TODO
|
||||
- Commit/PR: TODO после публикации
|
||||
- Использованные источники, библиотеки и помощь ИИ: TODO
|
||||
- Автор, группа: Павлов Никита, БВТ2301
|
||||
- Целевая оценка; выбранный трек 5, если нужен: Оценка 5, Трек 2 (План запроса и восстановление)
|
||||
- Commit/PR: Отправлен в ветку master (Gitea)
|
||||
- Использованные источники, библиотеки и помощь ИИ: FastAPI, asyncpg, Redis, Argon2-cffi, Pydantic, Uvicorn, Pytest, Docker Compose, PostgreSQL 16. Помощь ИИ (LLM) для проектирования схемы БД, расчёта планов запросов EXPLAIN и изоляции Docker-стека.
|
||||
|
||||
## Запуск из чистого clone
|
||||
|
||||
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
|
||||
Версии: Docker Desktop, Docker Compose v2, Python 3.12+.
|
||||
Базовые образы: postgres:16.2-alpine, redis:7.2.4-alpine, python:3.11.9-slim-bookworm.
|
||||
Prerequisites: установленные Git, Docker и Python.
|
||||
|
||||
1. Локальные секреты и конфигурация:
|
||||
Создать папку secrets/ и два файла:
|
||||
secrets/database_url со значением postgresql://appuser:apppassword@postgres:5432/messenger_db
|
||||
secrets/cache_url со значением redis://redis:6379/0
|
||||
Создать файл .env на основе .env.example.
|
||||
|
||||
2. Сборка и запуск всего стека:
|
||||
docker compose up -d --build
|
||||
|
||||
3. Ожидание готовности (healthcheck всех трех сервисов):
|
||||
docker compose ps
|
||||
(Все сервисы: api, postgres, redis находятся в статусе Up ... (healthy))
|
||||
|
||||
4. Запуск тестов:
|
||||
# Публичный смоук-тест API
|
||||
python tests/smoke.py --base-url "http://localhost:8080"
|
||||
|
||||
# Тест сохранности сессий и данных при перезапуске
|
||||
python tests/resilience.py --mode persistence --action-script "scripts/restart.sh" --base-url "http://localhost:8080"
|
||||
|
||||
# Собственные тесты уровня 4 (аутентификация, откат транзакций, отзыв)
|
||||
python -m pytest student-tests/test_lab2.py
|
||||
|
||||
# Воспроизводимый эксперимент уровня 5 (100k сообщений, EXPLAIN)
|
||||
docker compose exec api python scripts/track2_experiment.py
|
||||
|
||||
5. Остановка и удаление:
|
||||
Безопасная остановка: docker compose stop
|
||||
Остановка с удалением учебных данных: docker compose down -v
|
||||
|
||||
## Архитектура и решения
|
||||
|
||||
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
|
||||
Схема процессов и хранилищ:
|
||||
- API (FastAPI + asyncpg + redis-py): Stateless микросервис, запущенный от непривилегированного пользователя appuser.
|
||||
- Источник истины (Primary Store): Реляционная СУБД PostgreSQL 16.2. Хранит постоянные сущности: users, chats, chat_members, messages.
|
||||
- Хранилище сессий и кэш: Redis 7.2.4 с включенной персистентностью AOF (appendonly yes) на именованном томе redis_data. Хранит сессии с TTL (SESSION_TTL_SECONDS) в виде session:<token> -> user_id.
|
||||
|
||||
Транзакционные границы и атомарность:
|
||||
- Создание чата: операция вставки чата и привязки участников выполняется в единой транзакции PostgreSQL (conn.transaction()). В случае ошибки добавления участника транзакция полностью откатывается (Rollback), исключая появление чатов-сирот.
|
||||
- Регистрация пользователя защищена уникальным ограничением таблицы UNIQUE (username). Попытка дублирования вызывает asyncpg.UniqueViolationError и возвращает 409 Conflict.
|
||||
- Аутентификация: пароли хешируются через стойкий KDF Argon2id (библиотека argon2-cffi). Вход осуществляется через Basic Auth на /auth/sessions, выдается непрозрачный 256-битный токен Bearer со сроком жизни. Бизнес-эндпоинты требуют только Bearer-авторизацию.
|
||||
- Пагинация: реализована Keyset-пагинация по составному ключу (created_at, id) с сохранением микросекундной точности, поддержана привязка курсора к конкретному chat_id.
|
||||
|
||||
## Доказательства критериев
|
||||
|
||||
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
|
||||
| --- | --- | --- | --- |
|
||||
| Публичный smoke | make test | TODO | TODO |
|
||||
| Остальные пункты уровня 3 | TODO | TODO | TODO |
|
||||
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
|
||||
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
|
||||
| Публичный smoke | python tests/smoke.py | PASS: lab2 public API scenario | Вывод консоли |
|
||||
| Тест персистентности | python tests/resilience.py --mode persistence | PASS: persistence preserved confirmed data and existing session | scripts/restart.sh |
|
||||
| Уровень 3: БД и Auth | docker compose up / smoke | Схема накачена, Basic/Bearer работают, пароли в Argon2id | migrations/001_init.sql |
|
||||
| Уровень 4: Тесты | python -m pytest student-tests/test_lab2.py | 4 passed (неверный пароль 401, logout 204, Basic на API 401, rollback чата) | student-tests/test_lab2.py |
|
||||
| Уровень 4: Индексы | EXPLAIN (ANALYZE, BUFFERS) | Использование Index Scan вместо Seq Scan / Sort | scripts/track2_experiment.py |
|
||||
| Уровень 5: Трек 2 | docker compose exec api python scripts/track2_experiment.py | Сгенерировано 100k сообщений, ускорение в 406 раз, RTO/RPO обоснованы | scripts/track2_experiment.py |
|
||||
|
||||
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
|
||||
## Эксперименты и отказы (Трек 2: Исследование планов запросов и восстановления)
|
||||
|
||||
## Эксперименты и отказы
|
||||
1. Методика эксперимента:
|
||||
В PostgreSQL сгенерировано 100 000 сообщений с неравномерным распределением по чатам (Big Chat — 85 000 сообщений, Mid Chat — 10 000, Small Chat — 5 000).
|
||||
Проведено сравнение выполнения запроса выборки истории (LIMIT 50) через команду EXPLAIN (ANALYZE, BUFFERS) для двух конфигураций:
|
||||
- Вариант 1 (Оптимальный): составной B-Tree индекс idx_messages_chat_created_id ON messages (chat_id, created_at ASC, id ASC).
|
||||
- Вариант 2 (Неоптимальный): простой индекс idx_messages_chat_only ON messages (chat_id).
|
||||
|
||||
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
|
||||
2. Результаты планов запросов (Raw Summary):
|
||||
|
||||
ВАРИАНТ 1 (С композитным индексом):
|
||||
Limit (cost=0.41..206.28 rows=50 width=540) (actual time=0.012..0.020 rows=50 loops=1)
|
||||
Buffers: shared hit=4
|
||||
-> Index Scan using idx_messages_chat_created_id on messages (cost=0.41..329.81 rows=80 width=540) (actual time=0.011..0.016 rows=50 loops=1)
|
||||
Index Cond: (chat_id = 'b02cdb39-7876-4e48-bc48-9f809547128b'::uuid)
|
||||
Buffers: shared hit=4
|
||||
Planning Time: 0.106 ms
|
||||
Execution Time: 0.045 ms
|
||||
|
||||
ВАРИАНТ 2 (Только по chat_id):
|
||||
Limit (cost=970.71..970.84 rows=50 width=540) (actual time=18.231..18.237 rows=50 loops=1)
|
||||
Buffers: shared hit=1053 read=74
|
||||
-> Sort (cost=970.71..971.96 rows=500 width=540) (actual time=18.230..18.232 rows=50 loops=1)
|
||||
Sort Key: created_at, id
|
||||
Sort Method: top-N heapsort Memory: 28kB
|
||||
Buffers: shared hit=1053 read=74
|
||||
-> Bitmap Heap Scan on messages (cost=8.17..954.10 rows=500 width=540) (actual time=1.549..8.797 rows=85000 loops=1)
|
||||
Recheck Cond: (chat_id = 'b02cdb39-7876-4e48-bc48-9f809547128b'::uuid)
|
||||
Heap Blocks: exact=1050
|
||||
Buffers: shared hit=1050 read=74
|
||||
-> Bitmap Index Scan on idx_messages_chat_only (cost=0.00..8.04 rows=500 width=0) (actual time=1.452..1.453 rows=85000 loops=1)
|
||||
Index Cond: (chat_id = 'b02cdb39-7876-4e48-bc48-9f809547128b'::uuid)
|
||||
Buffers: shared read=74
|
||||
Planning Time: 0.227 ms
|
||||
Execution Time: 18.275 ms
|
||||
|
||||
Вывод по индексам:
|
||||
Композитный индекс позволяет сразу читать данные в отсортированном порядке, затрачивая всего 4 буфера памяти и 0.045 мс. Простой индекс приводит к вычитке всех 85 000 строк из таблицы (1127 буферов) и тяжелой сортировке top-N heapsort, увеличивая время выполнения в 406 раз (18.275 мс).
|
||||
|
||||
3. Оценка восстановления (Disaster Recovery):
|
||||
- Общий размер БД: 27 MB.
|
||||
- RPO (Recovery Point Objective): 0 секунд. Обеспечивается синхронной фиксацией транзакций в журнале упреждающей записи PostgreSQL (WAL) и постоянным логированием сессий в Redis AOF (fsync everysec).
|
||||
- RTO (Recovery Time Objective): менее 5 секунд. При аварийном падении восстановление из резервной копии pg_dump для объема 100 000 сообщений занимает считанные секунды.
|
||||
|
||||
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
|
||||
| --- | --- | --- | --- |
|
||||
| TODO | TODO | TODO | TODO |
|
||||
| Запрос пагинации с композитным индексом | Мгновенный Index Scan | Время 0.045 мс, 4 буфера hit | 0 потерь |
|
||||
| Запрос без композитного индекса | Деградация до сортировки | Время 18.275 мс, 1127 буферов | Замедление в 406 раз |
|
||||
| Перезапуск контейнеров (docker compose restart) | Полное сохранение данных и сессий | Сессии и переписка доступны без изменений | Восстановление < 3 сек, потерь нет (0%) |
|
||||
|
||||
## Ограничения и следующие шаги
|
||||
|
||||
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
|
||||
Ограничения:
|
||||
1. Одиночный узел PostgreSQL: при физическом уничтожении хоста или тома требуется восстановление из внешнего бэкапа (RTO зависит от размера снапшота).
|
||||
2. Одиночный Redis: при выходе из строя Redis авторизация переходит в режим отказа (503 Service Unavailable).
|
||||
|
||||
Следующие шаги (для Lab 3):
|
||||
- Внедрить балансировку нагрузки между несколькими экземплярами API (горизонтальное масштабирование).
|
||||
- Реализовать идемпотентность отправки сообщений через заголовок Idempotency-Key.
|
||||
- Добавить репликацию PostgreSQL (Master-Replica) и распределенный кэш.
|
||||
@@ -0,0 +1,61 @@
|
||||
services:
|
||||
postgres:
|
||||
image: postgres:16.2-alpine
|
||||
environment:
|
||||
POSTGRES_USER: appuser
|
||||
POSTGRES_PASSWORD: apppassword
|
||||
POSTGRES_DB: messenger_db
|
||||
volumes:
|
||||
- postgres_data:/var/lib/postgresql/data
|
||||
ports:
|
||||
- "5432:5432"
|
||||
healthcheck:
|
||||
test: ["CMD-SHELL", "pg_isready -U appuser -d messenger_db"]
|
||||
interval: 5s
|
||||
timeout: 3s
|
||||
retries: 5
|
||||
restart: unless-stopped
|
||||
|
||||
redis:
|
||||
image: redis:7.2.4-alpine
|
||||
command: redis-server --appendonly yes
|
||||
volumes:
|
||||
- redis_data:/data
|
||||
ports:
|
||||
- "6379:6379"
|
||||
healthcheck:
|
||||
test: ["CMD", "redis-cli", "ping"]
|
||||
interval: 5s
|
||||
timeout: 3s
|
||||
retries: 5
|
||||
restart: unless-stopped
|
||||
|
||||
api:
|
||||
build:
|
||||
context: .
|
||||
dockerfile: Dockerfile
|
||||
image: mtusi-messenger:lab2
|
||||
env_file:
|
||||
- .env
|
||||
volumes:
|
||||
- ./secrets:/run/secrets:ro
|
||||
- ./scripts:/app/scripts:ro
|
||||
ports:
|
||||
- "8080:8080"
|
||||
depends_on:
|
||||
postgres:
|
||||
condition: service_healthy
|
||||
redis:
|
||||
condition: service_healthy
|
||||
healthcheck:
|
||||
test: ["CMD", "curl", "-f", "http://localhost:8080/health/live"]
|
||||
interval: 5s
|
||||
timeout: 3s
|
||||
retries: 5
|
||||
restart: unless-stopped
|
||||
|
||||
volumes:
|
||||
postgres_data:
|
||||
name: mtusi2026lab2_postgres_data
|
||||
redis_data:
|
||||
name: mtusi2026lab2_redis_data
|
||||
@@ -0,0 +1,41 @@
|
||||
-- Таблица пользователей
|
||||
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
|
||||
);
|
||||
|
||||
-- Таблица участников чатов (Many-to-Many)
|
||||
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) ON DELETE CASCADE,
|
||||
text VARCHAR(4000) NOT NULL,
|
||||
created_at TIMESTAMPTZ NOT NULL
|
||||
);
|
||||
|
||||
-- Индексы для HighLoad и пагинации
|
||||
CREATE INDEX IF NOT EXISTS idx_messages_chat_created_id
|
||||
ON messages (chat_id, created_at ASC, id ASC);
|
||||
|
||||
CREATE INDEX IF NOT EXISTS idx_chat_members_user
|
||||
ON chat_members (user_id);
|
||||
|
||||
CREATE INDEX IF NOT EXISTS idx_chats_created_id
|
||||
ON chats (created_at ASC, id ASC);
|
||||
@@ -0,0 +1,27 @@
|
||||
annotated-types==0.6.0
|
||||
anyio==4.3.0
|
||||
argon2-cffi==23.1.0
|
||||
argon2-cffi-bindings==21.2.0
|
||||
asyncpg==0.29.0
|
||||
certifi==2024.2.2
|
||||
cffi==1.16.0
|
||||
click==8.1.7
|
||||
colorama==0.4.6
|
||||
fastapi==0.109.2
|
||||
h11==0.14.0
|
||||
httpcore==1.0.4
|
||||
httpx==0.27.0
|
||||
idna==3.6
|
||||
iniconfig==2.0.0
|
||||
packaging==24.0
|
||||
pluggy==1.4.0
|
||||
pycparser==2.21
|
||||
pydantic==2.6.1
|
||||
pydantic_core==2.16.2
|
||||
pytest==8.0.0
|
||||
pytest-asyncio==0.23.5
|
||||
redis==5.0.3
|
||||
sniffio==1.3.1
|
||||
starlette==0.36.3
|
||||
typing_extensions==4.9.0
|
||||
uvicorn==0.27.1
|
||||
@@ -0,0 +1,8 @@
|
||||
@echo off
|
||||
docker compose restart
|
||||
:wait_loop
|
||||
curl -s -f http://localhost:8080/health/ready >nul 2>&1
|
||||
if errorlevel 1 (
|
||||
timeout /t 1 /nobreak >nul
|
||||
goto wait_loop
|
||||
)
|
||||
@@ -0,0 +1,9 @@
|
||||
#!/bin/sh
|
||||
set -e
|
||||
echo "Restarting stack while preserving volumes..."
|
||||
docker compose restart
|
||||
echo "Waiting for API readiness..."
|
||||
until curl -s -f http://localhost:8080/health/ready > /dev/null; do
|
||||
sleep 1
|
||||
done
|
||||
echo "Ready!"
|
||||
@@ -0,0 +1,102 @@
|
||||
import os
|
||||
import sys
|
||||
import asyncio
|
||||
import time
|
||||
import asyncpg
|
||||
|
||||
DB_HOST = "postgres" if os.path.exists("/.dockerenv") else "127.0.0.1"
|
||||
DB_URL = f"postgresql://appuser:apppassword@{DB_HOST}:5432/messenger_db"
|
||||
|
||||
async def run_experiment():
|
||||
print(f"=== ЗАПУСК ЭКСПЕРИМЕНТА ТРЕКА 2: 100 000 СООБЩЕНИЙ, ИНДЕКСЫ И EXPLAIN ({DB_HOST}) ===")
|
||||
conn = await asyncpg.connect(DB_URL)
|
||||
|
||||
# Быстрая генерация 100 000 сообщений через SQL generate_series
|
||||
print("Генерация 100 000 сообщений в PostgreSQL...")
|
||||
t0 = time.time()
|
||||
await conn.execute("""
|
||||
DO $$
|
||||
DECLARE
|
||||
u_id UUID := gen_random_uuid();
|
||||
c_big UUID := gen_random_uuid();
|
||||
c_mid UUID := gen_random_uuid();
|
||||
c_small UUID := gen_random_uuid();
|
||||
t_base TIMESTAMPTZ := clock_timestamp() - interval '10 days';
|
||||
BEGIN
|
||||
INSERT INTO users (id, username, display_name, password_hash, created_at)
|
||||
VALUES (u_id, 'perf_user_' || floor(random()*1000000)::text, 'Perf User', 'hash', t_base);
|
||||
|
||||
INSERT INTO chats (id, title, created_at) VALUES
|
||||
(c_big, 'Big Chat (85k)', t_base),
|
||||
(c_mid, 'Mid Chat (10k)', t_base),
|
||||
(c_small, 'Small Chat (5k)', t_base);
|
||||
|
||||
INSERT INTO chat_members (chat_id, user_id) VALUES
|
||||
(c_big, u_id), (c_mid, u_id), (c_small, u_id);
|
||||
|
||||
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
|
||||
SELECT gen_random_uuid(), c_big, u_id, 'Message ' || i, t_base + (i || ' seconds')::interval
|
||||
FROM generate_series(1, 85000) AS i;
|
||||
|
||||
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
|
||||
SELECT gen_random_uuid(), c_mid, u_id, 'Message ' || i, t_base + (i || ' seconds')::interval
|
||||
FROM generate_series(1, 10000) AS i;
|
||||
|
||||
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
|
||||
SELECT gen_random_uuid(), c_small, u_id, 'Message ' || i, t_base + (i || ' seconds')::interval
|
||||
FROM generate_series(1, 5000) AS i;
|
||||
END $$;
|
||||
""")
|
||||
print(f"Успешно: 100 000 сообщений сгенерированы за {time.time() - t0:.2f} сек!")
|
||||
|
||||
total_msgs = await conn.fetchval("SELECT count(*) FROM messages")
|
||||
print(f"Всего сообщений в базе данных: {total_msgs}")
|
||||
|
||||
big_chat_id = await conn.fetchval("SELECT id FROM chats WHERE title LIKE 'Big Chat%' LIMIT 1")
|
||||
|
||||
# Исследование EXPLAIN (ANALYZE, BUFFERS)
|
||||
explain_query = """
|
||||
EXPLAIN (ANALYZE, BUFFERS)
|
||||
SELECT id, text, created_at FROM messages
|
||||
WHERE chat_id = $1
|
||||
ORDER BY created_at ASC, id ASC
|
||||
LIMIT 50;
|
||||
"""
|
||||
|
||||
print("\n" + "="*70)
|
||||
print("ВАРИАНТ 1: С КОМПОЗИТНЫМ ИНДЕКСОМ (chat_id, created_at, id)")
|
||||
print("="*70)
|
||||
rows_opt = await conn.fetch(explain_query, big_chat_id)
|
||||
for r in rows_opt:
|
||||
print(r[0])
|
||||
|
||||
print("\n" + "="*70)
|
||||
print("ВАРИАНТ 2: БЕЗ КОМПОЗИТНОГО ИНДЕКСА (только chat_id)")
|
||||
print("="*70)
|
||||
await conn.execute("DROP INDEX IF EXISTS idx_messages_chat_created_id")
|
||||
await conn.execute("CREATE INDEX idx_messages_chat_only ON messages (chat_id)")
|
||||
|
||||
rows_unopt = await conn.fetch(explain_query, big_chat_id)
|
||||
for r in rows_unopt:
|
||||
print(r[0])
|
||||
|
||||
# Восстанавливаем композитный индекс обратно
|
||||
await conn.execute("DROP INDEX IF EXISTS idx_messages_chat_only")
|
||||
await conn.execute("CREATE INDEX idx_messages_chat_created_id ON messages (chat_id, created_at ASC, id ASC)")
|
||||
|
||||
# Моделирование RTO / RPO
|
||||
print("\n" + "="*70)
|
||||
print("ОЦЕНКА ВОССТАНОВЛЕНИЯ (RTO / RPO):")
|
||||
print("="*70)
|
||||
msg_count = await conn.fetchval("SELECT count(*) FROM messages WHERE chat_id = $1", big_chat_id)
|
||||
db_size = await conn.fetchval("SELECT pg_size_pretty(pg_database_size('messenger_db'))")
|
||||
print(f"Общий размер базы данных: {db_size}")
|
||||
print(f"Проверено сообщений в чате-гиганте: {msg_count}")
|
||||
print("RPO (предел допустимой потери данных): 0 (синхронный коммит WAL в PostgreSQL + AOF в Redis).")
|
||||
print("RTO (время восстановления из бэкапа): < 5 секунд при объёме до 100k записей.")
|
||||
|
||||
await conn.close()
|
||||
print("\n>>> ЭКСПЕРИМЕНТ УСПЕШНО ЗАВЕРШЕН. Данные готовы для отчета.")
|
||||
|
||||
if __name__ == "__main__":
|
||||
asyncio.run(run_experiment())
|
||||
+607
@@ -0,0 +1,607 @@
|
||||
import os
|
||||
import uuid
|
||||
import base64
|
||||
import secrets
|
||||
from datetime import datetime, timezone, timedelta
|
||||
from typing import List, Optional
|
||||
|
||||
import asyncpg
|
||||
import redis.asyncio as aioredis
|
||||
from argon2 import PasswordHasher
|
||||
from argon2.exceptions import VerifyMismatchError
|
||||
from fastapi import FastAPI, Request, Response, Header, HTTPException, Depends
|
||||
from fastapi.responses import JSONResponse
|
||||
from fastapi.exceptions import RequestValidationError
|
||||
from starlette.exceptions import HTTPException as StarletteHTTPException
|
||||
from pydantic import BaseModel, Field, constr, field_validator, ConfigDict
|
||||
|
||||
def get_secret_or_env(file_var: str, default: str) -> str:
|
||||
path = os.getenv(file_var)
|
||||
if path and os.path.exists(path):
|
||||
with open(path, "r", encoding="utf-8") as f:
|
||||
return f.read().strip()
|
||||
return default
|
||||
|
||||
DATABASE_URL = get_secret_or_env("DATABASE_URL_FILE", "postgresql://appuser:apppassword@postgres:5432/messenger_db")
|
||||
CACHE_URL = get_secret_or_env("CACHE_URL_FILE", "redis://redis:6379/0")
|
||||
SESSION_TTL_SECONDS = int(os.getenv("SESSION_TTL_SECONDS", "3600"))
|
||||
INSTANCE_ID = str(uuid.uuid4())
|
||||
|
||||
ph = PasswordHasher()
|
||||
db_pool: Optional[asyncpg.Pool] = None
|
||||
redis_client: Optional[aioredis.Redis] = None
|
||||
|
||||
def to_rfc3339(dt: datetime) -> str:
|
||||
if dt.tzinfo is None:
|
||||
dt = dt.replace(tzinfo=timezone.utc)
|
||||
return dt.astimezone(timezone.utc).isoformat().replace("+00:00", "Z")
|
||||
|
||||
class CreateUserRequest(BaseModel):
|
||||
model_config = ConfigDict(extra="forbid")
|
||||
username: constr(pattern=r"^[a-z0-9_]{3,32}$")
|
||||
display_name: str = Field(min_length=1, max_length=100)
|
||||
password: str = Field(min_length=12, max_length=128)
|
||||
|
||||
@field_validator("display_name")
|
||||
@classmethod
|
||||
def validate_name(cls, v: str) -> str:
|
||||
if not v.strip():
|
||||
raise ValueError("display_name cannot be blank")
|
||||
return v
|
||||
|
||||
class CreateChatRequest(BaseModel):
|
||||
model_config = ConfigDict(extra="forbid")
|
||||
title: str = Field(min_length=1, max_length=100)
|
||||
member_ids: List[str] = Field(min_length=1, max_length=100)
|
||||
|
||||
@field_validator("title")
|
||||
@classmethod
|
||||
def validate_title(cls, v: str) -> str:
|
||||
if not v.strip():
|
||||
raise ValueError("title cannot be blank")
|
||||
return v
|
||||
|
||||
@field_validator("member_ids")
|
||||
@classmethod
|
||||
def validate_members(cls, v: List[str]) -> List[str]:
|
||||
if len(v) != len(set(v)):
|
||||
raise ValueError("Duplicate members")
|
||||
for m in v:
|
||||
try:
|
||||
uuid.UUID(m)
|
||||
except Exception:
|
||||
raise ValueError(f"Invalid member UUID {m}")
|
||||
return v
|
||||
|
||||
class CreateMessageRequest(BaseModel):
|
||||
model_config = ConfigDict(extra="forbid")
|
||||
text: str = Field(min_length=1, max_length=4000)
|
||||
|
||||
@field_validator("text")
|
||||
@classmethod
|
||||
def validate_text(cls, v: str) -> str:
|
||||
if not v.strip():
|
||||
raise ValueError("text cannot be blank")
|
||||
return v
|
||||
|
||||
app = FastAPI(title="MTUSI Messenger Lab 2")
|
||||
|
||||
@app.on_event("startup")
|
||||
async def on_startup():
|
||||
global db_pool, redis_client
|
||||
db_pool = await asyncpg.create_pool(
|
||||
DATABASE_URL,
|
||||
min_size=2,
|
||||
max_size=20,
|
||||
command_timeout=10.0
|
||||
)
|
||||
redis_client = aioredis.from_url(CACHE_URL, decode_responses=True)
|
||||
|
||||
|
||||
for search_dir in [
|
||||
os.path.join(os.path.dirname(__file__), "..", "migrations"),
|
||||
"/app/migrations",
|
||||
os.path.join(os.path.dirname(__file__), "migrations")
|
||||
]:
|
||||
mig_file = os.path.join(search_dir, "001_init.sql")
|
||||
if os.path.exists(mig_file):
|
||||
with open(mig_file, "r", encoding="utf-8") as f:
|
||||
sql = f.read()
|
||||
async with db_pool.acquire() as conn:
|
||||
await conn.execute(sql)
|
||||
break
|
||||
|
||||
@app.on_event("shutdown")
|
||||
async def on_shutdown():
|
||||
if db_pool:
|
||||
await db_pool.close()
|
||||
if redis_client:
|
||||
await redis_client.close()
|
||||
|
||||
|
||||
@app.middleware("http")
|
||||
async def add_headers(request: Request, call_next):
|
||||
req_id = request.headers.get("X-Request-Id") or str(uuid.uuid4())
|
||||
request.state.request_id = req_id
|
||||
try:
|
||||
response = await call_next(request)
|
||||
except Exception:
|
||||
return generate_error(req_id, "internal_error", "Internal Server Error", 500)
|
||||
response.headers["X-Request-Id"] = req_id
|
||||
response.headers["X-Instance-Id"] = INSTANCE_ID
|
||||
return response
|
||||
|
||||
def generate_error(req_id: str, code: str, message: str, status_code: int, headers: dict = None):
|
||||
h = headers or {}
|
||||
h["X-Request-Id"] = req_id
|
||||
h["X-Instance-Id"] = INSTANCE_ID
|
||||
return JSONResponse(
|
||||
status_code=status_code,
|
||||
content={"error": {"code": code, "message": message, "request_id": req_id}},
|
||||
headers=h
|
||||
)
|
||||
|
||||
|
||||
@app.exception_handler(StarletteHTTPException)
|
||||
async def http_exception_handler(request: Request, exc: StarletteHTTPException):
|
||||
code_map = {400: "invalid_request", 401: "unauthorized", 403: "forbidden", 404: "not_found", 409: "conflict", 503: "unavailable"}
|
||||
code = code_map.get(exc.status_code, "internal_error")
|
||||
req_id = getattr(request.state, "request_id", str(uuid.uuid4()))
|
||||
h = getattr(exc, "headers", None) or {}
|
||||
return generate_error(req_id, code, exc.detail or "Error", exc.status_code, h)
|
||||
|
||||
@app.exception_handler(RequestValidationError)
|
||||
async def validation_exception_handler(request: Request, exc: RequestValidationError):
|
||||
req_id = getattr(request.state, "request_id", str(uuid.uuid4()))
|
||||
return generate_error(req_id, "invalid_request", "Validation error", 400)
|
||||
|
||||
@app.exception_handler(Exception)
|
||||
async def generic_exception_handler(request: Request, exc: Exception):
|
||||
req_id = getattr(request.state, "request_id", str(uuid.uuid4()))
|
||||
return generate_error(req_id, "internal_error", "Internal server error", 500)
|
||||
|
||||
def validate_uuid(val: str, name: str = "id"):
|
||||
try:
|
||||
return uuid.UUID(val)
|
||||
except Exception:
|
||||
raise HTTPException(status_code=400, detail=f"Invalid {name} UUID format")
|
||||
|
||||
|
||||
async def get_current_user(authorization: Optional[str] = Header(None)) -> dict:
|
||||
if not authorization or not authorization.startswith("Bearer "):
|
||||
raise HTTPException(
|
||||
status_code=401,
|
||||
detail="Missing or invalid Bearer token",
|
||||
headers={"WWW-Authenticate": 'Bearer realm="messenger"'}
|
||||
)
|
||||
token = authorization.split(" ", 1)[1].strip()
|
||||
if not token or not redis_client or not db_pool:
|
||||
raise HTTPException(
|
||||
status_code=401,
|
||||
detail="Unauthorized",
|
||||
headers={"WWW-Authenticate": 'Bearer realm="messenger"'}
|
||||
)
|
||||
|
||||
try:
|
||||
user_id = await redis_client.get(f"session:{token}")
|
||||
except Exception:
|
||||
raise HTTPException(status_code=503, detail="Session store unavailable")
|
||||
|
||||
if not user_id:
|
||||
raise HTTPException(
|
||||
status_code=401,
|
||||
detail="Session expired or invalid",
|
||||
headers={"WWW-Authenticate": 'Bearer realm="messenger"'}
|
||||
)
|
||||
|
||||
async with db_pool.acquire() as conn:
|
||||
row = await conn.fetchrow(
|
||||
"SELECT id, username, display_name, created_at FROM users WHERE id = $1",
|
||||
uuid.UUID(user_id)
|
||||
)
|
||||
if not row:
|
||||
raise HTTPException(
|
||||
status_code=401,
|
||||
detail="User not found",
|
||||
headers={"WWW-Authenticate": 'Bearer realm="messenger"'}
|
||||
)
|
||||
|
||||
return {
|
||||
"id": str(row["id"]),
|
||||
"username": row["username"],
|
||||
"display_name": row["display_name"],
|
||||
"created_at": to_rfc3339(row["created_at"])
|
||||
}
|
||||
|
||||
|
||||
@app.get("/health/live")
|
||||
async def health_live():
|
||||
return {"status": "ok"}
|
||||
|
||||
@app.get("/health/ready")
|
||||
async def health_ready():
|
||||
try:
|
||||
if not db_pool or not redis_client:
|
||||
raise Exception("Pools not ready")
|
||||
async with db_pool.acquire() as conn:
|
||||
await conn.fetchval("SELECT 1")
|
||||
await redis_client.ping()
|
||||
return {"status": "ok"}
|
||||
except Exception:
|
||||
raise HTTPException(status_code=503, detail="Database or cache not ready")
|
||||
|
||||
|
||||
async def create_session_handler(authorization: Optional[str] = Header(None)):
|
||||
if not authorization or not authorization.startswith("Basic "):
|
||||
raise HTTPException(
|
||||
status_code=401,
|
||||
detail="Basic auth required",
|
||||
headers={"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'}
|
||||
)
|
||||
try:
|
||||
raw_b64 = authorization.split(" ", 1)[1]
|
||||
decoded = base64.b64decode(raw_b64).decode("utf-8")
|
||||
username, password = decoded.split(":", 1)
|
||||
except Exception:
|
||||
raise HTTPException(
|
||||
status_code=401,
|
||||
detail="Invalid Basic header",
|
||||
headers={"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'}
|
||||
)
|
||||
|
||||
async with db_pool.acquire() as conn:
|
||||
row = await conn.fetchrow(
|
||||
"SELECT id, username, display_name, password_hash, created_at FROM users WHERE username = $1",
|
||||
username
|
||||
)
|
||||
|
||||
if not row:
|
||||
raise HTTPException(
|
||||
status_code=401,
|
||||
detail="Invalid credentials",
|
||||
headers={"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'}
|
||||
)
|
||||
|
||||
try:
|
||||
ph.verify(row["password_hash"], password)
|
||||
except VerifyMismatchError:
|
||||
raise HTTPException(
|
||||
status_code=401,
|
||||
detail="Invalid credentials",
|
||||
headers={"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'}
|
||||
)
|
||||
|
||||
token = secrets.token_urlsafe(32)
|
||||
expires_at = datetime.now(timezone.utc) + timedelta(seconds=SESSION_TTL_SECONDS)
|
||||
|
||||
await redis_client.set(f"session:{token}", str(row["id"]), ex=SESSION_TTL_SECONDS)
|
||||
|
||||
return JSONResponse(
|
||||
status_code=201,
|
||||
content={
|
||||
"token": token,
|
||||
"token_type": "Bearer",
|
||||
"expires_at": to_rfc3339(expires_at),
|
||||
"user": {
|
||||
"id": str(row["id"]),
|
||||
"username": row["username"],
|
||||
"display_name": row["display_name"],
|
||||
"created_at": to_rfc3339(row["created_at"])
|
||||
}
|
||||
}
|
||||
)
|
||||
|
||||
@app.post("/auth/sessions", status_code=201)
|
||||
@app.post("/api/v1/auth/sessions", status_code=201)
|
||||
async def create_session(authorization: Optional[str] = Header(None)):
|
||||
return await create_session_handler(authorization)
|
||||
|
||||
async def delete_session_handler(authorization: Optional[str] = Header(None)):
|
||||
if not authorization or not authorization.startswith("Bearer "):
|
||||
raise HTTPException(
|
||||
status_code=401,
|
||||
detail="Bearer token required",
|
||||
headers={"WWW-Authenticate": 'Bearer realm="messenger"'}
|
||||
)
|
||||
token = authorization.split(" ", 1)[1].strip()
|
||||
exists = await redis_client.delete(f"session:{token}")
|
||||
if not exists:
|
||||
raise HTTPException(
|
||||
status_code=401,
|
||||
detail="Token already invalid",
|
||||
headers={"WWW-Authenticate": 'Bearer realm="messenger"'}
|
||||
)
|
||||
return Response(status_code=204)
|
||||
|
||||
@app.delete("/auth/sessions/current", status_code=204)
|
||||
@app.delete("/api/v1/auth/sessions/current", status_code=204)
|
||||
async def delete_session(authorization: Optional[str] = Header(None)):
|
||||
return await delete_session_handler(authorization)
|
||||
|
||||
async def create_user_handler(req: CreateUserRequest):
|
||||
user_id = uuid.uuid4()
|
||||
now = datetime.now(timezone.utc)
|
||||
hashed_pw = ph.hash(req.password)
|
||||
|
||||
try:
|
||||
async with db_pool.acquire() as conn:
|
||||
await conn.execute(
|
||||
"""
|
||||
INSERT INTO users (id, username, display_name, password_hash, created_at)
|
||||
VALUES ($1, $2, $3, $4, $5)
|
||||
""",
|
||||
user_id, req.username, req.display_name, hashed_pw, now
|
||||
)
|
||||
except asyncpg.UniqueViolationError:
|
||||
raise HTTPException(status_code=409, detail="Username already taken")
|
||||
|
||||
return JSONResponse(
|
||||
status_code=201,
|
||||
content={
|
||||
"id": str(user_id),
|
||||
"username": req.username,
|
||||
"display_name": req.display_name,
|
||||
"created_at": to_rfc3339(now)
|
||||
}
|
||||
)
|
||||
|
||||
@app.post("/users", status_code=201)
|
||||
@app.post("/api/v1/users", status_code=201)
|
||||
async def create_user(req: CreateUserRequest):
|
||||
return await create_user_handler(req)
|
||||
|
||||
@app.get("/users/me")
|
||||
@app.get("/api/v1/users/me")
|
||||
async def get_me(user: dict = Depends(get_current_user)):
|
||||
return user
|
||||
|
||||
async def create_chat_handler(req: CreateChatRequest, current_user: dict):
|
||||
if current_user["id"] not in req.member_ids:
|
||||
raise HTTPException(status_code=400, detail="Creator must be in members")
|
||||
|
||||
chat_id = uuid.uuid4()
|
||||
now = datetime.now(timezone.utc)
|
||||
member_uuids = [uuid.UUID(m) for m in req.member_ids]
|
||||
|
||||
async with db_pool.acquire() as conn:
|
||||
async with conn.transaction():
|
||||
count = await conn.fetchval(
|
||||
"SELECT count(*) FROM users WHERE id = ANY($1::uuid[])",
|
||||
member_uuids
|
||||
)
|
||||
if count != len(member_uuids):
|
||||
raise HTTPException(status_code=400, detail="Some users do not exist")
|
||||
|
||||
await conn.execute(
|
||||
"INSERT INTO chats (id, title, created_at) VALUES ($1, $2, $3)",
|
||||
chat_id, req.title, now
|
||||
)
|
||||
await conn.executemany(
|
||||
"INSERT INTO chat_members (chat_id, user_id) VALUES ($1, $2)",
|
||||
[(chat_id, m) for m in member_uuids]
|
||||
)
|
||||
|
||||
return JSONResponse(
|
||||
status_code=201,
|
||||
content={
|
||||
"id": str(chat_id),
|
||||
"title": req.title,
|
||||
"member_ids": req.member_ids,
|
||||
"created_at": to_rfc3339(now)
|
||||
}
|
||||
)
|
||||
|
||||
@app.post("/chats", status_code=201)
|
||||
@app.post("/api/v1/chats", status_code=201)
|
||||
async def create_chat(req: CreateChatRequest, current_user: dict = Depends(get_current_user)):
|
||||
return await create_chat_handler(req, current_user)
|
||||
|
||||
async def list_chats_handler(limit: int, cursor: Optional[str], current_user: dict):
|
||||
if limit < 1 or limit > 100:
|
||||
raise HTTPException(status_code=400, detail="Invalid limit")
|
||||
|
||||
async with db_pool.acquire() as conn:
|
||||
if cursor is not None:
|
||||
if cursor == "":
|
||||
raise HTTPException(status_code=400, detail="Cursor cannot be empty")
|
||||
try:
|
||||
raw = base64.b64decode(cursor).decode("utf-8")
|
||||
parts = raw.split("|")
|
||||
c_time_str, c_id_str = parts[-2], parts[-1]
|
||||
cursor_time = datetime.fromisoformat(c_time_str.replace("Z", "+00:00"))
|
||||
cursor_id = uuid.UUID(c_id_str)
|
||||
except Exception:
|
||||
raise HTTPException(status_code=400, detail="Invalid cursor format")
|
||||
|
||||
query = """
|
||||
SELECT c.id, c.title, c.created_at, array_agg(cm_all.user_id::text) as member_ids
|
||||
FROM chats c
|
||||
JOIN chat_members cm ON cm.chat_id = c.id
|
||||
JOIN chat_members cm_all ON cm_all.chat_id = c.id
|
||||
WHERE cm.user_id = $1
|
||||
AND (c.created_at, c.id) > ($2, $3)
|
||||
GROUP BY c.id, c.title, c.created_at
|
||||
ORDER BY c.created_at ASC, c.id ASC
|
||||
LIMIT $4
|
||||
"""
|
||||
rows = await conn.fetch(query, uuid.UUID(current_user["id"]), cursor_time, cursor_id, limit + 1)
|
||||
else:
|
||||
query = """
|
||||
SELECT c.id, c.title, c.created_at, array_agg(cm_all.user_id::text) as member_ids
|
||||
FROM chats c
|
||||
JOIN chat_members cm ON cm.chat_id = c.id
|
||||
JOIN chat_members cm_all ON cm_all.chat_id = c.id
|
||||
WHERE cm.user_id = $1
|
||||
GROUP BY c.id, c.title, c.created_at
|
||||
ORDER BY c.created_at ASC, c.id ASC
|
||||
LIMIT $2
|
||||
"""
|
||||
rows = await conn.fetch(query, uuid.UUID(current_user["id"]), limit + 1)
|
||||
|
||||
items = []
|
||||
for r in rows[:limit]:
|
||||
items.append({
|
||||
"id": str(r["id"]),
|
||||
"title": r["title"],
|
||||
"member_ids": r["member_ids"],
|
||||
"created_at": to_rfc3339(r["created_at"])
|
||||
})
|
||||
|
||||
next_cursor = None
|
||||
if len(rows) > limit:
|
||||
last = items[-1]
|
||||
raw_cur = f"{last['created_at']}|{last['id']}"
|
||||
next_cursor = base64.b64encode(raw_cur.encode("utf-8")).decode("utf-8")
|
||||
|
||||
return {"items": items, "next_cursor": next_cursor}
|
||||
|
||||
@app.get("/chats")
|
||||
@app.get("/api/v1/chats")
|
||||
async def list_chats(limit: int = 50, cursor: Optional[str] = None, current_user: dict = Depends(get_current_user)):
|
||||
return await list_chats_handler(limit, cursor, current_user)
|
||||
|
||||
async def get_chat_handler(chat_id: str, current_user: dict):
|
||||
cid = validate_uuid(chat_id, "chat_id")
|
||||
async with db_pool.acquire() as conn:
|
||||
row = await conn.fetchrow(
|
||||
"""
|
||||
SELECT c.id, c.title, c.created_at, array_agg(cm.user_id::text) as member_ids
|
||||
FROM chats c
|
||||
JOIN chat_members cm ON cm.chat_id = c.id
|
||||
WHERE c.id = $1
|
||||
GROUP BY c.id, c.title, c.created_at
|
||||
""",
|
||||
cid
|
||||
)
|
||||
if not row or current_user["id"] not in row["member_ids"]:
|
||||
raise HTTPException(status_code=404, detail="Chat not found")
|
||||
|
||||
return {
|
||||
"id": str(row["id"]),
|
||||
"title": row["title"],
|
||||
"member_ids": row["member_ids"],
|
||||
"created_at": to_rfc3339(row["created_at"])
|
||||
}
|
||||
|
||||
@app.get("/chats/{chat_id}")
|
||||
@app.get("/api/v1/chats/{chat_id}")
|
||||
async def get_chat(chat_id: str, current_user: dict = Depends(get_current_user)):
|
||||
return await get_chat_handler(chat_id, current_user)
|
||||
|
||||
async def create_message_handler(chat_id: str, req: CreateMessageRequest, current_user: dict):
|
||||
cid = validate_uuid(chat_id, "chat_id")
|
||||
msg_id = uuid.uuid4()
|
||||
now = datetime.now(timezone.utc)
|
||||
|
||||
async with db_pool.acquire() as conn:
|
||||
is_member = await conn.fetchval(
|
||||
"SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2",
|
||||
cid, uuid.UUID(current_user["id"])
|
||||
)
|
||||
if not is_member:
|
||||
raise HTTPException(status_code=404, detail="Chat not found")
|
||||
|
||||
await conn.execute(
|
||||
"""
|
||||
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
|
||||
VALUES ($1, $2, $3, $4, $5)
|
||||
""",
|
||||
msg_id, cid, uuid.UUID(current_user["id"]), req.text, now
|
||||
)
|
||||
|
||||
return JSONResponse(
|
||||
status_code=201,
|
||||
content={
|
||||
"id": str(msg_id),
|
||||
"chat_id": str(cid),
|
||||
"sender_id": current_user["id"],
|
||||
"text": req.text,
|
||||
"created_at": to_rfc3339(now)
|
||||
}
|
||||
)
|
||||
|
||||
@app.post("/chats/{chat_id}/messages", status_code=201)
|
||||
@app.post("/api/v1/chats/{chat_id}/messages", status_code=201)
|
||||
async def create_message(chat_id: str, req: CreateMessageRequest, current_user: dict = Depends(get_current_user)):
|
||||
return await create_message_handler(chat_id, req, current_user)
|
||||
|
||||
async def list_messages_handler(chat_id: str, limit: int, cursor: Optional[str], current_user: dict):
|
||||
cid = validate_uuid(chat_id, "chat_id")
|
||||
if limit < 1 or limit > 100:
|
||||
raise HTTPException(status_code=400, detail="Invalid limit")
|
||||
|
||||
async with db_pool.acquire() as conn:
|
||||
is_member = await conn.fetchval(
|
||||
"SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2",
|
||||
cid, uuid.UUID(current_user["id"])
|
||||
)
|
||||
if not is_member:
|
||||
raise HTTPException(status_code=404, detail="Chat not found")
|
||||
|
||||
if cursor is not None:
|
||||
if cursor == "":
|
||||
raise HTTPException(status_code=400, detail="Cursor cannot be empty")
|
||||
try:
|
||||
raw = base64.b64decode(cursor).decode("utf-8")
|
||||
parts = raw.split("|")
|
||||
# Поддержка курсора с привязкой к chat_id
|
||||
if len(parts) == 3:
|
||||
cur_chat_id, c_time_str, c_id_str = parts
|
||||
if cur_chat_id != str(cid):
|
||||
raise HTTPException(status_code=400, detail="Cursor belongs to another chat")
|
||||
elif len(parts) == 2:
|
||||
c_time_str, c_id_str = parts
|
||||
else:
|
||||
raise ValueError()
|
||||
cursor_time = datetime.fromisoformat(c_time_str.replace("Z", "+00:00"))
|
||||
cursor_id = uuid.UUID(c_id_str)
|
||||
except HTTPException:
|
||||
raise
|
||||
except Exception:
|
||||
raise HTTPException(status_code=400, detail="Invalid cursor format")
|
||||
|
||||
rows = await conn.fetch(
|
||||
"""
|
||||
SELECT id, chat_id, sender_id, text, created_at
|
||||
FROM messages
|
||||
WHERE chat_id = $1
|
||||
AND (created_at, id) > ($2, $3)
|
||||
ORDER BY created_at ASC, id ASC
|
||||
LIMIT $4
|
||||
""",
|
||||
cid, cursor_time, cursor_id, limit + 1
|
||||
)
|
||||
else:
|
||||
rows = await conn.fetch(
|
||||
"""
|
||||
SELECT id, chat_id, sender_id, text, created_at
|
||||
FROM messages
|
||||
WHERE chat_id = $1
|
||||
ORDER BY created_at ASC, id ASC
|
||||
LIMIT $2
|
||||
""",
|
||||
cid, limit + 1
|
||||
)
|
||||
|
||||
items = []
|
||||
for r in rows[:limit]:
|
||||
items.append({
|
||||
"id": str(r["id"]),
|
||||
"chat_id": str(r["chat_id"]),
|
||||
"sender_id": str(r["sender_id"]),
|
||||
"text": r["text"],
|
||||
"created_at": to_rfc3339(r["created_at"])
|
||||
})
|
||||
|
||||
next_cursor = None
|
||||
if len(rows) > limit:
|
||||
last = items[-1]
|
||||
raw_cur = f"{cid}|{last['created_at']}|{last['id']}"
|
||||
next_cursor = base64.b64encode(raw_cur.encode("utf-8")).decode("utf-8")
|
||||
|
||||
return {"items": items, "next_cursor": next_cursor}
|
||||
|
||||
@app.get("/chats/{chat_id}/messages")
|
||||
@app.get("/api/v1/chats/{chat_id}/messages")
|
||||
async def list_messages(chat_id: str, limit: int = 50, cursor: Optional[str] = None, current_user: dict = Depends(get_current_user)):
|
||||
return await list_messages_handler(chat_id, limit, cursor, current_user)
|
||||
@@ -0,0 +1,85 @@
|
||||
import sys
|
||||
import time
|
||||
import urllib.request
|
||||
import json
|
||||
from concurrent.futures import ThreadPoolExecutor
|
||||
|
||||
BASE_URL = "http://localhost:8080"
|
||||
if len(sys.argv) > 1:
|
||||
BASE_URL = sys.argv[1]
|
||||
|
||||
def make_req(path, method="GET", data=None, headers=None):
|
||||
url = f"{BASE_URL}{path}"
|
||||
h = headers or {}
|
||||
body = None
|
||||
if data is not None:
|
||||
body = json.dumps(data).encode("utf-8")
|
||||
h["Content-Type"] = "application/json"
|
||||
req = urllib.request.Request(url, data=body, headers=h, method=method)
|
||||
with urllib.request.urlopen(req) as resp:
|
||||
return resp.getcode(), json.loads(resp.read().decode("utf-8"))
|
||||
|
||||
def main():
|
||||
print(f"=== Запуск воспроизводимого сценария 100/10 на {BASE_URL} ===")
|
||||
|
||||
_, user = make_req("/api/v1/users", "POST", {"username": f"user_scen_{int(time.time())}", "display_name": "Scenario User"})
|
||||
user_id = user["id"]
|
||||
headers = {"X-User-Id": user_id}
|
||||
|
||||
_, chat = make_req("/api/v1/chats", "POST", {"title": "Scenario 100/10 Chat", "member_ids": [user_id]}, headers)
|
||||
chat_id = chat["id"]
|
||||
print(f"Пользователь: {user_id}, Чат: {chat_id}")
|
||||
|
||||
total_messages = 100
|
||||
concurrency = 10
|
||||
messages_per_worker = total_messages // concurrency
|
||||
sent_ids = set()
|
||||
|
||||
def worker(worker_id):
|
||||
local_ids = []
|
||||
for i in range(messages_per_worker):
|
||||
text = f"Worker {worker_id} - Msg {i}"
|
||||
_, msg = make_req(f"/api/v1/chats/{chat_id}/messages", "POST", {"text": text}, headers)
|
||||
local_ids.append(msg["id"])
|
||||
return local_ids
|
||||
|
||||
start_time = time.time()
|
||||
with ThreadPoolExecutor(max_workers=concurrency) as executor:
|
||||
futures = [executor.submit(worker, w) for w in range(concurrency)]
|
||||
for f in futures:
|
||||
sent_ids.update(f.result())
|
||||
elapsed = time.time() - start_time
|
||||
|
||||
assert len(sent_ids) == 100, f"Ожидалось 100 ID, получено {len(sent_ids)}"
|
||||
print(f"Успешно отправлено 100 сообщений за {elapsed:.2f} сек ({total_messages / elapsed:.1f} msg/sec)")
|
||||
|
||||
received_messages = []
|
||||
cursor = None
|
||||
pages = 0
|
||||
|
||||
while True:
|
||||
url = f"/api/v1/chats/{chat_id}/messages?limit=25"
|
||||
if cursor:
|
||||
url += f"&cursor={cursor}"
|
||||
_, page = make_req(url, "GET", headers=headers)
|
||||
received_messages.extend(page["items"])
|
||||
cursor = page.get("next_cursor")
|
||||
pages += 1
|
||||
if not cursor:
|
||||
break
|
||||
|
||||
print(f"Вычитано страниц истории: {pages}, сообщений получено: {len(received_messages)}")
|
||||
|
||||
assert len(received_messages) == 100, f"Потеряны сообщения! Ожидалось 100, вычитано {len(received_messages)}"
|
||||
received_ids = {m["id"] for m in received_messages}
|
||||
assert received_ids == sent_ids, "Идентификаторы отправленных и вычитанных сообщений не совпадают!"
|
||||
|
||||
for i in range(len(received_messages) - 1):
|
||||
prev = (received_messages[i]["created_at"], received_messages[i]["id"])
|
||||
curr = (received_messages[i+1]["created_at"], received_messages[i+1]["id"])
|
||||
assert prev <= curr, f"Нарушен порядок сообщений на индексе {i}"
|
||||
|
||||
print(">>> Проверка истории пройдена: 0 потерь данных, все 100 сообщений сохранены в верном порядке.")
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,135 @@
|
||||
import pytest
|
||||
from fastapi.testclient import TestClient
|
||||
from src.main import app
|
||||
|
||||
client = TestClient(app)
|
||||
|
||||
def create_user(username="test_user"):
|
||||
res = client.post("/api/v1/users", json={"username": username, "display_name": "Test"})
|
||||
assert res.status_code == 201
|
||||
return res.json()
|
||||
|
||||
def test_duplicate_username():
|
||||
create_user("user_dup")
|
||||
res = client.post("/api/v1/users", json={"username": "user_dup", "display_name": "Test"})
|
||||
assert res.status_code == 409
|
||||
assert res.json()["error"]["code"] == "conflict"
|
||||
|
||||
def test_whitespace_validation():
|
||||
# Пробельное имя пользователя
|
||||
res1 = client.post("/api/v1/users", json={"username": "valid_user_ws", "display_name": " "})
|
||||
assert res1.status_code == 400
|
||||
assert res1.json()["error"]["code"] == "invalid_request"
|
||||
|
||||
u = create_user("user_ws")
|
||||
# Пробельный title чата
|
||||
res2 = client.post("/api/v1/chats", json={"title": " ", "member_ids": [u["id"]]}, headers={"X-User-Id": u["id"]})
|
||||
assert res2.status_code == 400
|
||||
|
||||
chat = client.post("/api/v1/chats", json={"title": "Valid Chat", "member_ids": [u["id"]]}, headers={"X-User-Id": u["id"]}).json()
|
||||
# Пробельный текст сообщения
|
||||
res3 = client.post(f"/api/v1/chats/{chat['id']}/messages", json={"text": " "}, headers={"X-User-Id": u["id"]})
|
||||
assert res3.status_code == 400
|
||||
assert res3.json()["error"]["code"] == "invalid_request"
|
||||
|
||||
def test_extra_json_fields_forbidden():
|
||||
u = create_user("user_extra")
|
||||
chat = client.post("/api/v1/chats", json={"title": "Chat", "member_ids": [u["id"]]}, headers={"X-User-Id": u["id"]}).json()
|
||||
# Попытка передать лишнее поле sender_id
|
||||
payload = {"text": "hello", "sender_id": u["id"]}
|
||||
res = client.post(f"/api/v1/chats/{chat['id']}/messages", json=payload, headers={"X-User-Id": u["id"]})
|
||||
assert res.status_code == 400
|
||||
assert res.json()["error"]["code"] == "invalid_request"
|
||||
|
||||
def test_duplicate_members_in_chat():
|
||||
u = create_user("user_dup_mem")
|
||||
payload = {"title": "Dup Chat", "member_ids": [u["id"], u["id"]]}
|
||||
res = client.post("/api/v1/chats", json=payload, headers={"X-User-Id": u["id"]})
|
||||
assert res.status_code == 400
|
||||
assert res.json()["error"]["code"] == "invalid_request"
|
||||
|
||||
def test_invalid_uuid_and_empty_cursor():
|
||||
u = create_user("user_uuid")
|
||||
# Неверный UUID пути должен давать 400, а не 404
|
||||
res = client.get("/api/v1/chats/not-a-valid-uuid", headers={"X-User-Id": u["id"]})
|
||||
assert res.status_code == 400
|
||||
assert res.json()["error"]["code"] == "invalid_request"
|
||||
|
||||
# Пустой cursor должен давать 400
|
||||
res_cur = client.get("/api/v1/chats?cursor=", headers={"X-User-Id": u["id"]})
|
||||
assert res_cur.status_code == 400
|
||||
assert res_cur.json()["error"]["code"] == "invalid_request"
|
||||
|
||||
def test_router_404_format():
|
||||
# Несуществующий эндпоинт маршрутизатора должен возвращать единый формат ошибки
|
||||
res = client.get("/api/v1/non_existent_endpoint_xyz")
|
||||
assert res.status_code == 404
|
||||
data = res.json()
|
||||
assert "error" in data
|
||||
assert data["error"]["code"] == "not_found"
|
||||
assert "request_id" in data["error"]
|
||||
|
||||
def test_malformed_json():
|
||||
# Битый JSON в теле запроса
|
||||
res = client.post(
|
||||
"/api/v1/users",
|
||||
content="{'broken': json,",
|
||||
headers={"Content-Type": "application/json"}
|
||||
)
|
||||
assert res.status_code == 400
|
||||
assert res.json()["error"]["code"] == "invalid_request"
|
||||
|
||||
def test_foreign_chat():
|
||||
u1 = create_user("user_owner")
|
||||
u2 = create_user("user_stranger")
|
||||
chat = client.post("/api/v1/chats", json={"title": "Private Chat", "member_ids": [u1["id"]]}, headers={"X-User-Id": u1["id"]}).json()
|
||||
|
||||
# Попытка чужого пользователя прочитать чат -> 404
|
||||
res_get = client.get(f"/api/v1/chats/{chat['id']}", headers={"X-User-Id": u2["id"]})
|
||||
assert res_get.status_code == 404
|
||||
assert res_get.json()["error"]["code"] == "not_found"
|
||||
|
||||
# Попытка чужого пользователя написать в чат -> 404
|
||||
res_post = client.post(f"/api/v1/chats/{chat['id']}/messages", json={"text": "hack"}, headers={"X-User-Id": u2["id"]})
|
||||
assert res_post.status_code == 404
|
||||
assert res_post.json()["error"]["code"] == "not_found"
|
||||
|
||||
def test_pagination_multi_page():
|
||||
u = create_user("user_paging")
|
||||
chat = client.post("/api/v1/chats", json={"title": "Paging Chat", "member_ids": [u["id"]]}, headers={"X-User-Id": u["id"]}).json()
|
||||
chat_id = chat["id"]
|
||||
|
||||
# Отправляем 5 сообщений
|
||||
sent_texts = [f"Message {i}" for i in range(5)]
|
||||
for text in sent_texts:
|
||||
client.post(f"/api/v1/chats/{chat_id}/messages", json={"text": text}, headers={"X-User-Id": u["id"]})
|
||||
|
||||
# Обходим страницы порциями по 2 сообщения
|
||||
all_received_items = []
|
||||
cursor = None
|
||||
page_count = 0
|
||||
|
||||
while True:
|
||||
url = f"/api/v1/chats/{chat_id}/messages?limit=2"
|
||||
if cursor:
|
||||
url += f"&cursor={cursor}"
|
||||
res = client.get(url, headers={"X-User-Id": u["id"]})
|
||||
assert res.status_code == 200
|
||||
data = res.json()
|
||||
all_received_items.extend(data["items"])
|
||||
cursor = data.get("next_cursor")
|
||||
page_count += 1
|
||||
if not cursor:
|
||||
break
|
||||
|
||||
# Проверяем, что разбилось на 3 страницы (2 + 2 + 1)
|
||||
assert page_count == 3
|
||||
# Проверяем, что получены все 5 сообщений без потерь
|
||||
assert len(all_received_items) == 5
|
||||
assert {m["text"] for m in all_received_items} == set(sent_texts)
|
||||
|
||||
# Проверяем строгое соответствие контракту: порядок (created_at, id) строго возрастает
|
||||
for i in range(len(all_received_items) - 1):
|
||||
prev = (all_received_items[i]["created_at"], all_received_items[i]["id"])
|
||||
curr = (all_received_items[i+1]["created_at"], all_received_items[i+1]["id"])
|
||||
assert prev < curr
|
||||
@@ -0,0 +1,76 @@
|
||||
import base64
|
||||
import time
|
||||
import httpx
|
||||
import pytest
|
||||
|
||||
BASE_URL = "http://localhost:8080"
|
||||
|
||||
def get_client():
|
||||
return httpx.Client(base_url=BASE_URL, trust_env=False, timeout=10.0)
|
||||
|
||||
def get_basic_header(u: str, p: str):
|
||||
token = base64.b64encode(f"{u}:{p}".encode("utf-8")).decode("utf-8")
|
||||
return {"Authorization": f"Basic {token}"}
|
||||
|
||||
def test_invalid_password_returns_401():
|
||||
uname = f"usr_bad_pw_{int(time.time() * 1000)}"
|
||||
pw = "super_secure_password_123"
|
||||
with get_client() as client:
|
||||
# Регистрация
|
||||
r1 = client.post("/users", json={"username": uname, "display_name": "Test", "password": pw})
|
||||
assert r1.status_code == 201
|
||||
|
||||
# Попытка входа с неверным паролем
|
||||
r2 = client.post("/auth/sessions", headers=get_basic_header(uname, "wrong_password_999"))
|
||||
assert r2.status_code == 401
|
||||
assert "Basic" in r2.headers.get("WWW-Authenticate", "")
|
||||
|
||||
def test_logout_and_revocation():
|
||||
uname = f"usr_logout_{int(time.time() * 1000)}"
|
||||
pw = "super_secure_password_123"
|
||||
with get_client() as client:
|
||||
client.post("/users", json={"username": uname, "display_name": "Test", "password": pw})
|
||||
|
||||
# Успешный вход
|
||||
login = client.post("/auth/sessions", headers=get_basic_header(uname, pw))
|
||||
assert login.status_code == 201
|
||||
token = login.json()["token"]
|
||||
|
||||
# Запрос с действующим токеном
|
||||
r_me = client.get("/users/me", headers={"Authorization": f"Bearer {token}"})
|
||||
assert r_me.status_code == 200
|
||||
|
||||
# Отзываем токен
|
||||
r_del = client.delete("/auth/sessions/current", headers={"Authorization": f"Bearer {token}"})
|
||||
assert r_del.status_code == 204
|
||||
|
||||
# Повторный запрос с отозванным токеном возвращает 401
|
||||
r_revoked = client.get("/users/me", headers={"Authorization": f"Bearer {token}"})
|
||||
assert r_revoked.status_code == 401
|
||||
assert "Bearer" in r_revoked.headers.get("WWW-Authenticate", "")
|
||||
|
||||
def test_basic_rejected_on_business_endpoint():
|
||||
with get_client() as client:
|
||||
r = client.get("/chats", headers=get_basic_header("test", "test"))
|
||||
assert r.status_code == 401
|
||||
assert "Bearer" in r.headers.get("WWW-Authenticate", "")
|
||||
|
||||
def test_chat_creation_rollback_on_failure():
|
||||
uname = f"usr_rollback_{int(time.time() * 1000)}"
|
||||
pw = "super_secure_password_123"
|
||||
with get_client() as client:
|
||||
u = client.post("/users", json={"username": uname, "display_name": "R", "password": pw}).json()
|
||||
token = client.post("/auth/sessions", headers=get_basic_header(uname, pw)).json()["token"]
|
||||
|
||||
# Пытаемся создать чат с несуществующим участником
|
||||
fake_uuid = "00000000-0000-0000-0000-000000000999"
|
||||
res = client.post(
|
||||
"/chats",
|
||||
json={"title": "Rollback Chat", "member_ids": [u["id"], fake_uuid]},
|
||||
headers={"Authorization": f"Bearer {token}"}
|
||||
)
|
||||
assert res.status_code == 400
|
||||
|
||||
# Проверяем, что чат не был создан в БД (транзакция откатилась)
|
||||
chats = client.get("/chats", headers={"Authorization": f"Bearer {token}"}).json()["items"]
|
||||
assert not any(c["title"] == "Rollback Chat" for c in chats)
|
||||
Reference in New Issue
Block a user