Реализовать лабораторную 2: API мессенджера с PostgreSQL и кэшем сессий
Skeleton contracts / contracts (pull_request) Canceled after 0s
Skeleton contracts / contracts (pull_request) Canceled after 0s
FastAPI-сервис с opaque-сессиями (Argon2id, SHA-256 фингерпринт), PostgreSQL как источником истины, Valkey как кэшем сессий, keyset-пагинацией, пулом соединений и таймаутами. Добавлены миграции, compose-стенд, скрипт рестарта, студенческие проверки и evidence.
This commit is contained in:
+25
@@ -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"]
|
||||
@@ -1,37 +1,165 @@
|
||||
# Отчёт — лабораторная 2
|
||||
|
||||
- Автор, группа: TODO
|
||||
- Целевая оценка; выбранный трек 5, если нужен: TODO
|
||||
- Автор, группа: Ким Владимир, БВТ2302
|
||||
- Целевая оценка; 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:<sha256>`); промах или недоступность кэша → запрос к 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) не заявлен и не измерялся.
|
||||
|
||||
@@ -0,0 +1,6 @@
|
||||
services:
|
||||
api:
|
||||
environment:
|
||||
SESSION_TTL_SECONDS: 2
|
||||
ports:
|
||||
- "8081:8080"
|
||||
@@ -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:
|
||||
@@ -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
|
||||
@@ -0,0 +1 @@
|
||||
PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.
|
||||
@@ -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]
|
||||
@@ -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
|
||||
@@ -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)
|
||||
|
||||
@@ -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
|
||||
@@ -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."
|
||||
}
|
||||
@@ -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.
|
||||
@@ -0,0 +1 @@
|
||||
PASS: lab2 public API scenario; infrastructure and grading evidence remain separate.
|
||||
@@ -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);
|
||||
@@ -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
|
||||
@@ -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%
|
||||
@@ -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
|
||||
@@ -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)
|
||||
+276
@@ -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})
|
||||
@@ -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)
|
||||
@@ -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()
|
||||
+107
@@ -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)
|
||||
@@ -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)
|
||||
+115
@@ -0,0 +1,115 @@
|
||||
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)
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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()
|
||||
@@ -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
|
||||
```
|
||||
@@ -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;
|
||||
@@ -0,0 +1,143 @@
|
||||
#!/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)
|
||||
Reference in New Issue
Block a user