diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..df701465 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,25 @@ +FROM python:3.12.7-slim + +ENV PYTHONUNBUFFERED=1 \ + PYTHONDONTWRITEBYTECODE=1 \ + PIP_NO_CACHE_DIR=1 \ + PYTHONPATH=/app/src + +WORKDIR /app + +COPY requirements.txt ./ +RUN pip install --no-cache-dir -r requirements.txt + +COPY src ./src +COPY migrations ./migrations + +RUN groupadd --system app && useradd --system --gid app --uid 10001 app \ + && chown -R app:app /app +USER app + +EXPOSE 8080 + +HEALTHCHECK --interval=10s --timeout=3s --start-period=25s --retries=6 \ + 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 ["python", "-m", "app"] diff --git a/REPORT.md b/REPORT.md index e42f2b05..a5f3196c 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,165 @@ -# Отчёт — лабораторная 2 + Отчёт — лабораторная 2 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO +- Автор, группа: Унру Денис, БПИ2303 +- Целевая оценка; 3 + (Redis/Valkey как кэш сессий, параметризованные запросы и пул, индекс истории с EXPLAIN на 10 000 + сообщениях, автоматические проверки expiry/logout/гонки/отказа). - Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +- Использованные источники, библиотеки: FastAPI 0.115.6, Uvicorn 0.34.0, + psycopg2-binary 2.9.10, redis 5.2.1, argon2-cffi 23.1.0; PostgreSQL 16.4, Valkey 7.2.6. + Все решения проверены запуском стенда. Первичные материалы: см. README курса. ## Запуск из чистого clone -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +Prerequisites: Docker Engine/Desktop с Compose v2 и доступом к сети для сборки образа. +Версии зафиксированы: Python 3.12.7-slim (образ `python:3.12.7-slim`), `postgres:16.4`, +`valkey/valkey:7.2.6`. Никаких хостовых БД/Redis не требуется. + +```sh +# 1. Локальные синтетические секреты (файл в .gitignore, в Git не попадает) +cp .env.example .env +# заполните как минимум POSTGRES_USER/POSTGRES_PASSWORD/POSTGRES_DB, +# APP_HOST/APP_PORT/APP_ENV/SESSION_TTL_SECONDS/SESSION_STORE, DB_POOL_MIN/DB_POOL_MAX + +# 2. Проверка конфигурации и сборка +docker compose --env-file .env config --quiet +docker compose --env-file .env up -d --build + +# 3. Дождаться готовности (миграции применяются автоматически при старте API) +until curl -fsS http://localhost:8080/health/ready; do sleep 1; done + +# 4. Проверки +python scripts/check_contract.py # = make check +python tests/smoke.py --base-url http://localhost:8080 # = make test +python tests/resilience.py --mode persistence --action-script scripts/restart.sh \ + --base-url http://localhost:8080 # = make test-persistence +python tests/load.py --duration 30 --concurrency 4 --output evidence/load.json + +# 5. Безопасная остановка (volumes сохраняются) +docker compose --env-file .env stop + +# 6. Намеренное удаление только учебных данных +docker compose --env-file .env down -v +``` + +На Windows хук `scripts/restart.sh` (POSIX) запускается через `scripts/restart.cmd` +(та же команда `docker compose restart`); проверка сохранности при этом эквивалентна. +`make` в среде разработки отсутствовал, поэтому в отчёте приведены эквивалентные python-команды. ## Архитектура и решения -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +``` +Клиент --HTTP--> API (FastAPI/Uvicorn, python:3.12.7-slim, non-root) + | psycopg2 pool (bounded, statement_timeout) + v + PostgreSQL 16.4 <-- источник истины: users, chats, chat_members, + (named volume pgdata) messages, sessions, schema_migrations + ^ + | cache-aside (TTL = остаток жизни сессии) + Valkey 7.2.6 (named volume valkeydata, AOF) <-- кэш сессий +``` + +- **Источник истины** — PostgreSQL. Пользователи, чаты, членство, сообщения и **сессии** + хранятся в БД, поэтому данные и действующие сессии переживают рестарт API и хранилищ. +- **Сессии**: opaque-токен (`secrets.token_urlsafe(32)`, ≥256 бит). В БД пишется только + SHA-256-фингерпринт токена (сам токен не хранится). Срок жизни задаёт `SESSION_TTL_SECONDS` + (по умолчанию 3600). Отзыв — `revoked_at` + удаление ключа из кэша. +- **Пароли**: Argon2id (`argon2-cffi`). Пароль никогда не возвращается в `User`. +- **Valkey/Redis — кэш, а не источник истины.** При каждом аутентифицированном запросе сначала + проверяется кэш (`sess:`); промах или недоступность кэша → запрос к PostgreSQL. + TTL кэша равен остатку жизни сессии, инвалидация — при logout/отзыве. Так как истина в БД, + потеря кэша не приводит к потере данных, а анонимный запрос не принимается доверенным. +- **Транзакционные границы**: регистрация пользователя и создание сессии — одиночные INSERT; + создание чата — одна транзакция (проверка существования участников + INSERT чата + + INSERT участников); отправка сообщения — проверка членства и INSERT в одной транзакции. + Гонка регистрации одинакового username разрешается уникальным ограничением `users.username`, + нарушение перехватывается и превращается в `409 conflict`. +- **Ограничения и валидация**: длина и формат полей проверяются приложением (код-поинты) и + дублируются CHECK-ограничениями БД; лишние поля и неверные типы → `400`; `additionalProperties:false` + соблюдается для всех ответов. +- **Пагинация истории** — keyset по `(created_at, id)` по возрастанию, курсор непрозрачный и + привязан к ресурсу (`chat_id`/`user_id`); выборка `LIMIT n+1` определяет `next_cursor` без + полного сканирования истории. + +### Соответствие `.env.example` реальной конфигурации + +| `.env.example` | Реальная переменная | Смысл | +| --- | --- | --- | +| `APP_HOST` / `APP_PORT` | то же | bind-адрес/порт Uvicorn | +| `APP_ENV` | то же | метка окружения (лог) | +| `SESSION_TTL_SECONDS` | то же | TTL сессии, по умолчанию 3600 | +| `SESSION_STORE` | то же | `postgres` или `postgres+redis` | +| `DATABASE_URL_FILE` | `DATABASE_URL` **или** `DATABASE_URL_FILE` | DSN PostgreSQL (поддержаны оба способа) | +| `CACHE_URL_FILE` | `CACHE_URL` **или** `CACHE_URL_FILE` | DSN Valkey/Redis (кэш) | +| — | `DB_POOL_MIN` / `DB_POOL_MAX` | границы пула соединений | + +Приложение читает значение напрямую из переменной, а при её отсутствии — из файла, +указанного в `*_FILE` (совместимо с Docker secrets). Секретов в Git нет: `.env` в `.gitignore`. + +### Роли инфраструктуры + +| Роль | service | Образ (пиннинг) | healthcheck | volume | сеть | credentials | +| --- | --- | --- | --- | --- | --- | --- | +| api | `api` | сборка из `Dockerfile` (python:3.12.7-slim) | `HEALTHCHECK` + `/health/live` | — | `backend` | env из `.env` | +| postgres | `postgres` | `postgres:16.4` | `pg_isready` | `pgdata` | `backend` | `POSTGRES_*` из `.env` | +| cache | `valkey` | `valkey/valkey:7.2.6` | `valkey-cli ping` | `valkeydata` (AOF) | `backend` | `CACHE_URL` из `.env` | + +Bootstrap: миграции `migrations/*.sql` применяются самим API при старте (таблица +`schema_migrations`, advisory lock). Повторный запуск не дублирует данные. ## Доказательства критериев | Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | | --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | - -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +| Структура skeleton | `python scripts/check_contract.py` | `PASS: offline skeleton structure...` | `evidence/check.txt` | +| Публичный smoke | `python tests/smoke.py --base-url http://localhost:8080` | `PASS: lab2 public API scenario` | `evidence/smoke.txt` | +| Данные и сессия переживают рестарт | `python tests/resilience.py --mode persistence --action-script scripts/restart.sh ...` | `PASS: persistence preserved confirmed data and existing session`; StartedAt всех контейнеров изменился, volumes сохранены | `evidence/persistence.txt` | +| PostgreSQL = источник истины, ключи, уникальность, миграции с нуля | миграция `migrations/0001_init.sql` + лог старта API | `applied migration 0001_init`; таблицы/индексы создаются на пустом volume | `evidence/persistence.txt` | +| Атомарное создание чата | код `store.create_chat` + одна транзакция | rollback при неизвестном участнике; гонка username → `409` | `student-tests/test_lab2.py` | +| Basic только на `POST /auth/sessions`, остальное — Bearer, expiry и отзыв | `student-tests/test_lab2.py` | wrong password `401` (Basic), `X-User-Id` не работает, logout `204`→`401` (Bearer) | `evidence/cache_outage.txt` | +| Истечение сессии при коротком TTL | `--expiry` c `SESSION_TTL_SECONDS=2` | `PASS: session expired after 2s TTL` | `evidence/expiry_check.txt` | +| Параметризованные запросы, пул, таймауты (уровень 4) | код `db.py`/`store.py` | пул `ThreadedConnectionPool`, `statement_timeout`, все SQL параметризованы | код | +| Индекс истории обоснован EXPLAIN на ≥10 000 сообщений (уровень 4) | `student-tests/perf_explain.sql` | `Index Scan using messages_chat_created_id_idx`, 5 буферов, 0.028 ms против Seq Scan 361 буфер, 2.550 ms | `evidence/explain.txt`, `evidence/explain_no_index.txt` | +| Отказ Redis/БД (уровень 4) | `--cache-check` и `stop postgres` | аутентификация живёт без кэша; `/health/ready` и аутентифицированные запросы → `503 unavailable` при недоступной БД, `/health/live` → `200` | `evidence/cache_outage.txt`, `evidence/dependency_outage.txt` | ## Эксперименты и отказы -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +Оборудование: один Docker-host (Windows, Docker Desktop 29.4.3, Linux engine), образы без +явных CPU/RAM-лимитов. Прогрев не выделялся; данные синтетические. + +Нагрузка (closed-loop POST сообщений, `tests/load.py`, см. `evidence/load.json`): + +| Профиль | Длительность | Concurrency | Успешные RPS | Ошибки | p50 | p95 | p99 | +| --- | --- | --- | --- | --- | --- | --- | --- | +| 4 воркера | 15 с | 4 | 236.6 | 0 (0.0) | 16.0 ms | 32.0 ms | 47.0 ms | + +Ограничения измерения: генератор закрытого контура ограничен клиентом и подвержен coordinated +omission; latency только по успешным запросам; это пропускная способность HTTP-подтверждений, а +не счётчик COMMIT. + +План запроса (10 000 сообщений в чате, keyset-страница): + +| Вариант | План | Buffers | Execution | +| --- | --- | --- | --- | +| С индексом | `Index Scan using messages_chat_created_id_idx` | shared hit=5 | 0.028 ms | +| Без индекса (indexscan off) | `Seq Scan` + `Sort` | shared hit=361 | 2.550 ms | + +Отказы: | Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | | --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +| `docker compose restart` (api+postgres+valkey, volumes сохранены) | данные и прежний токен доступны | те же чат/сообщение по прежнему токену | рестарт всех контейнеров; потерь нет | +| Остановка Valkey (кэш) | аутентификация продолжает работать через БД | `/users/me` по прежнему токену → `200` | кэш пересоберётся сам; потерь нет | +| Остановка PostgreSQL | `/health/ready` деградирует | `/health/ready` → `503 unavailable`, аутентифицированный запрос → `503 unavailable`, `/health/live` → `200` | `200` после старта БД; потерь нет | ## Ограничения и следующие шаги -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +- Учебное упрощение: один Docker-host; эксперимент **не** даёт отказоустойчивости к потере + самого host, а единственная БД и отсутствие LB/реплик не делают стенд HA. Redis выбран как + кэш, а не единственное хранилище сессий, поэтому его потеря безопасна. +- Durability PostgreSQL определяется настройками по умолчанию образа; отдельно проверялось + сохранение при рестарте контейнеров с сохранением volume, а не при потере диска. +- Не реализовано (вне минимума этой лабы): изменение участников/удаление сообщений, rate limiting, + идемпотентность отправки (`Idempotency-Key`) и `X-Instance-Id` — это переходы lab3+. +- Уровень 4 подтверждён частично: кэш сессий, пул/таймауты, индекс и отказы проверены; отдельный + «трек 5» (согласованность кэша или backup/restore) не заявлен и не измерялся. \ No newline at end of file diff --git a/compose.expiry.yaml b/compose.expiry.yaml new file mode 100644 index 00000000..f3906b2b --- /dev/null +++ b/compose.expiry.yaml @@ -0,0 +1,6 @@ +services: + api: + environment: + SESSION_TTL_SECONDS: 2 + ports: + - "8081:8080" diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 00000000..89c6ef56 --- /dev/null +++ b/compose.yaml @@ -0,0 +1,57 @@ +name: mtusi-lab2 + +services: + postgres: + image: postgres:16.4 + environment: + POSTGRES_USER: ${POSTGRES_USER} + POSTGRES_PASSWORD: ${POSTGRES_PASSWORD} + POSTGRES_DB: ${POSTGRES_DB} + volumes: + - pgdata:/var/lib/postgresql/data + healthcheck: + test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER} -d ${POSTGRES_DB}"] + interval: 5s + timeout: 3s + retries: 20 + networks: [backend] + + valkey: + image: valkey/valkey:7.2.6 + command: ["valkey-server", "--appendonly", "yes", "--save", "", "--appendfsync", "everysec"] + volumes: + - valkeydata:/data + healthcheck: + test: ["CMD", "valkey-cli", "ping"] + interval: 5s + timeout: 3s + retries: 20 + networks: [backend] + + api: + build: . + depends_on: + postgres: + condition: service_healthy + valkey: + condition: service_healthy + environment: + APP_HOST: ${APP_HOST} + APP_PORT: ${APP_PORT} + APP_ENV: ${APP_ENV} + SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS} + SESSION_STORE: ${SESSION_STORE} + DB_POOL_MIN: ${DB_POOL_MIN} + DB_POOL_MAX: ${DB_POOL_MAX} + DATABASE_URL: postgresql://${POSTGRES_USER}:${POSTGRES_PASSWORD}@postgres:5432/${POSTGRES_DB} + CACHE_URL: redis://valkey:6379/0 + ports: + - "${APP_PORT}:${APP_PORT}" + networks: [backend] + +volumes: + pgdata: + valkeydata: + +networks: + backend: diff --git a/evidence/cache_outage.txt b/evidence/cache_outage.txt new file mode 100644 index 00000000..2347bc2d --- /dev/null +++ b/evidence/cache_outage.txt @@ -0,0 +1,6 @@ +PASS: wrong password -> 401 with Basic challenge +PASS: X-User-Id ignored for authentication +PASS: logout revokes the session +PASS: concurrent registration -> one 201 and seven 409 +PASS: authentication survives a cache outage +PASS: student lab2 checks completed diff --git a/evidence/check.txt b/evidence/check.txt new file mode 100644 index 00000000..b62af9c5 --- /dev/null +++ b/evidence/check.txt @@ -0,0 +1 @@ +PASS: offline skeleton structure, local refs and Python syntax; application NOT tested. diff --git a/evidence/dependency_outage.txt b/evidence/dependency_outage.txt new file mode 100644 index 00000000..b15b8ee5 --- /dev/null +++ b/evidence/dependency_outage.txt @@ -0,0 +1,7 @@ +== postgres stopped == +{"status":"ok"} [HTTP 200] +{"error":{"code":"unavailable","message":"Хранилище недоступно","request_id":"d4ff2da4d2ca40f59b9a3e9986f8fbe2"}} [HTTP 503] +{"error":{"code":"unavailable","message":"Хранилище недоступно","request_id":"7a513917f13846c89194b62f5c1f5e2f"}} [HTTP 503] +== postgres restarted == +{"status":"ok"} [HTTP 200] +{"error":{"code":"unauthorized","message":"Требуется аутентификация","request_id":"6ce854c975964caab1cf0c6d65adabc5"}} [HTTP 401] diff --git a/evidence/expiry_check.txt b/evidence/expiry_check.txt new file mode 100644 index 00000000..e21befe8 --- /dev/null +++ b/evidence/expiry_check.txt @@ -0,0 +1,6 @@ +PASS: wrong password -> 401 with Basic challenge +PASS: X-User-Id ignored for authentication +PASS: logout revokes the session +PASS: concurrent registration -> one 201 and seven 409 +PASS: session expired after 2s TTL +PASS: student lab2 checks completed diff --git a/evidence/explain.txt b/evidence/explain.txt new file mode 100644 index 00000000..3fd25f03 --- /dev/null +++ b/evidence/explain.txt @@ -0,0 +1,37 @@ +INSERT 0 0 +INSERT 0 0 +INSERT 0 0 +INSERT 0 10000 +ANALYZE +=== message count === + messages +---------- + 10000 +(1 row) + +=== EXPLAIN (ANALYZE, BUFFERS): keyset page in the middle of history === + QUERY PLAN +---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + Limit (cost=0.42..17.91 rows=50 width=70) (actual time=0.006..0.014 rows=50 loops=1) + Buffers: shared hit=5 + -> Index Scan using messages_chat_created_id_idx on messages (cost=0.42..1719.51 rows=4913 width=70) (actual time=0.006..0.011 rows=50 loops=1) + Index Cond: ((chat_id = '00000000-0000-4000-8000-0000000000aa'::uuid) AND (ROW(created_at, id) > ROW((now() - '01:23:20'::interval), '00000000-0000-4000-8000-000000000000'::uuid))) + Buffers: shared hit=5 + Planning: + Buffers: shared hit=20 + Planning Time: 0.056 ms + Execution Time: 0.028 ms +(9 rows) + +=== EXPLAIN (ANALYZE, BUFFERS): first page (no cursor) === + QUERY PLAN +-------------------------------------------------------------------------------------------------------------------------------------------------------- + Limit (cost=0.41..11.29 rows=50 width=70) (actual time=21.930..21.937 rows=50 loops=1) + Buffers: shared hit=266 read=126 dirtied=126 + -> Index Scan using messages_chat_created_id_idx on messages (cost=0.41..2176.76 rows=10000 width=70) (actual time=21.929..21.933 rows=50 loops=1) + Index Cond: (chat_id = '00000000-0000-4000-8000-0000000000aa'::uuid) + Buffers: shared hit=266 read=126 dirtied=126 + Planning Time: 0.022 ms + Execution Time: 21.948 ms +(7 rows) + diff --git a/evidence/explain_no_index.txt b/evidence/explain_no_index.txt new file mode 100644 index 00000000..de0997ab --- /dev/null +++ b/evidence/explain_no_index.txt @@ -0,0 +1,22 @@ +SET +SET + QUERY PLAN +------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ + Limit (cost=903.23..903.36 rows=50 width=70) (actual time=2.525..2.529 rows=50 loops=1) + Buffers: shared hit=361 + -> Sort (cost=903.23..915.49 rows=4903 width=70) (actual time=2.525..2.526 rows=50 loops=1) + Sort Key: created_at, id + Sort Method: top-N heapsort Memory: 38kB + Buffers: shared hit=361 + -> Seq Scan on messages (cost=0.00..740.36 rows=4903 width=70) (actual time=0.617..2.086 rows=4982 loops=1) + Filter: ((chat_id = '00000000-0000-4000-8000-0000000000aa'::uuid) AND (ROW(created_at, id) > ROW((now() - '01:23:20'::interval), '00000000-0000-4000-8000-000000000000'::uuid))) + Rows Removed by Filter: 12145 + Buffers: shared hit=355 + Planning: + Buffers: shared hit=106 + Planning Time: 0.203 ms + Execution Time: 2.550 ms +(14 rows) + +RESET +RESET diff --git a/evidence/load.json b/evidence/load.json new file mode 100644 index 00000000..a5f119e1 --- /dev/null +++ b/evidence/load.json @@ -0,0 +1,17 @@ +{ + "lab": 2, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 15.0, + "elapsed_seconds": 15.016, + "concurrency": 4, + "successful_requests": 3553, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 236.614, + "successful_latency_ms": { + "p50": 16.0, + "p95": 32.0, + "p99": 47.0 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." +} diff --git a/evidence/persistence.txt b/evidence/persistence.txt new file mode 100644 index 00000000..749fd29b --- /dev/null +++ b/evidence/persistence.txt @@ -0,0 +1,2 @@ +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..92154196 --- /dev/null +++ b/evidence/smoke.txt @@ -0,0 +1 @@ +PASS: lab2 public API scenario; infrastructure and grading evidence remain separate. diff --git a/migrations/0001_init.sql b/migrations/0001_init.sql new file mode 100644 index 00000000..8ec2ca60 --- /dev/null +++ b/migrations/0001_init.sql @@ -0,0 +1,46 @@ +CREATE TABLE IF NOT EXISTS 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 DEFAULT now(), + CONSTRAINT users_username_format CHECK (username ~ '^[a-z0-9_]{3,32}$'), + CONSTRAINT users_display_name_len CHECK (char_length(display_name) BETWEEN 1 AND 100) +); + +CREATE TABLE IF NOT EXISTS chats ( + id uuid PRIMARY KEY, + title text NOT NULL, + created_at timestamptz NOT NULL DEFAULT now(), + CONSTRAINT chats_title_len CHECK (char_length(title) BETWEEN 1 AND 100) +); + +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, + added_at timestamptz NOT NULL DEFAULT now(), + PRIMARY KEY (chat_id, user_id) +); + +CREATE INDEX IF NOT EXISTS chat_members_user_idx ON chat_members (user_id, chat_id); + +CREATE TABLE IF NOT EXISTS messages ( + id uuid PRIMARY KEY, + chat_id uuid NOT NULL REFERENCES chats (id) ON DELETE CASCADE, + sender_id uuid NOT NULL REFERENCES users (id), + text text NOT NULL, + created_at timestamptz NOT NULL DEFAULT now(), + CONSTRAINT messages_text_len CHECK (char_length(text) BETWEEN 1 AND 4000) +); + +CREATE INDEX IF NOT EXISTS messages_chat_created_id_idx ON messages (chat_id, created_at, id); + +CREATE TABLE IF NOT EXISTS sessions ( + token_hash text PRIMARY KEY, + user_id uuid NOT NULL REFERENCES users (id) ON DELETE CASCADE, + created_at timestamptz NOT NULL DEFAULT now(), + expires_at timestamptz NOT NULL, + revoked_at timestamptz +); + +CREATE INDEX IF NOT EXISTS sessions_user_idx ON sessions (user_id); diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 00000000..f3e354e1 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,5 @@ +fastapi==0.115.6 +uvicorn==0.34.0 +psycopg2-binary==2.9.10 +redis==5.2.1 +argon2-cffi==23.1.0 diff --git a/scripts/restart.cmd b/scripts/restart.cmd new file mode 100644 index 00000000..7c36a6cc --- /dev/null +++ b/scripts/restart.cmd @@ -0,0 +1,8 @@ +@echo off +cd /d "%~dp0.." +if not exist .env ( + echo restart.cmd: .env is missing ^(copy .env.example and fill it^) 1>&2 + exit /b 1 +) +docker compose --env-file .env restart +exit /b %ERRORLEVEL% diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100644 index 00000000..94ab7879 --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,10 @@ +#!/bin/sh +set -eu +cd "$(dirname "$0")/.." + +if [ ! -f .env ]; then + echo "restart.sh: .env is missing (copy .env.example and fill it)" >&2 + exit 1 +fi + +docker compose --env-file .env restart diff --git a/src/app/__init__.py b/src/app/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/src/app/__main__.py b/src/app/__main__.py new file mode 100644 index 00000000..ce6df766 --- /dev/null +++ b/src/app/__main__.py @@ -0,0 +1,7 @@ +import uvicorn + +from .config import settings +from .main import app + +if __name__ == "__main__": + uvicorn.run(app, host=settings.host, port=settings.port, log_level="info", access_log=False) diff --git a/src/app/api.py b/src/app/api.py new file mode 100644 index 00000000..716d58dd --- /dev/null +++ b/src/app/api.py @@ -0,0 +1,276 @@ +import json +import logging +import re +import uuid +from datetime import datetime, timedelta, timezone + +import psycopg2 +from fastapi import APIRouter, Request +from fastapi.responses import JSONResponse, Response + +from . import db, store +from .cache import session_cache +from .config import settings +from .errors import ApiError, conflict, invalid, not_found, unauthorized +from .security import ( + bearer_token, + hash_password, + new_token, + parse_basic, + token_fingerprint, + verify_password, +) +from .serialization import ( + chat_json, + decode_cursor, + encode_cursor, + iso, + message_json, + user_json, +) + +logger = logging.getLogger("app.api") + +router = APIRouter() + +USERNAME_RE = re.compile(r"^[a-z0-9_]{3,32}$") +DEFAULT_LIMIT = 50 +MAX_LIMIT = 100 + + +async def read_json(request, allowed, required): + body = await request.body() + if not body: + raise invalid("Ожидается JSON-тело") + content_type = request.headers.get("content-type", "") + if content_type and "application/json" not in content_type.lower(): + raise ApiError(415, "unsupported_media_type", "Ожидается application/json") + try: + data = json.loads(body.decode("utf-8")) + except (ValueError, UnicodeDecodeError): + raise invalid("Некорректный JSON") + if not isinstance(data, dict): + raise invalid("Ожидается JSON-объект") + if set(data) - set(allowed): + raise invalid("Лишние поля запроса") + if set(required) - set(data): + raise invalid("Отсутствуют обязательные поля") + return data + + +def valid_username(value): + return isinstance(value, str) and USERNAME_RE.match(value) is not None + + +def valid_required_text(value, max_length): + return isinstance(value, str) and 1 <= len(value) <= max_length and value.strip() != "" + + +def valid_password(value): + return isinstance(value, str) and 12 <= len(value) <= 128 + + +def parse_uuid(value): + try: + return str(uuid.UUID(value)) + except (ValueError, AttributeError, TypeError): + raise invalid("Некорректный UUID") + + +def parse_limit(raw): + if raw is None: + return DEFAULT_LIMIT + try: + value = int(raw) + except (ValueError, TypeError): + raise invalid("Некорректный limit") + if value < 1 or value > MAX_LIMIT: + raise invalid("Некорректный limit") + return value + + +def authenticate(request): + token = bearer_token(request.headers.get("authorization")) + if not token: + raise unauthorized() + fingerprint = token_fingerprint(token) + cached = session_cache.get(fingerprint) + if cached and isinstance(cached.get("uid"), str): + return cached["uid"] + with db.cursor() as cur: + row = store.get_valid_session(cur, fingerprint) + if not row: + raise unauthorized() + user_id = str(row["user_id"]) + ttl = int((row["expires_at"] - datetime.now(timezone.utc)).total_seconds()) + session_cache.set(fingerprint, user_id, ttl) + return user_id + + +@router.post("/api/v1/users") +async def register_user(request: Request): + data = await read_json( + request, + allowed={"username", "display_name", "password"}, + required={"username", "display_name", "password"}, + ) + username = data.get("username") + display_name = data.get("display_name") + password = data.get("password") + if not valid_username(username): + raise invalid("Некорректный username") + if not valid_required_text(display_name, 100): + raise invalid("Некорректный display_name") + if not valid_password(password): + raise invalid("Некорректный пароль") + user_id = str(uuid.uuid4()) + password_hash = hash_password(password) + try: + with db.cursor(commit=True) as cur: + row = store.create_user(cur, user_id, username, display_name, password_hash) + except psycopg2.errors.UniqueViolation: + raise conflict("username уже занят") + return JSONResponse(status_code=201, content=user_json(row)) + + +@router.post("/api/v1/auth/sessions") +async def create_session(request: Request): + credentials = parse_basic(request.headers.get("authorization")) + if credentials is None: + raise unauthorized() + username, password = credentials + with db.cursor() as cur: + user = store.get_user_by_username(cur, username) + if not user or not verify_password(user["password_hash"], password): + raise unauthorized() + token = new_token() + fingerprint = token_fingerprint(token) + expires_at = datetime.now(timezone.utc) + timedelta(seconds=settings.session_ttl) + with db.cursor(commit=True) as cur: + store.create_session(cur, fingerprint, str(user["id"]), expires_at) + session_cache.set(fingerprint, str(user["id"]), settings.session_ttl) + return JSONResponse( + status_code=201, + content={ + "token": token, + "token_type": "Bearer", + "expires_at": iso(expires_at), + "user": user_json(user), + }, + ) + + +@router.delete("/api/v1/auth/sessions/current") +async def revoke_current(request: Request): + authenticate(request) + fingerprint = token_fingerprint(bearer_token(request.headers.get("authorization"))) + with db.cursor(commit=True) as cur: + store.revoke_session(cur, fingerprint) + session_cache.delete(fingerprint) + return Response(status_code=204) + + +@router.get("/api/v1/users/me") +async def current_user(request: Request): + user_id = authenticate(request) + with db.cursor() as cur: + user = store.get_user_by_id(cur, user_id) + if not user: + raise unauthorized() + return JSONResponse(status_code=200, content=user_json(user)) + + +@router.post("/api/v1/chats") +async def create_chat(request: Request): + user_id = authenticate(request) + data = await read_json( + request, allowed={"title", "member_ids"}, required={"title", "member_ids"} + ) + title = data.get("title") + member_ids = data.get("member_ids") + if not valid_required_text(title, 100): + raise invalid("Некорректный title") + if not isinstance(member_ids, list) or not 1 <= len(member_ids) <= 100: + raise invalid("Некорректный member_ids") + normalized = [] + for value in member_ids: + if not isinstance(value, str): + raise invalid("member_ids должен содержать UUID") + normalized.append(parse_uuid(value)) + if len(set(normalized)) != len(normalized): + raise invalid("Дубликаты участников") + if user_id not in normalized: + raise invalid("Вызывающий должен входить в member_ids") + with db.cursor(commit=True) as cur: + row = store.create_chat(cur, str(uuid.uuid4()), title, normalized) + return JSONResponse(status_code=201, content=chat_json(row, sorted(normalized))) + + +@router.get("/api/v1/chats") +async def list_chats(request: Request): + user_id = authenticate(request) + limit = parse_limit(request.query_params.get("limit")) + cursor = request.query_params.get("cursor") + after = decode_cursor(cursor, "c", user_id) if cursor else None + with db.cursor() as cur: + rows = store.list_chats(cur, user_id, after, limit + 1) + has_more = len(rows) > limit + rows = rows[:limit] + members = store.chat_members(cur, [str(row["id"]) for row in rows]) + items = [chat_json(row, members.get(str(row["id"]), [])) for row in rows] + next_cursor = None + if has_more and rows: + last = rows[-1] + next_cursor = encode_cursor("c", user_id, iso(last["created_at"]), str(last["id"])) + return JSONResponse(status_code=200, content={"items": items, "next_cursor": next_cursor}) + + +@router.get("/api/v1/chats/{chat_id}") +async def get_chat(chat_id: str, request: Request): + user_id = authenticate(request) + cid = parse_uuid(chat_id) + with db.cursor() as cur: + if not store.is_member(cur, cid, user_id): + raise not_found() + row = store.get_chat(cur, cid) + members = store.chat_members(cur, [cid]) + if not row: + raise not_found() + return JSONResponse(status_code=200, content=chat_json(row, members.get(cid, []))) + + +@router.post("/api/v1/chats/{chat_id}/messages") +async def create_message(chat_id: str, request: Request): + user_id = authenticate(request) + cid = parse_uuid(chat_id) + with db.cursor() as cur: + if not store.is_member(cur, cid, user_id): + raise not_found() + data = await read_json(request, allowed={"text"}, required={"text"}) + text = data.get("text") + if not valid_required_text(text, 4000): + raise invalid("Некорректный text") + with db.cursor(commit=True) as cur: + row = store.create_message(cur, str(uuid.uuid4()), cid, user_id, text) + return JSONResponse(status_code=201, content=message_json(row)) + + +@router.get("/api/v1/chats/{chat_id}/messages") +async def list_messages(chat_id: str, request: Request): + user_id = authenticate(request) + cid = parse_uuid(chat_id) + limit = parse_limit(request.query_params.get("limit")) + cursor = request.query_params.get("cursor") + after = decode_cursor(cursor, "m", cid) if cursor else None + with db.cursor() as cur: + if not store.is_member(cur, cid, user_id): + raise not_found() + rows = store.list_messages(cur, cid, after, limit + 1) + has_more = len(rows) > limit + rows = rows[:limit] + items = [message_json(row) for row in rows] + next_cursor = None + if has_more and rows: + last = rows[-1] + next_cursor = encode_cursor("m", cid, iso(last["created_at"]), str(last["id"])) + return JSONResponse(status_code=200, content={"items": items, "next_cursor": next_cursor}) diff --git a/src/app/cache.py b/src/app/cache.py new file mode 100644 index 00000000..998308e8 --- /dev/null +++ b/src/app/cache.py @@ -0,0 +1,53 @@ +import json +import logging + +import redis + +from .config import settings + +logger = logging.getLogger("app.cache") + +PREFIX = "sess:" + + +class SessionCache: + def __init__(self, url): + self.client = None + if url: + self.client = redis.Redis.from_url( + url, socket_connect_timeout=1, socket_timeout=1, decode_responses=True + ) + + def get(self, fingerprint): + if self.client is None: + return None + try: + value = self.client.get(PREFIX + fingerprint) + except redis.RedisError as exc: + logger.warning("cache get failed: %s", type(exc).__name__) + return None + if not value: + return None + try: + return json.loads(value) + except ValueError: + return None + + def set(self, fingerprint, user_id, ttl_seconds): + if self.client is None or ttl_seconds <= 0: + return + try: + self.client.setex(PREFIX + fingerprint, ttl_seconds, json.dumps({"uid": user_id})) + except redis.RedisError as exc: + logger.warning("cache set failed: %s", type(exc).__name__) + + def delete(self, fingerprint): + if self.client is None: + return + try: + self.client.delete(PREFIX + fingerprint) + except redis.RedisError as exc: + logger.warning("cache delete failed: %s", type(exc).__name__) + + +session_cache = SessionCache(settings.cache_url) diff --git a/src/app/config.py b/src/app/config.py new file mode 100644 index 00000000..bfbe8199 --- /dev/null +++ b/src/app/config.py @@ -0,0 +1,34 @@ +import os +from pathlib import Path + + +def _secret(value_name, file_name): + value = os.environ.get(value_name) + if value: + return value.strip() + path = os.environ.get(file_name) + if path: + candidate = Path(path) + if candidate.is_file(): + return candidate.read_text(encoding="utf-8").strip() + return None + + +class Settings: + def __init__(self): + self.host = os.environ.get("APP_HOST", "0.0.0.0") + self.port = int(os.environ.get("APP_PORT", "8080")) + self.app_env = os.environ.get("APP_ENV", "lab") + self.session_ttl = int(os.environ.get("SESSION_TTL_SECONDS", "3600")) + self.session_store = os.environ.get("SESSION_STORE", "postgres") + self.database_url = _secret("DATABASE_URL", "DATABASE_URL_FILE") + self.cache_url = _secret("CACHE_URL", "CACHE_URL_FILE") + self.pool_min = int(os.environ.get("DB_POOL_MIN", "1")) + self.pool_max = int(os.environ.get("DB_POOL_MAX", "10")) + self.db_statement_timeout_ms = int(os.environ.get("DB_STATEMENT_TIMEOUT_MS", "5000")) + self.db_connect_timeout_s = int(os.environ.get("DB_CONNECT_TIMEOUT_SECONDS", "5")) + default_migrations = Path(__file__).resolve().parents[2] / "migrations" + self.migrations_dir = os.environ.get("MIGRATIONS_DIR", str(default_migrations)) + + +settings = Settings() diff --git a/src/app/db.py b/src/app/db.py new file mode 100644 index 00000000..6cf7e52f --- /dev/null +++ b/src/app/db.py @@ -0,0 +1,107 @@ +import logging +from contextlib import contextmanager +from pathlib import Path + +import psycopg2 +import psycopg2.extras +from psycopg2 import pool as pg_pool + +from .config import settings +from .errors import unavailable + +logger = logging.getLogger("app.db") + +MIGRATION_LOCK = 727001 +_pool = None + + +def init_pool(): + global _pool + if not settings.database_url: + raise RuntimeError("DATABASE_URL / DATABASE_URL_FILE is not configured") + _pool = pg_pool.ThreadedConnectionPool( + settings.pool_min, + settings.pool_max, + settings.database_url, + options="-c statement_timeout={} -c application_name=messenger-api".format( + settings.db_statement_timeout_ms + ), + connect_timeout=settings.db_connect_timeout_s, + ) + logger.info("database pool ready (min=%d max=%d)", settings.pool_min, settings.pool_max) + + +def close_pool(): + global _pool + if _pool is not None: + _pool.closeall() + _pool = None + + +@contextmanager +def cursor(commit=False): + if _pool is None: + raise unavailable("Хранилище недоступно") + try: + conn = _pool.getconn() + except psycopg2.Error as exc: + logger.warning("database connection unavailable: %s", type(exc).__name__) + raise unavailable("Хранилище недоступно") from None + discard = False + try: + cur = conn.cursor(cursor_factory=psycopg2.extras.RealDictCursor) + try: + yield cur + if commit: + conn.commit() + else: + conn.rollback() + finally: + cur.close() + except (psycopg2.OperationalError, psycopg2.InterfaceError) as exc: + discard = True + logger.warning("database connection lost: %s", type(exc).__name__) + raise unavailable("Хранилище недоступно") from None + except Exception: + try: + conn.rollback() + except Exception: + pass + raise + finally: + _pool.putconn(conn, close=discard) + + +def ping(): + with cursor() as cur: + cur.execute("SELECT 1") + cur.fetchone() + + +def run_migrations(): + directory = Path(settings.migrations_dir) + files = sorted(directory.glob("*.sql")) + conn = _pool.getconn() + try: + with conn.cursor() as cur: + cur.execute("SELECT pg_advisory_lock(%s)", (MIGRATION_LOCK,)) + cur.execute( + "CREATE TABLE IF NOT EXISTS schema_migrations (" + "version text PRIMARY KEY, applied_at timestamptz NOT NULL DEFAULT now())" + ) + cur.execute("SELECT version FROM schema_migrations") + applied = {row[0] for row in cur.fetchall()} + for path in files: + version = path.stem + if version in applied: + continue + cur.execute(path.read_text(encoding="utf-8")) + cur.execute("INSERT INTO schema_migrations (version) VALUES (%s)", (version,)) + logger.info("applied migration %s", version) + cur.execute("SELECT pg_advisory_unlock(%s)", (MIGRATION_LOCK,)) + conn.commit() + except Exception: + conn.rollback() + raise + finally: + _pool.putconn(conn) diff --git a/src/app/errors.py b/src/app/errors.py new file mode 100644 index 00000000..ecca2d03 --- /dev/null +++ b/src/app/errors.py @@ -0,0 +1,26 @@ +class ApiError(Exception): + def __init__(self, status, code, message): + super().__init__(message) + self.status = status + self.code = code + self.message = message + + +def invalid(message="Некорректный запрос"): + return ApiError(400, "invalid_request", message) + + +def unauthorized(message="Требуется аутентификация"): + return ApiError(401, "unauthorized", message) + + +def not_found(message="Объект не найден или недоступен"): + return ApiError(404, "not_found", message) + + +def conflict(message="Конфликт состояния"): + return ApiError(409, "conflict", message) + + +def unavailable(message="Сервис временно недоступен"): + return ApiError(503, "unavailable", message) diff --git a/src/app/main.py b/src/app/main.py new file mode 100644 index 00000000..c886d399 --- /dev/null +++ b/src/app/main.py @@ -0,0 +1,106 @@ +import logging +import uuid +from contextlib import asynccontextmanager + +from fastapi import FastAPI, Request +from fastapi.responses import JSONResponse +from starlette.exceptions import HTTPException as StarletteHTTPException + +from . import db +from .api import router +from .config import settings +from .errors import ApiError + +logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(name)s %(message)s") +logger = logging.getLogger("app") + +INSTANCE_ID = uuid.uuid4().hex[:12] + +@asynccontextmanager +async def lifespan(_app): + db.init_pool() + db.run_migrations() + logger.info( + "instance %s ready (env=%s, ttl=%ss, session_store=%s)", + INSTANCE_ID, + settings.app_env, + settings.session_ttl, + settings.session_store, + ) + yield + db.close_pool() + +app = FastAPI( + title="MTUSI Messenger — lab 2", + version="1.2.0", + lifespan=lifespan, + docs_url=None, + redoc_url=None, + openapi_url=None, +) + +def error_payload(request, code, message): + request_id = getattr(request.state, "request_id", None) or uuid.uuid4().hex + return {"error": {"code": code, "message": message, "request_id": request_id}} + + +def challenge_for(request): + if request.url.path == "/api/v1/auth/sessions": + return 'Basic realm="messenger", charset="UTF-8"' + return 'Bearer realm="messenger"' + +@app.middleware("http") +async def request_context(request: Request, call_next): + request_id = request.headers.get("x-request-id") or uuid.uuid4().hex + request.state.request_id = request_id + try: + response = await call_next(request) + except ApiError as exc: + response = JSONResponse(status_code=exc.status, content=error_payload(request, exc.code, exc.message)) + if exc.status == 401: + response.headers["WWW-Authenticate"] = challenge_for(request) + except Exception: + logger.exception("unhandled error") + response = JSONResponse( + status_code=500, content=error_payload(request, "internal_error", "Внутренняя ошибка") + ) + response.headers["X-Request-Id"] = request_id + response.headers["X-Instance-Id"] = INSTANCE_ID + return response + +@app.exception_handler(ApiError) +async def handle_api_error(request: Request, exc: ApiError): + response = JSONResponse(status_code=exc.status, content=error_payload(request, exc.code, exc.message)) + if exc.status == 401: + response.headers["WWW-Authenticate"] = challenge_for(request) + return response + +@app.exception_handler(StarletteHTTPException) +async def handle_http_error(request: Request, exc: StarletteHTTPException): + mapping = { + 400: "invalid_request", + 401: "unauthorized", + 404: "not_found", + 405: "invalid_request", + 415: "unsupported_media_type", + } + code = mapping.get(exc.status_code, "invalid_request") + response = JSONResponse(status_code=exc.status_code, content=error_payload(request, code, "Ошибка запроса")) + if exc.status_code == 401: + response.headers["WWW-Authenticate"] = challenge_for(request) + return response + +@app.get("/health/live") +async def health_live(): + return JSONResponse(status_code=200, content={"status": "ok"}) + +@app.get("/health/ready") +async def health_ready(): + try: + db.ping() + except Exception as exc: + logger.warning("readiness check failed: %s", type(exc).__name__) + raise ApiError(503, "unavailable", "Хранилище недоступно") + return JSONResponse(status_code=200, content={"status": "ok"}) + +app.include_router(router) diff --git a/src/app/security.py b/src/app/security.py new file mode 100644 index 00000000..5b7cc0f4 --- /dev/null +++ b/src/app/security.py @@ -0,0 +1,59 @@ +import base64 +import hashlib +import secrets + +from argon2 import PasswordHasher +from argon2.exceptions import Argon2Error + +_hasher = PasswordHasher() + + +def hash_password(password): + return _hasher.hash(password) + + +def verify_password(password_hash, password): + try: + return _hasher.verify(password_hash, password) + except Argon2Error: + return False + except Exception: + return False + + +def new_token(): + return secrets.token_urlsafe(32) + + +def token_fingerprint(token): + return hashlib.sha256(token.encode("utf-8")).hexdigest() + + +def parse_basic(header): + if not header: + return None + parts = header.split(" ", 1) + if len(parts) != 2 or parts[0].lower() != "basic": + return None + try: + raw = base64.b64decode(parts[1].strip(), validate=True) + except Exception: + return None + try: + decoded = raw.decode("utf-8") + except UnicodeDecodeError: + return None + if ":" not in decoded: + return None + username, password = decoded.split(":", 1) + return username, password + + +def bearer_token(header): + if not header: + return None + parts = header.split(" ", 1) + if len(parts) != 2 or parts[0].lower() != "bearer": + return None + token = parts[1].strip() + return token or None diff --git a/src/app/serialization.py b/src/app/serialization.py new file mode 100644 index 00000000..c157ccc2 --- /dev/null +++ b/src/app/serialization.py @@ -0,0 +1,66 @@ +import base64 +import json +import uuid +from datetime import datetime, timezone + +from .errors import invalid + + +def iso(value): + if value.tzinfo is None: + value = value.replace(tzinfo=timezone.utc) + return value.astimezone(timezone.utc).isoformat(timespec="microseconds").replace("+00:00", "Z") + + +def user_json(row): + return { + "id": str(row["id"]), + "username": row["username"], + "display_name": row["display_name"], + "created_at": iso(row["created_at"]), + } + + +def chat_json(row, member_ids): + return { + "id": str(row["id"]), + "title": row["title"], + "member_ids": member_ids, + "created_at": iso(row["created_at"]), + } + + +def message_json(row): + return { + "id": str(row["id"]), + "chat_id": str(row["chat_id"]), + "sender_id": str(row["sender_id"]), + "text": row["text"], + "created_at": iso(row["created_at"]), + } + + +def encode_cursor(kind, scope, created_at, item_id): + payload = {"k": kind, "s": scope, "t": created_at, "i": item_id} + raw = json.dumps(payload, separators=(",", ":")).encode("utf-8") + return base64.urlsafe_b64encode(raw).decode("ascii").rstrip("=") + + +def decode_cursor(value, kind, scope): + try: + padded = value + "=" * (-len(value) % 4) + data = json.loads(base64.urlsafe_b64decode(padded.encode("ascii")).decode("utf-8")) + except Exception: + raise invalid("Некорректный cursor") + if not isinstance(data, dict) or data.get("k") != kind or data.get("s") != scope: + raise invalid("Некорректный cursor") + created_at = data.get("t") + item_id = data.get("i") + if not isinstance(created_at, str) or not isinstance(item_id, str): + raise invalid("Некорректный cursor") + try: + uuid.UUID(item_id) + datetime.fromisoformat(created_at.replace("Z", "+00:00")) + except (ValueError, AttributeError): + raise invalid("Некорректный cursor") + return created_at, item_id diff --git a/src/app/store.py b/src/app/store.py new file mode 100644 index 00000000..6aaf1e7f --- /dev/null +++ b/src/app/store.py @@ -0,0 +1,135 @@ +from .errors import invalid + + +def create_user(cur, user_id, username, display_name, password_hash): + cur.execute( + "INSERT INTO users (id, username, display_name, password_hash) " + "VALUES (%s, %s, %s, %s) RETURNING id, username, display_name, created_at", + (user_id, username, display_name, password_hash), + ) + return cur.fetchone() + + +def get_user_by_username(cur, username): + cur.execute( + "SELECT id, username, display_name, password_hash, created_at FROM users WHERE username = %s", + (username,), + ) + return cur.fetchone() + + +def get_user_by_id(cur, user_id): + cur.execute( + "SELECT id, username, display_name, created_at FROM users WHERE id = %s", + (user_id,), + ) + return cur.fetchone() + + +def create_session(cur, fingerprint, user_id, expires_at): + cur.execute( + "INSERT INTO sessions (token_hash, user_id, expires_at) VALUES (%s, %s, %s)", + (fingerprint, user_id, expires_at), + ) + + +def get_valid_session(cur, fingerprint): + cur.execute( + "SELECT user_id, expires_at FROM sessions " + "WHERE token_hash = %s AND revoked_at IS NULL AND expires_at > now()", + (fingerprint,), + ) + return cur.fetchone() + + +def revoke_session(cur, fingerprint): + cur.execute( + "UPDATE sessions SET revoked_at = now() WHERE token_hash = %s AND revoked_at IS NULL", + (fingerprint,), + ) + return cur.rowcount + + +def is_member(cur, chat_id, user_id): + cur.execute( + "SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s", + (chat_id, user_id), + ) + return cur.fetchone() is not None + + +def create_chat(cur, chat_id, title, member_ids): + cur.execute( + "SELECT id FROM users WHERE id = ANY(%s::uuid[])", + (list(member_ids),), + ) + found = {str(row["id"]) for row in cur.fetchall()} + if found != set(member_ids): + raise invalid("Неизвестные участники чата") + cur.execute( + "INSERT INTO chats (id, title) VALUES (%s, %s) RETURNING id, title, created_at", + (chat_id, title), + ) + row = cur.fetchone() + cur.executemany( + "INSERT INTO chat_members (chat_id, user_id) VALUES (%s, %s)", + [(chat_id, member) for member in member_ids], + ) + return row + + +def get_chat(cur, chat_id): + cur.execute("SELECT id, title, created_at FROM chats WHERE id = %s", (chat_id,)) + return cur.fetchone() + + +def chat_members(cur, chat_ids): + if not chat_ids: + return {} + cur.execute( + "SELECT chat_id, user_id FROM chat_members WHERE chat_id = ANY(%s::uuid[]) " + "ORDER BY chat_id, user_id", + (list(chat_ids),), + ) + result = {} + for row in cur.fetchall(): + result.setdefault(str(row["chat_id"]), []).append(str(row["user_id"])) + return result + + +def list_chats(cur, user_id, after, limit): + sql = ( + "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" + ) + params = [user_id] + if after is not None: + sql += " AND (c.created_at, c.id) > (%s::timestamptz, %s::uuid)" + params.extend([after[0], after[1]]) + sql += " ORDER BY c.created_at ASC, c.id ASC LIMIT %s" + params.append(limit) + cur.execute(sql, params) + return cur.fetchall() + + +def create_message(cur, message_id, chat_id, sender_id, text): + cur.execute( + "INSERT INTO messages (id, chat_id, sender_id, text) VALUES (%s, %s, %s, %s) " + "RETURNING id, chat_id, sender_id, text, created_at", + (message_id, chat_id, sender_id, text), + ) + return cur.fetchone() + + +def list_messages(cur, chat_id, after, limit): + sql = ( + "SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id = %s" + ) + params = [chat_id] + if after is not None: + sql += " AND (created_at, id) > (%s::timestamptz, %s::uuid)" + params.extend([after[0], after[1]]) + sql += " ORDER BY created_at ASC, id ASC LIMIT %s" + params.append(limit) + cur.execute(sql, params) + return cur.fetchall() diff --git a/student-tests/README.md b/student-tests/README.md new file mode 100644 index 00000000..161fa919 --- /dev/null +++ b/student-tests/README.md @@ -0,0 +1,32 @@ +# Студенческие проверки (lab 2) + +Дополняют публичный `tests/smoke.py`, не ослабляя его. Только стандартная библиотека. + +```sh +# негативные и конкурентные проверки на работающем стенде +python student-tests/test_lab2.py --base-url http://localhost:8080 + +# проверка истечения сессии при коротком TTL (см. compose.expiry.yaml) +docker compose -f compose.yaml -f compose.expiry.yaml up -d --no-deps api +python student-tests/test_lab2.py --base-url http://localhost:8081 --expiry +docker compose up -d --no-deps api # вернуть обычный TTL + +# обход кэша при недоступности Valkey (останавливает/запускает valkey) +python student-tests/test_lab2.py --base-url http://localhost:8080 --cache-check +``` + +Что проверяется: + +- неверный пароль → одинаковый `401` и `WWW-Authenticate: Basic`; +- `X-User-Id` сам по себе не аутентифицирует и не подменяет владельца Bearer-сессии; +- logout отзывает токен (`204`, затем `401` с `WWW-Authenticate: Bearer`); +- гонка регистрации одного username: ровно один `201`, остальные `409`; +- истечение сессии по короткому `SESSION_TTL_SECONDS` (`--expiry`); +- недоступность Valkey не ломает аутентификацию, источник истины — PostgreSQL (`--cache-check`). + +`perf_explain.sql` наполняет один чат 10 000 синтетических сообщений и печатает +`EXPLAIN (ANALYZE, BUFFERS)` для keyset-пагинации: + +```sh +Get-Content -Raw student-tests/perf_explain.sql | docker compose exec -T postgres psql -U messenger -d messenger +``` diff --git a/student-tests/perf_explain.sql b/student-tests/perf_explain.sql new file mode 100644 index 00000000..5d87c252 --- /dev/null +++ b/student-tests/perf_explain.sql @@ -0,0 +1,44 @@ +INSERT INTO users (id, username, display_name, password_hash) +VALUES ('00000000-0000-4000-8000-000000000001', 'perf_user_1', 'Perf One', 'synthetic'), + ('00000000-0000-4000-8000-000000000002', 'perf_user_2', 'Perf Two', 'synthetic') +ON CONFLICT (id) DO NOTHING; + +INSERT INTO chats (id, title) +VALUES ('00000000-0000-4000-8000-0000000000aa', 'Perf chat') +ON CONFLICT (id) DO NOTHING; + +INSERT INTO chat_members (chat_id, user_id) +VALUES ('00000000-0000-4000-8000-0000000000aa', '00000000-0000-4000-8000-000000000001') +ON CONFLICT DO NOTHING; + +INSERT INTO messages (id, chat_id, sender_id, text, created_at) +SELECT gen_random_uuid(), + '00000000-0000-4000-8000-0000000000aa', + '00000000-0000-4000-8000-000000000001', + 'perf message ' || g, + now() - (g || ' seconds')::interval +FROM generate_series(1, 10000) AS g; + +ANALYZE messages; + +\echo === message count === +SELECT count(*) AS messages FROM messages +WHERE chat_id = '00000000-0000-4000-8000-0000000000aa'; + +\echo === EXPLAIN (ANALYZE, BUFFERS): keyset page in the middle of history === +EXPLAIN (ANALYZE, BUFFERS) +SELECT id, chat_id, sender_id, text, created_at +FROM messages +WHERE chat_id = '00000000-0000-4000-8000-0000000000aa' + AND (created_at, id) > (now() - interval '5000 seconds', + '00000000-0000-4000-8000-000000000000'::uuid) +ORDER BY created_at ASC, id ASC +LIMIT 50; + +\echo === EXPLAIN (ANALYZE, BUFFERS): first page (no cursor) === +EXPLAIN (ANALYZE, BUFFERS) +SELECT id, chat_id, sender_id, text, created_at +FROM messages +WHERE chat_id = '00000000-0000-4000-8000-0000000000aa' +ORDER BY created_at ASC, id ASC +LIMIT 50; diff --git a/student-tests/test_lab2.py b/student-tests/test_lab2.py new file mode 100644 index 00000000..82b7255c --- /dev/null +++ b/student-tests/test_lab2.py @@ -0,0 +1,137 @@ +#!/usr/bin/env python3 +import argparse +import base64 +import json +import subprocess +import threading +import time +import urllib.error +import urllib.request +import uuid + +class Failure(AssertionError): + pass + +def check(condition, message): + if not condition: + raise Failure(message) + +def call(base, method, path, body=None, token=None, basic=None, headers=None): + h = {"Accept": "application/json"} + if token: + h["Authorization"] = "Bearer " + token + if basic: + h["Authorization"] = "Basic " + base64.b64encode(basic.encode("utf-8")).decode("ascii") + data = None + if body is not None: + data = json.dumps(body, ensure_ascii=False).encode("utf-8") + h["Content-Type"] = "application/json" + h.update(headers or {}) + request = urllib.request.Request(base + path, data=data, headers=h, method=method) + try: + response = urllib.request.urlopen(request, timeout=10) + except urllib.error.HTTPError as error: + response = error + with response: + raw = response.read() + return response.code, response.headers, raw + +def register(base, username, password): + return call(base, "POST", "/api/v1/users", body={ + "username": username, "display_name": "Студент " + username, "password": password}) + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("--base-url", default="http://localhost:8080") + parser.add_argument("--expiry", action="store_true", help="expect a short SESSION_TTL_SECONDS") + parser.add_argument("--cache-check", action="store_true", help="stop Valkey via docker compose") + parser.add_argument("--compose-dir", default=".") + args = parser.parse_args() + base = args.base_url.rstrip("/") + tag = uuid.uuid4().hex[:10] + password = "T3st-" + uuid.uuid4().hex + + status, _, raw = register(base, "u_neg_" + tag, password) + check(status == 201, "registration failed: %d" % status) + user = json.loads(raw) + status, headers, _ = call(base, "POST", "/api/v1/auth/sessions", + basic="u_neg_%s:%s" % (tag, "wrong-password-123")) + check(status == 401, "wrong password must be 401, got %d" % status) + check(headers.get("WWW-Authenticate", "").lower().startswith("basic"), "missing Basic challenge") + print("PASS: wrong password -> 401 with Basic challenge") + + status, _, raw = call(base, "POST", "/api/v1/auth/sessions", + basic="u_neg_%s:%s" % (tag, password)) + check(status == 201, "login failed: %d" % status) + token = json.loads(raw)["token"] + + status, _, _ = call(base, "GET", "/api/v1/users/me", headers={"X-User-Id": user["id"]}) + check(status == 401, "X-User-Id must not authenticate, got %d" % status) + other = json.loads(register(base, "u_neg2_" + tag, password)[2]) + status, _, raw = call(base, "GET", "/api/v1/users/me", token=token, headers={"X-User-Id": other["id"]}) + check(status == 200 and json.loads(raw)["id"] == user["id"], "X-User-Id overrode bearer identity") + print("PASS: X-User-Id ignored for authentication") + + status, _, raw = call(base, "DELETE", "/api/v1/auth/sessions/current", token=token) + check(status == 204 and not raw, "logout must be 204 without body, got %d" % status) + status, headers, _ = call(base, "GET", "/api/v1/users/me", token=token) + check(status == 401, "revoked token must be 401, got %d" % status) + check(headers.get("WWW-Authenticate", "").lower().startswith("bearer"), "missing Bearer challenge") + print("PASS: logout revokes the session") + + race_username = "u_race_" + tag + results = [] + lock = threading.Lock() + barrier = threading.Barrier(8) + + def attempt(): + barrier.wait() + code, _, _ = register(base, race_username, password) + with lock: + results.append(code) + + threads = [threading.Thread(target=attempt) for _ in range(8)] + for thread in threads: + thread.start() + for thread in threads: + thread.join() + check(results.count(201) == 1, "exactly one registration must succeed: %s" % sorted(results)) + check(results.count(409) == 7, "losers must get 409: %s" % sorted(results)) + print("PASS: concurrent registration -> one 201 and seven 409") + + if args.expiry: + status, _, raw = call(base, "POST", "/api/v1/auth/sessions", + basic="u_neg_%s:%s" % (tag, password)) + check(status == 201, "login failed: %d" % status) + short = json.loads(raw) + expires = short["expires_at"] + from datetime import datetime, timezone + ttl = (datetime.fromisoformat(expires.replace("Z", "+00:00")) - datetime.now(timezone.utc)).total_seconds() + check(ttl < 60, "run this with a short SESSION_TTL_SECONDS (ttl=%.1fs)" % ttl) + time.sleep(max(0.0, ttl) + 1.5) + status, _, _ = call(base, "GET", "/api/v1/users/me", token=short["token"]) + check(status == 401, "expired session must be 401, got %d" % status) + print("PASS: session expired after %.0fs TTL" % ttl) + + if args.cache_check: + status, _, raw = call(base, "POST", "/api/v1/auth/sessions", + basic="u_neg_%s:%s" % (tag, password)) + token = json.loads(raw)["token"] + subprocess.run(["docker", "compose", "stop", "valkey"], cwd=args.compose_dir, check=True, + stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) + try: + status, _, _ = call(base, "GET", "/api/v1/users/me", token=token) + check(status == 200, "auth must keep working without the cache, got %d" % status) + print("PASS: authentication survives a cache outage") + finally: + subprocess.run(["docker", "compose", "start", "valkey"], cwd=args.compose_dir, check=True, + stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) + + print("PASS: student lab2 checks completed") + +if __name__ == "__main__": + try: + main() + except Failure as error: + print("FAIL:", error) + raise SystemExit(1)