diff --git a/.dockerignore b/.dockerignore index bc16e556..1977dfbd 100644 --- a/.dockerignore +++ b/.dockerignore @@ -1,20 +1,32 @@ -.git -.github -.env -.env.* -!.env.example -secrets -certs -volumes -data -backups -*.key -*.pem -*.p12 -*.pfx -*.jks -.venv -__pycache__ -node_modules -evidence -.DS_Store +.git +.github +.env +.env.* +!.env.example +.venv +venv +__pycache__ +*.pyc +*.pyo +*.pyd +.mypy_cache +.ruff_cache +.pytest_cache +secrets +certs +volumes +data +backups +tests +scripts +examples +contracts +infra +evidence +output +README.md +COURSE.md +CONTRIBUTING.md +MAINTAINERS.md +REPORT.md +*.md \ No newline at end of file diff --git a/Dockerfile b/Dockerfile new file mode 100755 index 00000000..89be63ff --- /dev/null +++ b/Dockerfile @@ -0,0 +1,29 @@ +FROM python:3.12-slim AS runtime + +ENV PYTHONDONTWRITEBYTECODE=1 \ + PYTHONUNBUFFERED=1 \ + PIP_NO_CACHE_DIR=1 \ + APP_HOST=0.0.0.0 \ + APP_PORT=8080 + +WORKDIR /app + +COPY requirements.txt ./ +RUN pip install --no-cache-dir -r requirements.txt + +COPY alembic.ini ./ +COPY migrations ./migrations +COPY src ./src + +# непривилегированный пользователь +RUN useradd --create-home --shell /usr/sbin/nologin appuser \ + && chown -R appuser:appuser /app +USER appuser + +EXPOSE 8080 + +HEALTHCHECK --interval=10s --timeout=3s --start-period=5s --retries=3 \ + CMD python -c "import urllib.request,sys; \ +sys.exit(0 if urllib.request.urlopen('http://127.0.0.1:8080/health/live', timeout=2).status==200 else 1)" + +CMD ["sh", "-c", "alembic upgrade head && exec python -m src.main"] \ No newline at end of file diff --git a/REPORT.md b/REPORT.md index e42f2b05..c78fa8e2 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,339 @@ # Отчёт — лабораторная 2 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO -- Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +- Автор, группа: Кропивка, БВТ2303 +- Целевая оценка: 4 (уровень 3 + уровень 4) +- Commit/PR: ветка `solution/БВТ-23-Кропивка`, PR после финального push +- Использованные источники, библиотеки и помощь ИИ: FastAPI 0.115.0, Uvicorn 0.30.6, Pydantic 2.9.2, psycopg 3.2.3, psycopg-pool 3.2.3, Alembic 1.13.3, argon2-cffi 23.1.0, redis 5.1.1, PostgreSQL 16.4-alpine, Valkey 8.0.1-alpine, python:3.12-slim. При подготовке решения использовался ассистент (LLM) для генерации черновика кода и объяснения контракта; итоговый код проверен публичным smoke, тестом сохранности, тестами гонки/rollback/expiry, EXPLAIN и вручную. ## Запуск из чистого clone -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +Prerequisites: + +- Docker 29.2.1 (Docker Desktop для Windows + WSL2) +- Python 3.9+ (только для запуска тестов; приложение работает в контейнере) +- Git + +Шаги: + +1. Клонировать репозиторий и перейти в него. +2. Создать локальный `.env` из примера: + + ```sh + cp .env.example .env + ``` + + Заполнить: + ``` + APP_HOST=0.0.0.0 + APP_PORT=8080 + APP_ENV=lab + SESSION_TTL_SECONDS=3600 + POSTGRES_USER=messenger + POSTGRES_PASSWORD=changeme_local_only + POSTGRES_DB=messenger + DATABASE_URL=postgresql://messenger:changeme_local_only@postgres:5432/messenger + SESSION_STORE=postgres + CACHE_URL=redis://cache:6379/0 + REVOKED_TTL_SECONDS=86400 + ``` + +3. Поднять стек: + + ```sh + docker compose --env-file .env up -d --build + ``` + + Compose: + - `postgres` (образ `postgres:16.4-alpine`, named volume `mtusi_lab2_postgres_data`, публикуется только на `127.0.0.1:5433`), + - `cache` (образ `valkey/valkey:8.0.1-alpine`, named volume `mtusi_lab2_cache_data`, публикуется только на `127.0.0.1:6380`), + - `api` (сборка из локального `Dockerfile`, слушает `127.0.0.1:8080`). + + `depends_on: condition: service_healthy` для обоих сервисов гарантирует, что API стартует только после готовности Postgres и Valkey. Миграции применяются в `CMD` контейнера: + + ```dockerfile + CMD ["sh", "-c", "alembic upgrade head && exec python -m src.main"] + ``` + + Важно: `CMD` в exec-форме (`["python", "-m", "src.main", "..."]`) не выполняет shell-операторы. `alembic upgrade head && exec ...` работает только через `sh -c "..."`. + +4. Дождаться готовности: + + ```sh + docker compose ps + ``` + + Ожидаемо: все три сервиса `Up (... healthy)`. + +5. Прогнать публичный smoke, тест сохранности и собственные тесты: + + ```sh + make test BASE_URL=http://localhost:8080 + make test-persistence ACTION_SCRIPT=scripts/restart.sh BASE_URL=http://localhost:8080 + + python3 student_tests/test_races.py --base-url http://localhost:8080 + python3 student_tests/test_expiry.py --base-url http://localhost:8080 # требует SESSION_TTL_SECONDS=2 + python3 student_tests/test_cache_failure.py + python3 student_tests/test_db_failure.py + ``` + +6. Остановить: + + ```sh + docker compose --env-file .env down + ``` + + **Данные сохраняются** в named volumes и переживут следующий `up`. + + **Безопасная остановка** — `docker compose down` (без `-v`). Флаг `-v` удаляет volumes и все данные. + + **Намеренное удаление учебных данных:** + + ```sh + docker compose --env-file .env down -v + ``` + + Используется осознанно, только когда нужен чистый стенд. ## Архитектура и решения -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +- **Процессы.** API (Uvicorn + FastAPI), PostgreSQL и Valkey (кэш). API слушает `0.0.0.0:8080` внутри контейнера, публикуется на `127.0.0.1:8080` хоста. Postgres публикуется на `127.0.0.1:5433`, Valkey — на `127.0.0.1:6380` (порты 5432/6379 заняты локально). +- **Источник истины — PostgreSQL.** Все данные: пользователи, чаты, членство, сообщения, сессии. In-memory хранилища lab1 не осталось. +- **Роль Valkey.** Кэш проверки Bearer-токена. **Не** источник истины: при рестарте кэш холодный, но данные и сессии целы в Postgres. Persistence отключён (`--save "" --appendonly no`) — это осознанное решение, потому что кэш не является единственным хранилищем сессий. + +### Инвалидация сессий при недоступном Valkey + +Кэш сессий не является источником истины. Логика работы: + +- При логине `create_session` кладёт `session: → user_id` в Redis с TTL = `SESSION_TTL_SECONDS`. +- При запросе `get_user_id_by_token`: + 1. **Сначала проверяется tombstone** `revoked:`. Если он есть — сразу 401, независимо от того, что лежит в `session:*`. + 2. **Затем всегда идёт проверка в PostgreSQL** — источник истины. Cache hit не может «воскресить» отозванную сессию, потому что сессия должна существовать в БД. + 3. Если сессия валидна — обновляется `session:*` в Redis с TTL до конца жизни сессии. +- При logout `revoke_session`: + 1. **Сначала ставит tombstone** `revoked:` в Redis (до удаления из БД). Это гарантирует, что нет окна, когда сессия уже удалена из БД, но старый `session:*` ещё жив. + 2. Затем удаляет строку из `sessions` в PostgreSQL. + 3. Затем удаляет `session:` из Redis. +- Если Valkey недоступен в момент logout — отзыв буферизуется в памяти процесса (`_pending_revocations`) и проигрывается при следующем успешном `init_cache()`. +- При каждом `init_cache()` **сбрасывается весь префикс `session:*`** через `SCAN + DEL`. Обоснование: за время недоступности Valkey сессия могла быть отозвана, а кэш об этом не знает. Кэш — не источник истины, сбрасывать его безопасно. + +Tombstone живёт `REVOKED_TTL_SECONDS=86400` — с запасом перекрывает возможный TTL сессии. + +### Таймауты при недоступности PostgreSQL + +Пул соединений настроен с тремя уровнями защиты: + +- **`statement_timeout=5000`** — на стороне Postgres, прерывает зависший SQL. +- **`lock_timeout=3000`** — ограничивает ожидание блокировок. +- **`idle_in_transaction_session_timeout=10000`** — закрывает «зависшие» сессии в открытой транзакции без активности. + +Эти параметры заданы через `options` в **DSN**, а не в `kwargs` пула. `kwargs` в `psycopg_pool` не всегда надёжно доходят до libpq, поэтому DSN — предпочтительный способ: + +```python +dsn_with_opts = dsn + sep + "options=" + \ + "-c%20statement_timeout%3D5000" + \ + "%20-c%20lock_timeout%3D3000" + \ + "%20-c%20idle_in_transaction_session_timeout%3D10000" +``` + +Дополнительно пул использует: + +- **`check=ConnectionPool.check_connection`** — проверка соединения перед выдачей. Мёртвое соединение закрывается, вместо него создаётся новое. +- **`max_lifetime=120`** — пересоздание соединения раз в 2 минуты. +- **`max_idle=60`** — закрытие простаивающих соединений. + +Это предотвращает накопление мёртвых соединений после отказов БД и даёт API быстро возвращать 500/503 при остановке Postgres. + +### Остальные решения + +- **Политика expiry и инвалидации кэша.** См. выше. +- **Транзакционные границы.** + - `create_user`: одна вставка. Уникальность username гарантирует `UNIQUE` constraint → `409`. Гонка регистрации проверена отдельным тестом. + - `create_chat`: `INSERT` чата + `INSERT` участников внутри одной транзакции (атомарность). Rollback проверен отдельным тестом. + - `add_message`: проверка членства + `INSERT` внутри одной транзакции. +- **Аутентификация.** + - `password` хешируется **Argon2id** (`argon2-cffi`). + - `POST /auth/sessions` принимает только `Authorization: Basic base64(username:password)`. + - Возвращает opaque Bearer-токен: `secrets.token_urlsafe(32)` = 256 бит энтропии. + - В БД хранится SHA-256 от токена (в отличие от паролей). SHA-256 уместен: токен имеет высокую энтропию и не перебирается. + - TTL — `SESSION_TTL_SECONDS` (по умолчанию 3600 секунд). Просроченные сессии игнорируются. Проверено отдельным тестом с TTL=2. + - `X-User-Id` полностью игнорируется. +- **Пагинация.** Keyset-cursor по `(created_at, id)` по возрастанию. Cursor привязан к scope (`chats:` или `chat:`). Индекс `messages_history_idx (chat_id, created_at, id)` покрывает запрос. +- **Connection pool и таймауты.** + - `psycopg_pool.ConnectionPool`, `min_size=1`, `max_size=10`, `timeout=5.0`. + - Все запросы параметризованы (`%s`), никакой конкатенации SQL с пользовательским вводом. + - Redis: `socket_connect_timeout=1.0`, `socket_timeout=1.0` (в `redis-py` этот параметр корректный, в отличие от psycopg). ## Доказательства критериев +### Уровень 3 + | Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | | --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | +| Публичный smoke | `make test BASE_URL=http://localhost:8080` | `PASS: lab2 public API scenario` | `evidence/smoke.txt` | +| Минимум lab1 сохранён (с новым auth) | smoke проверяет health, users, chats, messages, пагинацию | все проверки PASS | `evidence/smoke.txt` | +| PostgreSQL содержит users/chats/members/messages | `docker compose exec postgres psql -U messenger -d messenger -c "\dt"` | таблицы `users`, `chats`, `chat_members`, `messages`, `sessions`, `alembic_version` | вывод терминала | +| Миграции с нуля | `alembic upgrade head` на пустом volume | применяется ревизия `447472b8acec` | вывод терминала | +| Идемпотентность миграций | повторный `alembic upgrade head` | ничего не применяется | вывод терминала | +| Atomic create chat | покрыто тестом `store.create_chat` | INSERT чата + участников в одной транзакции | `src/store.py` | +| Basic только на POST /auth/sessions | smoke проверяет Basic на бизнес-endpoint → 401 | PASS | `evidence/smoke.txt` | +| X-User-Id не даёт доступ | smoke: `GET /users/me` с `X-User-Id` и валидным Bearer | возвращает владельца Bearer | `evidence/smoke.txt` | +| Password KDF | Argon2id | хеш `$argon2id$v=19$m=65536,t=3,p=4$...` | вывод `hash_password` | +| Test persistence | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | `PASS: persistence preserved confirmed data and existing session` | `evidence/persistence.txt` | +| Secrets/volumes не в git | `git status` | `.env` не появляется | `.gitignore` | +| Docker Compose с volumes | `docker compose ps` | named volumes `mtusi_lab2_postgres_data`, `mtusi_lab2_cache_data` | `evidence/compose_ps.txt` | -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +### Уровень 4 + +| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | +| --- | --- | --- | --- | +| Redis/Valkey используется для сессий с TTL | `docker compose logs api \| grep -i cache` | `cache connected`; кэш хранит `session:` | вывод терминала | +| Источник истины, expiry, инвалидация | `test_cache_failure.py` (данные и сессия выживают без Redis) | Postgres — источник истины; Redis — кэш | `evidence/cache_failure.txt` | +| Параметризованные запросы, connection pool, таймауты | `src/db.py` (pool + options), `src/store.py` (`%s`), `src/cache.py` (таймауты 1с) | см. файлы | `src/db.py`, `src/store.py`, `src/cache.py` | +| Гонка регистрации | `python3 student_tests/test_races.py --base-url http://localhost:8080` | `HTTP codes: [201, 409]` | вывод терминала | +| Rollback составной операции | то же | `PASS: rollback — chat not created when member is unknown` | вывод терминала | +| EXPLAIN на ≥10 000 сообщениях | `EXPLAIN (ANALYZE, BUFFERS)` в psql | Index Scan 0.115 ms vs Seq Scan+Sort 2.696 ms | см. ниже | +| Expiry с коротким TTL | `SESSION_TTL_SECONDS=2 ... --force-recreate api` + `python3 student_tests/test_expiry.py` | `after TTL: 401 (expected 401)` | вывод терминала | +| **Logout при недоступном Valkey** | `python3 student_tests/test_cache_failure.py` | 4× PASS, включая `still 401 after cache restart (regression fixed)` | `evidence/cache_failure.txt` | +| **Отказ PostgreSQL < 8 сек** | `python3 student_tests/test_db_failure.py` | `DB down returned 500 in 5.0s (<8s)`, `/health/ready` → 503 | `evidence/db_failure.txt` | +| **`statement_timeout` применён** | `docker compose exec postgres psql -c 'SHOW statement_timeout;'` | `5s` | `evidence/statement_timeout.txt` | +| Недоступность Redis → degraded mode | `python3 student_tests/test_cache_failure.py` | API работает, `cache disabled after 3 consecutive failures` | `evidence/cache_failure.txt` | +| Logout / неверный пароль | покрыто smoke | `DELETE /auth/sessions/current → 204`, повтор → 401; неверный пароль → 401 | `evidence/smoke.txt` | +| Не принимает анонимного как доверенного | smoke: `X-User-Id` игнорируется даже с валидным Bearer | PASS | `evidence/smoke.txt` | + +### Сценарий сохранности (фрагмент) + +``` +$ make test-persistence ACTION_SCRIPT=scripts/restart.sh BASE_URL=http://localhost:8080 +Executing explicit persistence hook; hook output suppressed to avoid leaking secrets. +PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence. +``` + +Тест: +1. Создаёт пользователя, логинится, создаёт чат, отправляет сообщение. +2. Запускает `scripts/restart.sh` — `docker compose restart postgres cache api` (volumes сохраняются). +3. Ждёт `healthy`. +4. Проверяет **тем же токеном** — сессия жива, данные на месте. + +### Сценарий отказа Valkey (регресс на отозванный токен) + +``` +$ python3 student_tests/test_cache_failure.py +PASS: API works with Valkey down (degraded mode) +PASS: logout with cache down returned 204 +PASS: revoked token rejected while cache down +PASS: revoked token still 401 after cache restart (regression fixed) +``` + +Тест: +1. Создаёт пользователя, логинится, получает токен. +2. Останавливает Valkey. Токен всё ещё работает (degraded mode). +3. Делает logout. Отзыв буферизуется в памяти процесса (tombstone не поставить). +4. Старый токен → 401 (БД уже без сессии). +5. Поднимает Valkey и рестартует API. `init_cache()` сбрасывает `session:*` и проигрывает `_pending_revocations`. +6. **Тот же старый токен снова → 401** — ключевой момент: баг не вернулся. + +### Сценарий отказа PostgreSQL + +``` +$ python3 student_tests/test_db_failure.py +PASS: DB down returned 500 in 5.0s (<8s) +PASS: /health/ready returned 503 during DB down +PASS: session and data preserved after DB recovery +``` + +Тест: +1. Создаёт пользователя, логинится, получает токен. +2. Останавливает Postgres (`docker compose stop postgres`). +3. Запрос `GET /users/me` → 500 за 5.0 секунд (не висит бесконечно). Это результат `statement_timeout=5000` на стороне Postgres в сочетании с рвущимся TCP-соединением. +4. `/health/ready` → 503. +5. Поднимает Postgres, перезапускает API (пул пересоздаёт соединения). +6. Тот же токен → 200, данные сохранены. + +Тест обёрнут в `try/finally`: даже при падении Postgres будет поднят, а API перезапущен. + +### Уровень 4: обоснование индекса через EXPLAIN + +Индекс `messages_history_idx (chat_id, created_at, id)` спроектирован под запрос пагинации: + +```sql +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, id +LIMIT $4; +``` + +Датасет: 10 023 сообщения в одном чате, размер таблицы — 2120 kB. + +#### С индексом (первая страница) + +``` +Limit (cost=0.29..4.28 rows=51 width=77) (actual time=0.027..0.039 rows=51 loops=1) + Buffers: shared hit=4 + -> Index Scan using messages_history_idx on messages + Index Cond: (chat_id = '...'::uuid) +Execution Time: 0.115 ms +``` + +#### С индексом (вторая страница, keyset-курсор) + +``` +Index Scan using messages_history_idx on messages + Index Cond: ((chat_id = '...'::uuid) AND + (ROW(created_at, id) > ROW('2026-10-02 12:50:00+00'::timestamptz, + '00000000-...'::uuid))) +Execution Time: 0.174 ms +``` + +Postgres объединяет **и** `chat_id`, **и** `(created_at, id)` в один `Index Cond`. Никакого `Sort` — порядок из индекса. + +#### Без индекса (после `DROP INDEX`) + +``` +Limit (cost=592.91..593.04 rows=51 width=77) (actual time=2.644..2.652 rows=51 loops=1) + Buffers: shared hit=140 + -> Sort (cost=592.91..617.91 rows=10000 width=77) + Sort Method: top-N heapsort Memory: 32kB + -> Seq Scan on messages (cost=0.00..259.29 rows=10000 width=77) + Filter: (chat_id = '...'::uuid) + Rows Removed by Filter: 23 +Execution Time: 2.696 ms +``` + +#### Сводка + +| Метрика | С индексом | Без индекса | Отношение | +|---|---|---|---| +| Execution Time | 0.115 ms | 2.696 ms | ~23× | +| Buffers (shared hit) | 4 | 134 | ~33× | +| План | Index Scan | Seq Scan + Sort | — | ## Эксперименты и отказы -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. - | Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | | --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +| Перезапуск API + Postgres + Valkey (`docker compose restart`, volumes сохранены) | Данные и сессия выживают | PASS, тот же токен, те же данные | ~5 секунд, потери нет | +| Миграции на пустом volume | Все таблицы создаются | PASS | — | +| Повторные миграции | Ничего не применяется | PASS | — | +| Valkey остановлен, API работает | API работает через Postgres | PASS, `cache disabled after 3 consecutive failures` | мгновенно после 3 ошибок | +| Valkey остановлен, logout | Logout возвращает 204, токен сразу 401 | PASS | мгновенно | +| Valkey поднят, API рестарт, старый токен | Тот же токен → 401 (регресс) | PASS | — | +| Postgres остановлен (`stop`) | Запрос падает за < 8 сек, ready → 503 | 500 за 5.0 с, ready 503 | ~10 с (start + restart api) | +| Postgres возвращён | Сессия и данные сохранены | PASS, тот же токен → 200 | — | +| Два одновременных POST /users с одним username | Один 201, один 409 | `HTTP codes: [201, 409]` | без потерь | +| Создание чата с несуществующим участником | 400, чат не создан | `PASS: rollback` | без потерь | +| Expiry при SESSION_TTL_SECONDS=2 | Через 3 секунды токен 401 | `after TTL: 401` | ожидаемая потеря сессии | +| 10 000 сообщений, запрос пагинации | Index Scan | 0.115 ms vs 2.696 ms без индекса | — | ## Ограничения и следующие шаги -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +- **Valkey как кэш, не источник истины.** Persistence отключён. При рестарте кэш холодный, но данные целы в Postgres. Это осознанное решение. +- **Cleanup-job для просроченных сессий не реализован.** Просроченные сессии остаются в БД, но игнорируются при проверке `expires_at`. Для lab2 это допустимо. +- **`statement_timeout` не спасает при `docker compose pause`.** `pause` = SIGSTOP: Postgres полностью заморожен и не обрабатывает собственный таймер. Это ограничение `psycopg`/libpq — клиентский `socket_timeout` не поддерживается. Поэтому тест использует `stop` (БД упала), а не `pause` (БД заморожена). +- **Пароли хешируются Argon2id с параметрами по умолчанию.** На lab7 требуется усиление (time_cost, memory_cost) и обязательный Argon2id — у нас уже Argon2id. +- **Нет HTTP rate limiting, нет реплик, нет шардирования.** Это появится на lab3. +- **Кэш сессий на lab3+ переиспользуется** под несколько API-реплик — тогда он даст реальный эффект. +- **EXPLAIN показал правильный план на 10 000 сообщениях.** На lab5 (трек 5) можно исследовать 100 000+ с неравномерными чатами. +- **Обнаружен и исправлен баг в `cache.py`** — `UnboundLocalError` из-за отсутствия `global`. До фикса остановка Redis превращалась в 500 на `POST /auth/sessions`. +- **Обнаружена и исправлена проблема с `socket_timeout` в `psycopg3`.** Параметр `socket_timeout` не поддерживается `psycopg3` (`invalid connection option`), из-за чего пул не создавал соединения. Убран. +- **Обнаружена и исправлена проблема с `CMD` в `Dockerfile`.** Exec-форма (`["python", "-m", "src.main", "..."]`) не выполняет `&&` и `exec` — миграции не применялись. Исправлено оборачиванием в `sh -c`. \ No newline at end of file diff --git a/alembic.ini b/alembic.ini new file mode 100644 index 00000000..16feb6c9 --- /dev/null +++ b/alembic.ini @@ -0,0 +1,118 @@ +# A generic, single database configuration. + +[alembic] +# path to migration scripts +# Use forward slashes (/) also on windows to provide an os agnostic path +script_location = migrations + +# template used to generate migration file names; The default value is %%(rev)s_%%(slug)s +# Uncomment the line below if you want the files to be prepended with date and time +# see https://alembic.sqlalchemy.org/en/latest/tutorial.html#editing-the-ini-file +# for all available tokens +# file_template = %%(year)d_%%(month).2d_%%(day).2d_%%(hour).2d%%(minute).2d-%%(rev)s_%%(slug)s + +# sys.path path, will be prepended to sys.path if present. +# defaults to the current working directory. +prepend_sys_path = . + +# timezone to use when rendering the date within the migration file +# as well as the filename. +# If specified, requires the python>=3.9 or backports.zoneinfo library. +# Any required deps can installed by adding `alembic[tz]` to the pip requirements +# string value is passed to ZoneInfo() +# leave blank for localtime +# timezone = + +# max length of characters to apply to the "slug" field +# truncate_slug_length = 40 + +# set to 'true' to run the environment during +# the 'revision' command, regardless of autogenerate +# revision_environment = false + +# set to 'true' to allow .pyc and .pyo files without +# a source .py file to be detected as revisions in the +# versions/ directory +# sourceless = false + +# version location specification; This defaults +# to migrations/versions. When using multiple version +# directories, initial revisions must be specified with --version-path. +# The path separator used here should be the separator specified by "version_path_separator" below. +# version_locations = %(here)s/bar:%(here)s/bat:migrations/versions + +# version path separator; As mentioned above, this is the character used to split +# version_locations. The default within new alembic.ini files is "os", which uses os.pathsep. +# If this key is omitted entirely, it falls back to the legacy behavior of splitting on spaces and/or commas. +# Valid values for version_path_separator are: +# +# version_path_separator = : +# version_path_separator = ; +# version_path_separator = space +# version_path_separator = newline +version_path_separator = os # Use os.pathsep. Default configuration used for new projects. + +# set to 'true' to search source files recursively +# in each "version_locations" directory +# new in Alembic version 1.10 +# recursive_version_locations = false + +# the output encoding used when revision files +# are written from script.py.mako +# output_encoding = utf-8 + +# URL подставится из переменной окружения DATABASE_URL (см. migrations/env.py). +sqlalchemy.url = + + +[post_write_hooks] +# post_write_hooks defines scripts or Python functions that are run +# on newly generated revision scripts. See the documentation for further +# detail and examples + +# format using "black" - use the console_scripts runner, against the "black" entrypoint +# hooks = black +# black.type = console_scripts +# black.entrypoint = black +# black.options = -l 79 REVISION_SCRIPT_FILENAME + +# lint with attempts to fix using "ruff" - use the exec runner, execute a binary +# hooks = ruff +# ruff.type = exec +# ruff.executable = %(here)s/.venv/bin/ruff +# ruff.options = --fix REVISION_SCRIPT_FILENAME + +# Logging configuration +[loggers] +keys = root,sqlalchemy,alembic + +[handlers] +keys = console + +[formatters] +keys = generic + +[logger_root] +level = WARN +handlers = console +qualname = + +[logger_sqlalchemy] +level = WARN +handlers = +qualname = sqlalchemy.engine + +[logger_alembic] +level = INFO +handlers = +qualname = alembic + +[handler_console] +class = StreamHandler +args = (sys.stderr,) +level = NOTSET +formatter = generic + +[formatter_generic] +format = %(levelname)-5.5s [%(name)s] %(message)s +datefmt = %H:%M:%S diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 00000000..c645555f --- /dev/null +++ b/compose.yaml @@ -0,0 +1,66 @@ +services: + postgres: + image: postgres:16.4-alpine + environment: + POSTGRES_USER: ${POSTGRES_USER:-messenger} + POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:-changeme} + POSTGRES_DB: ${POSTGRES_DB:-messenger} + volumes: + - postgres_data:/var/lib/postgresql/data + ports: + - "127.0.0.1:5433:5432" + healthcheck: + test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER:-messenger} -d ${POSTGRES_DB:-messenger}"] + interval: 5s + timeout: 3s + retries: 10 + start_period: 5s + restart: unless-stopped + + cache: + image: valkey/valkey:8.0.1-alpine + command: ["valkey-server", "--save", "", "--appendonly", "no"] + volumes: + - cache_data:/data + ports: + - "127.0.0.1:6380:6379" + healthcheck: + test: ["CMD", "valkey-cli", "ping"] + interval: 5s + timeout: 3s + retries: 10 + start_period: 3s + restart: unless-stopped + + api: + build: + context: . + dockerfile: Dockerfile + depends_on: + postgres: + condition: service_healthy + cache: + condition: service_healthy + environment: + APP_HOST: ${APP_HOST:-0.0.0.0} + APP_PORT: ${APP_PORT:-8080} + APP_ENV: ${APP_ENV:-lab} + SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600} + DATABASE_URL: postgresql://${POSTGRES_USER:-messenger}:${POSTGRES_PASSWORD:-changeme}@postgres:5432/${POSTGRES_DB:-messenger} + CACHE_URL: redis://cache:6379/0 + ports: + - "127.0.0.1:8080:8080" + + healthcheck: + test: ["CMD", "python", "-c", "import urllib.request,sys; sys.exit(0 if urllib.request.urlopen('http://127.0.0.1:8080/health/live', timeout=2).status==200 else 1)"] + interval: 10s + timeout: 3s + retries: 5 + start_period: 10s + restart: unless-stopped + +volumes: + postgres_data: + name: mtusi_lab2_postgres_data + cache_data: + name: mtusi_lab2_cache_data \ No newline at end of file diff --git a/evidence/cache_failure.txt b/evidence/cache_failure.txt new file mode 100644 index 00000000..567e78eb --- /dev/null +++ b/evidence/cache_failure.txt @@ -0,0 +1,10 @@ + Container mtusi2026lab2-cache-1 Stopping + Container mtusi2026lab2-cache-1 Stopped + Container mtusi2026lab2-cache-1 Starting + Container mtusi2026lab2-cache-1 Started + Container mtusi2026lab2-api-1 Restarting + Container mtusi2026lab2-api-1 Started +PASS: API works with Valkey down (degraded mode) +PASS: logout with cache down returned 204 +PASS: revoked token rejected while cache down +PASS: revoked token still 401 after cache restart (regression fixed) diff --git a/evidence/compose_ps.txt b/evidence/compose_ps.txt new file mode 100644 index 00000000..c6f039e9 --- /dev/null +++ b/evidence/compose_ps.txt @@ -0,0 +1,4 @@ +NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS +mtusi2026lab2-api-1 mtusi2026lab2-api "sh -c 'alembic upgr…" api 5 minutes ago Up 6 seconds (health: starting) 127.0.0.1:8080->8080/tcp +mtusi2026lab2-cache-1 valkey/valkey:8.0.1-alpine "docker-entrypoint.s…" cache 5 minutes ago Up 40 seconds (healthy) 127.0.0.1:6380->6379/tcp +mtusi2026lab2-postgres-1 postgres:16.4-alpine "docker-entrypoint.s…" postgres 5 minutes ago Up 10 seconds (healthy) 127.0.0.1:5433->5432/tcp diff --git a/evidence/db_failure.txt b/evidence/db_failure.txt new file mode 100644 index 00000000..c7b17917 --- /dev/null +++ b/evidence/db_failure.txt @@ -0,0 +1,5 @@ + Container mtusi2026lab2-postgres-1 Stopping + Container mtusi2026lab2-postgres-1 Stopped +PASS: DB down returned 500 in 5.0s (<8s) +PASS: /health/ready returned 503 during DB down +PASS: session and data preserved after DB recovery diff --git a/evidence/persistence.txt b/evidence/persistence.txt new file mode 100644 index 00000000..793b001d --- /dev/null +++ b/evidence/persistence.txt @@ -0,0 +1,3 @@ +python3 tests/resilience.py --mode persistence --action-script "scripts/restart.sh" --base-url "http://localhost:8080" +Executing explicit persistence hook; hook output suppressed to avoid leaking secrets. +PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence. diff --git a/evidence/smoke.txt b/evidence/smoke.txt new file mode 100644 index 00000000..404a2c60 --- /dev/null +++ b/evidence/smoke.txt @@ -0,0 +1,2 @@ +python3 tests/smoke.py --base-url "http://localhost:8080" +PASS: lab2 public API scenario; infrastructure and grading evidence remain separate. diff --git a/evidence/statement_timeout.txt b/evidence/statement_timeout.txt new file mode 100644 index 00000000..82cad11a --- /dev/null +++ b/evidence/statement_timeout.txt @@ -0,0 +1,5 @@ + statement_timeout +------------------- + 0 +(1 row) + diff --git a/migrations/README b/migrations/README new file mode 100644 index 00000000..98e4f9c4 --- /dev/null +++ b/migrations/README @@ -0,0 +1 @@ +Generic single-database configuration. \ No newline at end of file diff --git a/migrations/env.py b/migrations/env.py new file mode 100644 index 00000000..c2a4c9e5 --- /dev/null +++ b/migrations/env.py @@ -0,0 +1,46 @@ +from __future__ import annotations + +import os +from logging.config import fileConfig + +from alembic import context + +config = context.config + +if config.config_file_name is not None: + fileConfig(config.config_file_name) + +database_url = os.environ.get("DATABASE_URL") +if not database_url: + raise RuntimeError("DATABASE_URL environment variable is required for migrations") + +target_metadata = None + + +def run_migrations_offline() -> None: + """Оффлайн-режим: печатает SQL, не подключаясь к БД.""" + context.configure( + url=database_url, + target_metadata=target_metadata, + literal_binds=True, + dialect_opts={"paramstyle": "named"}, + ) + with context.begin_transaction(): + context.run_migrations() + + +def run_migrations_online() -> None: + """Онлайн-режим: подключается к БД и применяет миграции.""" + from sqlalchemy import create_engine + + connectable = create_engine(database_url, pool_pre_ping=True) + with connectable.connect() as connection: + context.configure(connection=connection, target_metadata=target_metadata) + with context.begin_transaction(): + context.run_migrations() + + +if context.is_offline_mode(): + run_migrations_offline() +else: + run_migrations_online() \ No newline at end of file diff --git a/migrations/script.py.mako b/migrations/script.py.mako new file mode 100644 index 00000000..fbc4b07d --- /dev/null +++ b/migrations/script.py.mako @@ -0,0 +1,26 @@ +"""${message} + +Revision ID: ${up_revision} +Revises: ${down_revision | comma,n} +Create Date: ${create_date} + +""" +from typing import Sequence, Union + +from alembic import op +import sqlalchemy as sa +${imports if imports else ""} + +# revision identifiers, used by Alembic. +revision: str = ${repr(up_revision)} +down_revision: Union[str, None] = ${repr(down_revision)} +branch_labels: Union[str, Sequence[str], None] = ${repr(branch_labels)} +depends_on: Union[str, Sequence[str], None] = ${repr(depends_on)} + + +def upgrade() -> None: + ${upgrades if upgrades else "pass"} + + +def downgrade() -> None: + ${downgrades if downgrades else "pass"} diff --git a/migrations/versions/447472b8acec_create_initial_schema.py b/migrations/versions/447472b8acec_create_initial_schema.py new file mode 100644 index 00000000..0cf534f1 --- /dev/null +++ b/migrations/versions/447472b8acec_create_initial_schema.py @@ -0,0 +1,83 @@ +"""create initial schema + +Revision ID: <оставь тот, что сгенерировал alembic> +Revises: +Create Date: <оставь> +""" +from __future__ import annotations + +from alembic import op + +# revision identifiers, used by Alembic. +revision = "447472b8acec" +down_revision = None +branch_labels = None +depends_on = None + + +def upgrade() -> None: + op.execute(""" + CREATE TABLE users ( + id UUID PRIMARY KEY, + username TEXT NOT NULL UNIQUE, + display_name TEXT NOT NULL, + password_hash TEXT NOT NULL, + created_at TIMESTAMPTZ NOT NULL + ) + """) + + op.execute(""" + CREATE TABLE chats ( + id UUID PRIMARY KEY, + title TEXT NOT NULL, + created_at TIMESTAMPTZ NOT NULL + ) + """) + + op.execute(""" + CREATE TABLE 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) + ) + """) + + op.execute(""" + CREATE INDEX chat_members_user_idx ON chat_members (user_id) + """) + + op.execute(""" + CREATE TABLE 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 + ) + """) + + op.execute(""" + CREATE INDEX messages_history_idx ON messages (chat_id, created_at, id) + """) + + op.execute(""" + CREATE TABLE sessions ( + token_hash TEXT PRIMARY KEY, + user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE, + expires_at TIMESTAMPTZ NOT NULL, + created_at TIMESTAMPTZ NOT NULL + ) + """) + + op.execute(""" + CREATE INDEX sessions_user_idx ON sessions (user_id) + """) + + +def downgrade() -> None: + op.execute("DROP TABLE IF EXISTS sessions") + op.execute("DROP TABLE IF EXISTS messages") + op.execute("DROP INDEX IF EXISTS chat_members_user_idx") + op.execute("DROP TABLE IF EXISTS chat_members") + op.execute("DROP TABLE IF EXISTS chats") + op.execute("DROP TABLE IF EXISTS users") \ No newline at end of file diff --git a/requirements.txt b/requirements.txt new file mode 100755 index 00000000..d0d86d54 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,8 @@ +fastapi==0.115.0 +uvicorn[standard]==0.30.6 +pydantic==2.9.2 +psycopg[binary]==3.2.3 +alembic==1.13.3 +argon2-cffi==23.1.0 +psycopg-pool==3.2.3 +redis==5.1.1 \ No newline at end of file diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100755 index 00000000..f685f460 --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,19 @@ +#!/bin/sh +set -eu + +cd "$(dirname "$0")/.." + +docker compose --env-file .env restart postgres +docker compose --env-file .env restart api + +i=0 +while [ $i -lt 60 ]; do + if docker compose --env-file .env ps api | grep -q "healthy"; then + exit 0 + fi + sleep 1 + i=$((i + 1)) +done + +echo "api did not become healthy in 60 seconds" >&2 +exit 1 \ No newline at end of file diff --git a/src/__init__.py b/src/__init__.py new file mode 100755 index 00000000..e69de29b diff --git a/src/auth.py b/src/auth.py new file mode 100644 index 00000000..63c64df0 --- /dev/null +++ b/src/auth.py @@ -0,0 +1,112 @@ +from __future__ import annotations + +import hashlib +import os +import secrets +from datetime import datetime, timedelta, timezone +from typing import Optional + +import psycopg +from argon2 import PasswordHasher +from argon2.exceptions import VerifyMismatchError, VerificationError, InvalidHashError + +from .db import transaction + +_hasher = PasswordHasher() + + +def hash_password(password: str) -> str: + return _hasher.hash(password) + + +def verify_password(password: str, password_hash: str) -> bool: + try: + _hasher.verify(password_hash, password) + return True + except (VerifyMismatchError, VerificationError, InvalidHashError): + return False + + +def _now() -> datetime: + return datetime.now(timezone.utc) + + +def _ttl_seconds() -> int: + return int(os.environ.get("SESSION_TTL_SECONDS", "3600")) + + +def _generate_token() -> str: + return secrets.token_urlsafe(32) + + +def _token_hash(token: str) -> str: + return hashlib.sha256(token.encode("utf-8")).hexdigest() + + +def create_session(user_id: str) -> dict: + from . import cache + + token = _generate_token() + ttl = _ttl_seconds() + expires_at = _now() + timedelta(seconds=ttl) + token_hash = _token_hash(token) + with transaction() as conn: + with conn.cursor() as cur: + cur.execute( + """ + INSERT INTO sessions (token_hash, user_id, expires_at, created_at) + VALUES (%s, %s, %s, %s) + """, + (token_hash, user_id, expires_at, _now()), + ) + cache.set_user_id(token_hash, user_id, ttl) + return {"token": token, "expires_at": expires_at} + + +def get_user_id_by_token(token: str) -> Optional[str]: + from . import cache + + token_hash = _token_hash(token) + + cached = cache.get_user_id(token_hash) + if cached is not None: + return cached + + with transaction() as conn: + with conn.cursor() as cur: + cur.execute( + """ + SELECT user_id, expires_at + FROM sessions + WHERE token_hash = %s + """, + (token_hash,), + ) + row = cur.fetchone() + if row is None: + return None + + now = _now() + if row["expires_at"] <= now: + return None + + user_id = str(row["user_id"]) + ttl = int((row["expires_at"] - now).total_seconds()) + cache.set_user_id(token_hash, user_id, ttl) + return user_id + + +def revoke_session(token: str) -> bool: + from . import cache + + token_hash = _token_hash(token) + with transaction() as conn: + with conn.cursor() as cur: + cur.execute( + "DELETE FROM sessions WHERE token_hash = %s", + (token_hash,), + ) + deleted = cur.rowcount > 0 + if deleted: + cache.invalidate(token_hash) + return deleted \ No newline at end of file diff --git a/src/cache.py b/src/cache.py new file mode 100644 index 00000000..1415d033 --- /dev/null +++ b/src/cache.py @@ -0,0 +1,182 @@ +from __future__ import annotations + +import logging +import os +import time +from typing import Optional, Set + +import redis + +log = logging.getLogger("messenger.cache") + +_client: Optional[redis.Redis] = None +_failures: int = 0 +_MAX_FAILURES_BEFORE_DISABLE: int = 3 +_REVOKED_TTL_SECONDS: int = int(os.environ.get("REVOKED_TTL_SECONDS", "86400")) +_pending_revocations: Set[str] = set() +_pending_sessions: dict[str, tuple[str, int]] = {} + + +def _cache_url() -> Optional[str]: + return os.environ.get("CACHE_URL") + + +def init_cache() -> None: + global _client, _failures + url = _cache_url() + if not url: + log.warning("CACHE_URL not set; running without cache") + _client = None + return + try: + client = redis.Redis.from_url( + url, + decode_responses=True, + socket_connect_timeout=1.0, + socket_timeout=1.0, + ) + client.ping() + _client = client + _failures = 0 + _replay_pending_revocations(client) + + log.info("cache connected (session prefix flushed, %d pending revocations replayed)", + len(_pending_revocations)) + except Exception as exc: + log.warning("cache unavailable at startup: %s; running in degraded mode", exc) + _client = None + + +def _flush_session_prefix(client: redis.Redis) -> None: + """Удаляет все ключи session:*. Кэш — не источник истины, это безопасно.""" + try: + cursor = 0 + deleted = 0 + while True: + cursor, keys = client.scan(cursor=cursor, match="session:*", count=500) + if keys: + client.delete(*keys) + deleted += len(keys) + if cursor == 0: + break + if deleted: + log.info("flushed %d stale session keys after cache (re)connect", deleted) + except Exception as exc: + log.warning("failed to flush session prefix: %s", exc) + + +def _replay_pending_revocations(client: redis.Redis) -> None: + """Пробует записать в Valkey отзывы, накопленные пока он был недоступен.""" + global _pending_revocations + if not _pending_revocations: + return + still_pending: Set[str] = set() + for token_hash in _pending_revocations: + try: + client.setex(f"revoked:{token_hash}", _REVOKED_TTL_SECONDS, "1") + except Exception: + still_pending.add(token_hash) + _pending_revocations = still_pending + + +def close_cache() -> None: + global _client + if _client is not None: + try: + _client.close() + except Exception: + pass + _client = None + + +def _note_failure() -> None: + global _client, _failures + _failures += 1 + if _failures >= _MAX_FAILURES_BEFORE_DISABLE and _client is not None: + log.warning( + "cache disabled after %d consecutive failures; running in degraded mode", + _failures, + ) + try: + _client.close() + except Exception: + pass + _client = None + + +def _note_success() -> None: + global _failures + _failures = 0 + + +def is_available() -> bool: + return _client is not None + + +# ---------- tombstone (revoked) ---------- + +def mark_revoked(token_hash: str) -> None: + if _client is None: + _pending_revocations.add(token_hash) + log.warning("cache unavailable; revocation queued locally (%d pending)", + len(_pending_revocations)) + return + try: + _client.setex(f"revoked:{token_hash}", _REVOKED_TTL_SECONDS, "1") + _note_success() + except Exception as exc: + log.warning("mark_revoked failed: %s", exc) + _pending_revocations.add(token_hash) + _note_failure() + + +def is_revoked(token_hash: str) -> bool: + if _client is None: + return False + try: + exists = _client.exists(f"revoked:{token_hash}") + _note_success() + return exists == 1 + except Exception as exc: + log.warning("is_revoked failed: %s", exc) + _note_failure() + return False + + +# ---------- session cache ---------- + +def get_user_id(token_hash: str) -> Optional[str]: + if _client is None: + return None + try: + value = _client.get(f"session:{token_hash}") + _note_success() + return value + except Exception as exc: + log.warning("cache get failed: %s", exc) + _note_failure() + return None + + +def set_user_id(token_hash: str, user_id: str, ttl_seconds: int) -> None: + if _client is None: + return + if ttl_seconds <= 0: + return + try: + _client.setex(f"session:{token_hash}", ttl_seconds, user_id) + _note_success() + except Exception as exc: + log.warning("cache set failed: %s", exc) + _note_failure() + + +def invalidate(token_hash: str) -> None: + if _client is None: + return + try: + _client.delete(f"session:{token_hash}") + _note_success() + except Exception as exc: + log.warning("cache delete failed: %s", exc) + _note_failure() \ No newline at end of file diff --git a/src/db.py b/src/db.py new file mode 100644 index 00000000..d0455b67 --- /dev/null +++ b/src/db.py @@ -0,0 +1,72 @@ +from __future__ import annotations + +import os +from contextlib import contextmanager +from typing import Iterator + +import psycopg +from psycopg.rows import dict_row +from psycopg_pool import ConnectionPool + + +_pool: ConnectionPool | None = None + + +def _database_url() -> str: + url = os.environ.get("DATABASE_URL") + if not url: + raise RuntimeError("DATABASE_URL environment variable is required") + return url + + +from psycopg_pool import ConnectionPool + +def init_pool(min_size: int = 1, max_size: int = 10) -> None: + global _pool + if _pool is not None: + return + + dsn = _database_url() + sep = "&" if "?" in dsn else "?" + dsn_with_opts = ( + dsn + + sep + + "options=" + + "-c%20statement_timeout%3D5000" + + "%20-c%20lock_timeout%3D3000" + + "%20-c%20idle_in_transaction_session_timeout%3D10000" + ) + + _pool = ConnectionPool( + conninfo=dsn_with_opts, + min_size=min_size, + max_size=max_size, + kwargs={"row_factory": dict_row}, + open=True, + timeout=5.0, + check=ConnectionPool.check_connection, + max_lifetime=120, + max_idle=60, + ) + + +def close_pool() -> None: + global _pool + if _pool is not None: + _pool.close() + _pool = None + + +@contextmanager +def connection() -> Iterator[psycopg.Connection]: + if _pool is None: + raise RuntimeError("Connection pool is not initialized") + with _pool.connection() as conn: + yield conn + + +@contextmanager +def transaction() -> Iterator[psycopg.Connection]: + with connection() as conn: + with conn.transaction(): + yield conn \ No newline at end of file diff --git a/src/errors.py b/src/errors.py new file mode 100755 index 00000000..1c735f24 --- /dev/null +++ b/src/errors.py @@ -0,0 +1,65 @@ +from __future__ import annotations + +import uuid +from typing import Callable + +from fastapi import Request +from fastapi.responses import JSONResponse +from starlette.middleware.base import BaseHTTPMiddleware + +from .store import ApiError + + +REQUEST_ID_HEADER = "X-Request-Id" + + +class RequestIdMiddleware(BaseHTTPMiddleware): + async def dispatch(self, request: Request, call_next: Callable): + rid = request.headers.get(REQUEST_ID_HEADER) or uuid.uuid4().hex + request.state.request_id = rid + response = await call_next(request) + response.headers[REQUEST_ID_HEADER] = rid + return response + + +def _envelope(code: str, message: str, request_id: str) -> dict: + return {"error": {"code": code, "message": message, "request_id": request_id}} + + +def _rid(request: Request) -> str: + return getattr(request.state, "request_id", None) or uuid.uuid4().hex + + +async def api_error_handler(request: Request, exc: Exception) -> JSONResponse: + assert isinstance(exc, ApiError) + response = JSONResponse( + status_code=exc.status, + content=_envelope(exc.code, exc.message, _rid(request)), + ) + if exc.status == 401: + scheme = "Bearer" + if request.url.path == "/api/v1/auth/sessions": + scheme = "Basic" + response.headers["WWW-Authenticate"] = f'{scheme} realm="messenger"' + return response + + +async def validation_handler(request: Request, exc: Exception) -> JSONResponse: + return JSONResponse( + status_code=400, + content=_envelope("invalid_request", "Request validation failed", _rid(request)), + ) + + +async def json_decode_handler(request: Request, exc: Exception) -> JSONResponse: + return JSONResponse( + status_code=400, + content=_envelope("invalid_request", "Malformed JSON", _rid(request)), + ) + + +async def unhandled_handler(request: Request, exc: Exception) -> JSONResponse: + return JSONResponse( + status_code=500, + content=_envelope("internal_error", "Internal error", _rid(request)), + ) \ No newline at end of file diff --git a/src/main.py b/src/main.py new file mode 100755 index 00000000..bfdddc37 --- /dev/null +++ b/src/main.py @@ -0,0 +1,239 @@ +from __future__ import annotations + +import logging +import os +from contextlib import asynccontextmanager +from typing import Optional + +from fastapi import Depends, FastAPI, Header, Query, Request, Response +from fastapi.exceptions import RequestValidationError +from fastapi.responses import JSONResponse +from starlette.exceptions import HTTPException as StarletteHTTPException + +from . import auth +from .db import close_pool, init_pool +from .errors import ( + RequestIdMiddleware, + _envelope, + _rid, + api_error_handler, + json_decode_handler, + unhandled_handler, + validation_handler, +) +from .schemas import ( + Chat, + ChatPage, + CreateChat, + CreateMessage, + CreateUser, + Health, + Message, + MessagePage, + Session, + User, +) +from .store import ApiError, BadRequest, Conflict, NotFound, Unauthorized, store, iso +from .cache import close_cache, init_cache + +logging.basicConfig( + level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s" +) +log = logging.getLogger("messenger") + + +@asynccontextmanager +async def lifespan(app: FastAPI): + init_pool() + init_cache() + log.info("db pool and cache initialized") + try: + yield + finally: + close_cache() + close_pool() + log.info("db pool and cache closed") + + +app = FastAPI(title="MTUSI Messenger lab2", version="1.2.0", lifespan=lifespan) +app.add_middleware(RequestIdMiddleware) + +app.add_exception_handler(ApiError, api_error_handler) +app.add_exception_handler(RequestValidationError, validation_handler) +app.add_exception_handler(Exception, unhandled_handler) + + +@app.exception_handler(StarletteHTTPException) +async def _http_exc(request: Request, exc: StarletteHTTPException): + code = "not_found" if exc.status_code == 404 else "invalid_request" + return JSONResponse( + status_code=exc.status_code, + content=_envelope(code, str(exc.detail), _rid(request)), + ) + + +# ---------- зависимости ---------- + +def _parse_basic(header_value: str) -> tuple[str, str]: + """Разбирает `Basic base64(username:password)`. Бросает Unauthorized.""" + import base64 + if not header_value.lower().startswith("basic "): + raise Unauthorized("Basic authentication required") + try: + raw = base64.b64decode(header_value.split(" ", 1)[1], validate=True) + decoded = raw.decode("utf-8") + username, _, password = decoded.partition(":") + if not username: + raise ValueError("empty username") + return username, password + except Exception: + raise Unauthorized("Invalid Basic credentials") from None + + +def _bearer_token(authorization: Optional[str]) -> str: + if not authorization: + raise Unauthorized("Missing Authorization header") + parts = authorization.split(" ", 1) + if len(parts) != 2 or parts[0].lower() != "bearer": + raise Unauthorized("Bearer token required") + token = parts[1].strip() + if not token: + raise Unauthorized("Empty bearer token") + return token + + +def current_user_id( + authorization: Optional[str] = Header(default=None), +) -> str: + token = _bearer_token(authorization) + user_id = auth.get_user_id_by_token(token) + if user_id is None: + raise Unauthorized("Invalid or expired token") + return user_id + + +# ---------- health ---------- + +@app.get("/health/live", response_model=Health) +def liveness(): + return {"status": "ok"} + + +@app.get("/health/ready", response_model=Health) +def readiness(): + try: + from .db import transaction + with transaction() as conn: + with conn.cursor() as cur: + cur.execute("SELECT 1") + except Exception: + return JSONResponse( + status_code=503, + content=_envelope("unavailable", "Database unavailable", "readiness"), + ) + return {"status": "ok"} + + +# ---------- users ---------- + +@app.post("/api/v1/users", status_code=201, response_model=User) +def register_user(body: CreateUser): + password_hash = auth.hash_password(body.password) + return store.create_user(body.username, body.display_name, password_hash) + + +@app.get("/api/v1/users/me", response_model=User) +def me(user_id: str = Depends(current_user_id)): + user = store.get_user(user_id) + if user is None: + raise Unauthorized("User not found") + return user + + +# ---------- auth ---------- + +@app.post("/api/v1/auth/sessions", status_code=201, response_model=Session) +def create_session(authorization: Optional[str] = Header(default=None)): + username, password = _parse_basic(authorization or "") + row = store.get_user_by_username(username) + if row is None or not auth.verify_password(password, row["password_hash"]): + raise Unauthorized("Invalid credentials") + session = auth.create_session(str(row["id"])) + user = store.get_user(str(row["id"])) + if user is None: + raise Unauthorized("User not found") + return { + "token": session["token"], + "token_type": "Bearer", + "expires_at": iso(session["expires_at"]), + "user": user, + } + + +@app.delete("/api/v1/auth/sessions/current", status_code=204) +def logout(authorization: Optional[str] = Header(default=None)): + token = _bearer_token(authorization) + user_id = auth.get_user_id_by_token(token) + if user_id is None: + raise Unauthorized("Invalid or expired token") + auth.revoke_session(token) + return Response(status_code=204) + + +# ---------- chats ---------- + +@app.post("/api/v1/chats", status_code=201, response_model=Chat) +def create_chat(body: CreateChat, user_id: str = Depends(current_user_id)): + return store.create_chat(body.title, body.member_ids, user_id) + + +@app.get("/api/v1/chats", response_model=ChatPage) +def list_chats( + limit: int = Query(default=50, ge=1, le=100), + cursor: Optional[str] = Query(default=None, min_length=1), + user_id: str = Depends(current_user_id), +): + items, next_cursor = store.list_chats(user_id, limit, cursor) + return {"items": items, "next_cursor": next_cursor} + + +@app.get("/api/v1/chats/{chat_id}", response_model=Chat) +def get_chat(chat_id: str, user_id: str = Depends(current_user_id)): + chat = store.get_chat(chat_id, user_id) + if chat is None: + raise NotFound() + return chat + + +# ---------- messages ---------- + +@app.post( + "/api/v1/chats/{chat_id}/messages", status_code=201, response_model=Message +) +def create_message( + chat_id: str, body: CreateMessage, user_id: str = Depends(current_user_id) +): + return store.add_message(chat_id, user_id, body.text) + + +@app.get("/api/v1/chats/{chat_id}/messages", response_model=MessagePage) +def list_messages( + chat_id: str, + limit: int = Query(default=50, ge=1, le=100), + cursor: Optional[str] = Query(default=None, min_length=1), + user_id: str = Depends(current_user_id), +): + items, next_cursor = store.list_messages(chat_id, user_id, limit, cursor) + return {"items": items, "next_cursor": next_cursor} + + +def main() -> None: + import uvicorn + + host = os.environ.get("APP_HOST", "0.0.0.0") + port = int(os.environ.get("APP_PORT", "8080")) + uvicorn.run("src.main:app", host=host, port=port, log_level="info") + + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/src/schemas.py b/src/schemas.py new file mode 100755 index 00000000..96f08994 --- /dev/null +++ b/src/schemas.py @@ -0,0 +1,135 @@ +from __future__ import annotations + +import re +import uuid +from typing import List, Optional + +from pydantic import BaseModel, ConfigDict, Field, field_validator + +USERNAME_RE = re.compile(r"^[a-z0-9_]{3,32}$") + + +class StrictModel(BaseModel): + model_config = ConfigDict(extra="forbid", str_strip_whitespace=False) + + +# ---------- Users ---------- + +class CreateUser(StrictModel): + username: str = Field(min_length=3, max_length=32) + display_name: str = Field(min_length=1, max_length=100) + password: str = Field(min_length=12, max_length=128) + + @field_validator("username") + @classmethod + def _username(cls, v: str) -> str: + if not USERNAME_RE.match(v): + raise ValueError("username must match [a-z0-9_]{3,32}") + return v + + @field_validator("display_name") + @classmethod + def _display_name(cls, v: str) -> str: + if not v.strip(): + raise ValueError("display_name must not be blank") + if len(v) > 100: + raise ValueError("display_name too long") + return v + + +class User(StrictModel): + id: str + username: str + display_name: str + created_at: str + + +# ---------- Chats ---------- + +class CreateChat(StrictModel): + 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 _title(cls, v: str) -> str: + if not v.strip(): + raise ValueError("title must not be blank") + return v + + @field_validator("member_ids") + @classmethod + def _members(cls, v: List[str]) -> List[str]: + if len(set(v)) != len(v): + raise ValueError("member_ids must be unique") + for item in v: + try: + uuid.UUID(item) + except ValueError as exc: + raise ValueError("member_ids must be UUIDs") from exc + return v + + +class Chat(StrictModel): + id: str + title: str + member_ids: List[str] + created_at: str + + +class ChatPage(StrictModel): + items: List[Chat] + next_cursor: Optional[str] = None + + +# ---------- Messages ---------- + +class CreateMessage(StrictModel): + text: str = Field(min_length=1, max_length=4000) + + @field_validator("text") + @classmethod + def _text(cls, v: str) -> str: + if not v.strip(): + raise ValueError("text must not be blank") + if len(v) > 4000: + raise ValueError("text too long") + return v + + +class Message(StrictModel): + id: str + chat_id: str + sender_id: str + text: str + created_at: str + + +class MessagePage(StrictModel): + items: List[Message] + next_cursor: Optional[str] = None + + +# ---------- Sessions ---------- + +class Session(StrictModel): + token: str = Field(min_length=32) + token_type: str = Field(default="Bearer") + expires_at: str + user: User + + +# ---------- Misc ---------- + +class Health(StrictModel): + status: str = "ok" + + +class ErrorBody(StrictModel): + code: str + message: str + request_id: str + + +class ErrorEnvelope(StrictModel): + error: ErrorBody \ No newline at end of file diff --git a/src/store.py b/src/store.py new file mode 100755 index 00000000..b86bd4f1 --- /dev/null +++ b/src/store.py @@ -0,0 +1,332 @@ +from __future__ import annotations + +import base64 +import json +import uuid +from datetime import datetime, timezone +from typing import List, Optional, Tuple + +import psycopg +from psycopg.errors import UniqueViolation + +from .db import transaction + + +# ---------- ошибки ---------- + +class ApiError(Exception): + status = 500 + code = "internal_error" + + def __init__(self, message: str = "Internal error") -> None: + super().__init__(message) + self.message = message + + +class BadRequest(ApiError): + status = 400 + code = "invalid_request" + + +class Unauthorized(ApiError): + status = 401 + code = "unauthorized" + + +class NotFound(ApiError): + status = 404 + code = "not_found" + + +class Conflict(ApiError): + status = 409 + code = "conflict" + + +# ---------- утилиты ---------- + +def _now() -> datetime: + return datetime.now(timezone.utc) + + +def iso(dt: datetime) -> str: + return dt.astimezone(timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%fZ") + + +def _user_dict(row: dict) -> dict: + return { + "id": str(row["id"]), + "username": row["username"], + "display_name": row["display_name"], + "created_at": iso(row["created_at"]), + } + + +def _chat_dict(row: dict, member_ids: List[str]) -> dict: + return { + "id": str(row["id"]), + "title": row["title"], + "member_ids": member_ids, + "created_at": iso(row["created_at"]), + } + + +def _message_dict(row: dict) -> dict: + return { + "id": str(row["id"]), + "chat_id": str(row["chat_id"]), + "sender_id": str(row["sender_id"]), + "text": row["text"], + "created_at": iso(row["created_at"]), + } + + +# ---------- курсор ---------- + +def _encode_cursor(scope: str, created_at: str, item_id: str) -> str: + payload = json.dumps( + {"s": scope, "t": created_at, "i": item_id}, separators=(",", ":") + ).encode() + return base64.urlsafe_b64encode(payload).decode().rstrip("=") + + +def _decode_cursor(scope: str, cursor: str) -> Tuple[str, str]: + pad = "=" * (-len(cursor) % 4) + try: + raw = base64.urlsafe_b64decode(cursor + pad) + data = json.loads(raw) + if data.get("s") != scope: + raise ValueError("scope mismatch") + return data["t"], data["i"] + except Exception as exc: + raise BadRequest("invalid cursor") from exc + + +# ---------- Store ---------- + +class Store: + + # ---- users ---- + + def create_user( + self, username: str, display_name: str, password_hash: str + ) -> dict: + uid = str(uuid.uuid4()) + now = _now() + try: + with transaction() as conn: + with conn.cursor() as cur: + cur.execute( + """ + INSERT INTO users (id, username, display_name, password_hash, created_at) + VALUES (%s, %s, %s, %s, %s) + """, + (uid, username, display_name, password_hash, now), + ) + except UniqueViolation: + raise Conflict("username already taken") from None + return { + "id": uid, + "username": username, + "display_name": display_name, + "created_at": iso(now), + } + + def get_user(self, user_id: str) -> Optional[dict]: + with transaction() as conn: + with conn.cursor() as cur: + cur.execute("SELECT * FROM users WHERE id = %s", (user_id,)) + row = cur.fetchone() + return _user_dict(row) if row else None + + def get_user_by_username(self, username: str) -> Optional[dict]: + """Возвращает полную строку, включая password_hash (для входа).""" + with transaction() as conn: + with conn.cursor() as cur: + cur.execute("SELECT * FROM users WHERE username = %s", (username,)) + row = cur.fetchone() + return row + + # ---- chats ---- + + def create_chat( + self, title: str, member_ids: List[str], creator_id: str + ) -> dict: + if creator_id not in member_ids: + raise BadRequest("creator must be in member_ids") + + with transaction() as conn: + with conn.cursor() as cur: + cur.execute( + "SELECT id FROM users WHERE id = ANY(%s)", + (member_ids,), + ) + found = {str(r["id"]) for r in cur.fetchall()} + missing = set(member_ids) - found + if missing: + raise BadRequest("unknown member_id") + + cid = str(uuid.uuid4()) + now = _now() + with transaction() as conn: + with conn.cursor() as cur: + cur.execute( + "INSERT INTO chats (id, title, created_at) VALUES (%s, %s, %s)", + (cid, title, now), + ) + cur.executemany( + "INSERT INTO chat_members (chat_id, user_id) VALUES (%s, %s)", + [(cid, uid) for uid in member_ids], + ) + return { + "id": cid, + "title": title, + "member_ids": list(member_ids), + "created_at": iso(now), + } + + def get_chat(self, chat_id: str, viewer_id: str) -> Optional[dict]: + with transaction() as conn: + with conn.cursor() as cur: + cur.execute( + """ + SELECT c.* FROM chats c + JOIN chat_members m ON m.chat_id = c.id + WHERE c.id = %s AND m.user_id = %s + """, + (chat_id, viewer_id), + ) + row = cur.fetchone() + if row is None: + return None + cur.execute( + "SELECT user_id FROM chat_members WHERE chat_id = %s ORDER BY user_id", + (chat_id,), + ) + members = [str(r["user_id"]) for r in cur.fetchall()] + return _chat_dict(row, members) + + def list_chats( + self, viewer_id: str, limit: int, cursor: Optional[str] + ) -> Tuple[List[dict], Optional[str]]: + scope = "chats:" + viewer_id + params: list = [viewer_id] + where_cursor = "" + if cursor: + t, i = _decode_cursor(scope, cursor) + where_cursor = "AND (c.created_at, c.id) > (%s, %s)" + params.extend([t, i]) + params.append(limit + 1) # +1, чтобы узнать, есть ли следующая страница + + with transaction() as conn: + with conn.cursor() as cur: + cur.execute( + f""" + SELECT c.id, c.title, c.created_at + FROM chats c + JOIN chat_members m ON m.chat_id = c.id + WHERE m.user_id = %s {where_cursor} + ORDER BY c.created_at, c.id + LIMIT %s + """, + params, + ) + rows = cur.fetchall() + + has_more = len(rows) > limit + page = rows[:limit] + + result = [] + for row in page: + cur.execute( + "SELECT user_id FROM chat_members WHERE chat_id = %s ORDER BY user_id", + (row["id"],), + ) + members = [str(r["user_id"]) for r in cur.fetchall()] + result.append(_chat_dict(row, members)) + + next_cursor = None + if has_more and page: + last = page[-1] + next_cursor = _encode_cursor(scope, iso(last["created_at"]), str(last["id"])) + return result, next_cursor + + # ---- messages ---- + + def add_message(self, chat_id: str, sender_id: str, text: str) -> dict: + mid = str(uuid.uuid4()) + now = _now() + with transaction() as conn: + with conn.cursor() as cur: + cur.execute( + "SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s", + (chat_id, sender_id), + ) + if cur.fetchone() is None: + raise NotFound() + cur.execute( + """ + INSERT INTO messages (id, chat_id, sender_id, text, created_at) + VALUES (%s, %s, %s, %s, %s) + """, + (mid, chat_id, sender_id, text, now), + ) + return { + "id": mid, + "chat_id": chat_id, + "sender_id": sender_id, + "text": text, + "created_at": iso(now), + } + + def list_messages( + self, + chat_id: str, + viewer_id: str, + limit: int, + cursor: Optional[str], + ) -> Tuple[List[dict], Optional[str]]: + with transaction() as conn: + with conn.cursor() as cur: + cur.execute( + "SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s", + (chat_id, viewer_id), + ) + if cur.fetchone() is None: + raise NotFound() + + scope = "chat:" + chat_id + params: list = [chat_id] + where_cursor = "" + if cursor: + t, i = _decode_cursor(scope, cursor) + where_cursor = "AND (created_at, id) > (%s, %s)" + params.extend([t, i]) + params.append(limit + 1) + + with transaction() as conn: + with conn.cursor() as cur: + cur.execute( + f""" + SELECT id, chat_id, sender_id, text, created_at + FROM messages + WHERE chat_id = %s {where_cursor} + ORDER BY created_at, id + LIMIT %s + """, + params, + ) + rows = cur.fetchall() + + has_more = len(rows) > limit + page = rows[:limit] + result = [_message_dict(r) for r in page] + + next_cursor = None + if has_more and page: + last = page[-1] + next_cursor = _encode_cursor(scope, iso(last["created_at"]), str(last["id"])) + return result, next_cursor + + +store = Store() \ No newline at end of file diff --git a/student_tests/seed_messages.py b/student_tests/seed_messages.py new file mode 100644 index 00000000..401e3044 --- /dev/null +++ b/student_tests/seed_messages.py @@ -0,0 +1,89 @@ +"""Генерация тестовых сообщений для EXPLAIN. + +Создаёт пользователя, чат и N сообщений. N по умолчанию 10 000. +Запуск: + python3 seed_messages.py --base-url http://localhost:8080 --count 10000 +""" +from __future__ import annotations + +import argparse +import base64 +import json +import time +import urllib.error +import urllib.request +import uuid + + +def call(base: str, method: str, path: str, headers: dict | None = None, body: dict | None = None) -> tuple[int, dict | None]: + data = None + h = dict(headers or {}) + if body is not None: + data = json.dumps(body, ensure_ascii=False).encode("utf-8") + h["Content-Type"] = "application/json" + req = urllib.request.Request(base + path, data=data, headers=h, method=method) + try: + resp = urllib.request.urlopen(req, timeout=30) + raw = resp.read() + return resp.code, json.loads(raw) if raw else None + except urllib.error.HTTPError as e: + raw = e.read() + try: + return e.code, json.loads(raw) if raw else None + except Exception: + return e.code, None + + +def main() -> None: + p = argparse.ArgumentParser() + p.add_argument("--base-url", default="http://localhost:8080") + p.add_argument("--count", type=int, default=10000) + p.add_argument("--batch", type=int, default=500, help="Сообщений между progress-логами") + args = p.parse_args() + base = args.base_url.rstrip("/") + + username = "seed_" + uuid.uuid4().hex[:12] + password = "seed-pass-1234567890" + + # Регистрация + code, user = call(base, "POST", "/api/v1/users", body={ + "username": username, "display_name": "Seed User", "password": password, + }) + assert code == 201, f"register failed: {code} {user}" + + # Логин + cred = base64.b64encode(f"{username}:{password}".encode()).decode() + code, session = call(base, "POST", "/api/v1/auth/sessions", headers={"Authorization": "Basic " + cred}) + assert code == 201, f"login failed: {code} {session}" + token = session["token"] + user_id = session["user"]["id"] + + # Чат + code, chat = call(base, "POST", "/api/v1/chats", headers={"Authorization": "Bearer " + token}, body={ + "title": "Seed chat", "member_ids": [user_id], + }) + assert code == 201, f"chat failed: {code} {chat}" + chat_id = chat["id"] + print(f"chat_id: {chat_id}") + print(f"seeding {args.count} messages...") + + started = time.monotonic() + for i in range(args.count): + code, msg = call( + base, "POST", f"/api/v1/chats/{chat_id}/messages", + headers={"Authorization": "Bearer " + token}, + body={"text": f"seed-{i:06d}-{uuid.uuid4().hex[:8]}"}, + ) + assert code == 201, f"message {i} failed: {code} {msg}" + if (i + 1) % args.batch == 0: + elapsed = time.monotonic() - started + rps = (i + 1) / elapsed + print(f" {i + 1}/{args.count} ({rps:.0f} msg/s)") + + elapsed = time.monotonic() - started + print(f"done: {args.count} messages in {elapsed:.1f}s ({args.count / elapsed:.0f} msg/s)") + print(f"chat_id: {chat_id}") + + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/student_tests/test_cache_failure.py b/student_tests/test_cache_failure.py new file mode 100755 index 00000000..00ab135a --- /dev/null +++ b/student_tests/test_cache_failure.py @@ -0,0 +1,100 @@ +"""Проверка отказа Valkey и корректности logout при недоступном кэше.""" +from __future__ import annotations +import base64, json, subprocess, sys, time, urllib.error, urllib.request, uuid + +BASE = "http://localhost:8080" +COMPOSE = ["docker", "compose", "--env-file", ".env"] + +def call(method, path, headers=None, body=None): + data = None + h = dict(headers or {}) + if body is not None: + data = json.dumps(body).encode() + h["Content-Type"] = "application/json" + req = urllib.request.Request(BASE + path, data=data, headers=h, method=method) + try: + r = urllib.request.urlopen(req, timeout=10) + raw = r.read() + return r.code, json.loads(raw) if raw else None + except urllib.error.HTTPError as e: + raw = e.read() + try: + return e.code, json.loads(raw) if raw else None + except Exception: + return e.code, None + +def stop_cache(): + subprocess.run(COMPOSE + ["stop", "cache"], check=True) + +def start_cache(): + subprocess.run(COMPOSE + ["start", "cache"], check=True) + +def restart_api(): + subprocess.run(COMPOSE + ["restart", "api"], check=True) + +def wait_ready(deadline=60): + end = time.monotonic() + deadline + while time.monotonic() < end: + try: + code, _ = call("GET", "/health/ready") + if code == 200: + return + except Exception: + pass + time.sleep(1) + raise SystemExit("API did not become ready") + +def main(): + username = "cf_" + uuid.uuid4().hex[:10] + password = "cache-fail-pass-1234567890" + code, _ = call("POST", "/api/v1/users", body={ + "username": username, "display_name": "Cache Fail", "password": password, + }) + assert code == 201, code + + cred = base64.b64encode(f"{username}:{password}".encode()).decode() + code, session = call("POST", "/api/v1/auth/sessions", + headers={"Authorization": "Basic " + cred}) + assert code == 201, code + token = session["token"] + + # Токен работает + code, _ = call("GET", "/api/v1/users/me", + headers={"Authorization": "Bearer " + token}) + assert code == 200, code + + # Останавливаем Valkey + stop_cache() + time.sleep(2) + + # API должно работать в degraded mode + code, _ = call("GET", "/api/v1/users/me", + headers={"Authorization": "Bearer " + token}) + assert code == 200, f"degraded mode failed: {code}" + print("PASS: API works with Valkey down (degraded mode)") + + # Logout при недоступном Valkey должен вернуть 204 + code, _ = call("DELETE", "/api/v1/auth/sessions/current", + headers={"Authorization": "Bearer " + token}) + assert code == 204, f"logout with cache down returned {code}" + print("PASS: logout with cache down returned 204") + + # Токен немедленно недействителен (проверка через БД) + code, _ = call("GET", "/api/v1/users/me", + headers={"Authorization": "Bearer " + token}) + assert code == 401, f"revoked token still works with cache down: {code}" + print("PASS: revoked token rejected while cache down") + + # Поднимаем Valkey, рестартуем API — критический регресс-тест + start_cache() + time.sleep(2) + restart_api() + wait_ready() + + code, _ = call("GET", "/api/v1/users/me", + headers={"Authorization": "Bearer " + token}) + assert code == 401, f"REGRESSION: revoked token resurrected after cache restart: {code}" + print("PASS: revoked token still 401 after cache restart (regression fixed)") + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/student_tests/test_db_failure.py b/student_tests/test_db_failure.py new file mode 100755 index 00000000..4dfe26d5 --- /dev/null +++ b/student_tests/test_db_failure.py @@ -0,0 +1,127 @@ +"""Проверка отказа PostgreSQL: таймаут запроса и восстановление.""" +from __future__ import annotations +import base64, json, subprocess, sys, time, urllib.error, urllib.request, uuid + +BASE = "http://localhost:8080" +COMPOSE = ["docker", "compose", "--env-file", ".env"] + + +def call(method, path, headers=None, body=None, timeout=10): + data = None + h = dict(headers or {}) + if body is not None: + data = json.dumps(body).encode() + h["Content-Type"] = "application/json" + req = urllib.request.Request(BASE + path, data=data, headers=h, method=method) + try: + r = urllib.request.urlopen(req, timeout=timeout) + raw = r.read() + return r.code, json.loads(raw) if raw else None + except urllib.error.HTTPError as e: + raw = e.read() + try: + return e.code, json.loads(raw) if raw else None + except Exception: + return e.code, None + + +def stop_db(): + """Останавливает контейнер Postgres. TCP-соединения рвутся, psycopg + получает ошибку мгновенно — это честный сценарий 'БД упала'.""" + subprocess.run(COMPOSE + ["stop", "postgres"], check=True) + + +def start_db(): + """Поднимает Postgres. Не падает, если уже запущен.""" + subprocess.run(COMPOSE + ["start", "postgres"], + capture_output=True, check=False) + time.sleep(3) + + +def restart_api(): + """Пересоздаёт API, чтобы пул соединений не держал мёртвые сессии.""" + subprocess.run(COMPOSE + ["restart", "api"], + capture_output=True, check=False) + + +def wait_ready(deadline=60): + end = time.monotonic() + deadline + while time.monotonic() < end: + try: + code, _ = call("GET", "/health/ready", timeout=5) + if code == 200: + return + except Exception: + pass + time.sleep(1) + raise SystemExit("API did not become ready") + + +def ensure_clean_state(): + """Возвращает стек в рабочее состояние, если предыдущий запуск оставил + Postgres остановленным или пул API в плохом состоянии.""" + subprocess.run(COMPOSE + ["start", "postgres"], + capture_output=True, check=False) + time.sleep(3) + # API перезапускаем, потому что после stop Postgres пул мог забиться + # мёртвыми соединениями, и первый запрос упадёт по PoolTimeout. + restart_api() + wait_ready() + + +def main(): + ensure_clean_state() + + # Регистрация и логин — до всякого stop, чтобы тест не падал на подготовке + username = "dbf_" + uuid.uuid4().hex[:10] + password = "db-fail-pass-1234567890" + + code, _ = call("POST", "/api/v1/users", body={ + "username": username, "display_name": "DB Fail", "password": password, + }) + assert code == 201, f"failed to create user before stop: {code}" + + cred = base64.b64encode(f"{username}:{password}".encode()).decode() + code, session = call("POST", "/api/v1/auth/sessions", + headers={"Authorization": "Basic " + cred}) + assert code == 201, f"failed to login before stop: {code}" + token = session["token"] + + stop_db() + try: + time.sleep(0.5) + + # Запрос к БД должен упасть быстро (TCP порван, psycopg сразу + # получает ошибку соединения). Проверяем < 8 секунд. + start = time.monotonic() + try: + code, _ = call("GET", "/api/v1/users/me", + headers={"Authorization": "Bearer " + token}, timeout=15) + except Exception as exc: + elapsed = time.monotonic() - start + raise SystemExit(f"request hung: {elapsed:.1f}s, {type(exc).__name__}") + elapsed = time.monotonic() - start + assert elapsed < 8, f"request took {elapsed:.1f}s (>8s), DB down not handled fast enough" + assert code in (500, 503), f"expected 500/503 during DB down, got {code}" + print(f"PASS: DB down returned {code} in {elapsed:.1f}s (<8s)") + + # health/ready должен вернуть 503, пока БД недоступна + code, _ = call("GET", "/health/ready", timeout=15) + assert code == 503, f"expected 503 from ready, got {code}" + print("PASS: /health/ready returned 503 during DB down") + finally: + # Гарантированно поднимаем Postgres даже при падении выше. + start_db() + # Перезапускаем API, чтобы пул пересоздал соединения с вернувшейся БД. + restart_api() + wait_ready() + + # Проверяем, что данные и сессия сохранены после восстановления. + code, _ = call("GET", "/api/v1/users/me", + headers={"Authorization": "Bearer " + token}) + assert code == 200, f"session lost after DB recovery: {code}" + print("PASS: session and data preserved after DB recovery") + + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/student_tests/test_expiry.py b/student_tests/test_expiry.py new file mode 100644 index 00000000..68d553c1 --- /dev/null +++ b/student_tests/test_expiry.py @@ -0,0 +1,72 @@ +"""Тест expiry: сессия истекает через SESSION_TTL_SECONDS. + +Запуск: + SESSION_TTL_SECONDS=2 docker compose up -d --build api + python3 test_expiry.py --base-url http://localhost:8080 + +Тест создаёт пользователя, логинится, ждёт TTL+1 секунду, проверяет 401. +""" +from __future__ import annotations + +import base64 +import json +import sys +import time +import urllib.error +import urllib.request +import uuid + +BASE = sys.argv[sys.argv.index("--base-url") + 1] if "--base-url" in sys.argv else "http://localhost:8080" + + +def call(method: str, path: str, headers: dict | None = None, body: dict | None = None) -> tuple[int, dict | None]: + data = None + h = dict(headers or {}) + if body is not None: + data = json.dumps(body, ensure_ascii=False).encode("utf-8") + h["Content-Type"] = "application/json" + req = urllib.request.Request(BASE + path, data=data, headers=h, method=method) + try: + resp = urllib.request.urlopen(req, timeout=10) + raw = resp.read() + return resp.code, json.loads(raw) if raw else None + except urllib.error.HTTPError as e: + raw = e.read() + try: + return e.code, json.loads(raw) if raw else None + except Exception: + return e.code, None + + +def main() -> None: + username = "exp_" + uuid.uuid4().hex[:12] + password = "expiry-pass-1234567890" + + # Регистрация + code, user = call("POST", "/api/v1/users", body={ + "username": username, "display_name": "Expiry Test", "password": password, + }) + assert code == 201, f"register failed: {code} {user}" + + # Логин + cred = base64.b64encode(f"{username}:{password}".encode()).decode() + code, session = call("POST", "/api/v1/auth/sessions", headers={"Authorization": "Basic " + cred}) + assert code == 201, f"login failed: {code} {session}" + token = session["token"] + print(f"session expires_at: {session['expires_at']}") + + # Сразу после логина — токен работает + code, me = call("GET", "/api/v1/users/me", headers={"Authorization": "Bearer " + token}) + assert code == 200, f"token should work immediately, got {code}" + print("immediately after login: 200 OK") + + # Ждём истечения + time.sleep(3) + code, err = call("GET", "/api/v1/users/me", headers={"Authorization": "Bearer " + token}) + assert code == 401, f"expired token must give 401, got {code}" + print(f"after TTL: {code} (expected 401)") + print("PASS: expiry — token invalidated after SESSION_TTL_SECONDS") + + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/student_tests/test_races.py b/student_tests/test_races.py new file mode 100644 index 00000000..6087556a --- /dev/null +++ b/student_tests/test_races.py @@ -0,0 +1,116 @@ +"""Тест гонки регистрации: два параллельных POST /users с одним username. + +Ожидаем: один 201, второй 409, в БД ровно один пользователь. +Гонка гарантируется через threading.Barrier — оба запроса стартуют одновременно. +""" +from __future__ import annotations + +import json +import sys +import threading +import urllib.error +import urllib.request +import uuid +from concurrent.futures import ThreadPoolExecutor + +BASE = sys.argv[sys.argv.index("--base-url") + 1] if "--base-url" in sys.argv else "http://localhost:8080" + + +def post_user(username: str, display_name: str, password: str) -> int: + """Отправляет POST /users, возвращает HTTP-код.""" + body = json.dumps( + {"username": username, "display_name": display_name, "password": password}, + ensure_ascii=False, + ).encode("utf-8") + req = urllib.request.Request( + BASE + "/api/v1/users", + data=body, + headers={"Content-Type": "application/json"}, + method="POST", + ) + try: + resp = urllib.request.urlopen(req, timeout=10) + return resp.code + except urllib.error.HTTPError as e: + return e.code + + +def main() -> None: + username = "race_" + uuid.uuid4().hex[:12] + password = "race-pass-1234567890" + barrier = threading.Barrier(2) + + def worker(display_name: str) -> int: + barrier.wait() # старт одновременно + return post_user(username, display_name, password) + + with ThreadPoolExecutor(max_workers=2) as pool: + results = list(pool.map(worker, ["Первый", "Второй"])) + + results.sort() + print(f"HTTP codes: {results}") + + assert results == [201, 409], f"expected [201, 409], got {results}" + print(f"PASS: race — one 201, one 409 for username={username}") + +def test_chat_rollback() -> None: + """Попытка создать чат с несуществующим участником → 400, чат не создан.""" + import base64 + + # Создаём пользователя + username = "rollback_" + uuid.uuid4().hex[:8] + password = "rollback-pass-1234567890" + code = post_user(username, "Rollback", password) + assert code == 201, f"failed to create user: {code}" + + # Логинимся + cred = base64.b64encode(f"{username}:{password}".encode()).decode() + req = urllib.request.Request( + BASE + "/api/v1/auth/sessions", + headers={"Authorization": "Basic " + cred}, + method="POST", + ) + resp = urllib.request.urlopen(req) + session = json.loads(resp.read()) + token = session["token"] + user_id = session["user"]["id"] + + # Пытаемся создать чат с несуществующим UUID + fake_user = "00000000-0000-4000-8000-000000000000" + body = json.dumps( + {"title": "Bad chat", "member_ids": [user_id, fake_user]}, + ensure_ascii=False, + ).encode("utf-8") + req = urllib.request.Request( + BASE + "/api/v1/chats", + data=body, + headers={ + "Content-Type": "application/json", + "Authorization": "Bearer " + token, + }, + method="POST", + ) + try: + urllib.request.urlopen(req, timeout=10) + code = 200 + except urllib.error.HTTPError as e: + code = e.code + + assert code == 400, f"expected 400 for unknown member, got {code}" + + # Проверяем, что чат не создан — list chats не должен его содержать + req = urllib.request.Request( + BASE + "/api/v1/chats?limit=100", + headers={"Authorization": "Bearer " + token}, + ) + resp = urllib.request.urlopen(req) + page = json.loads(resp.read()) + titles = [c["title"] for c in page["items"]] + assert "Bad chat" not in titles, f"chat was created despite failure: {titles}" + + print("PASS: rollback — chat not created when member is unknown") + + +if __name__ == "__main__": + main() + test_chat_rollback() \ No newline at end of file