ЛР 2 — БПИ2303 — Бахрамов — на 3 #114
@@ -0,0 +1,23 @@
|
||||
name: Lab2 application
|
||||
on: [push, pull_request]
|
||||
permissions:
|
||||
contents: read
|
||||
jobs:
|
||||
application:
|
||||
runs-on: ubuntu-latest
|
||||
timeout-minutes: 15
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- uses: actions/setup-python@v5
|
||||
with:
|
||||
python-version: '3.12'
|
||||
- run: python scripts/bootstrap.py
|
||||
- run: docker compose --env-file .env up -d --build --wait --wait-timeout 120
|
||||
- run: python scripts/verify.py
|
||||
- if: always()
|
||||
uses: actions/upload-artifact@v4
|
||||
with:
|
||||
name: lab2-evidence
|
||||
path: evidence/
|
||||
- if: always()
|
||||
run: docker compose down
|
||||
+28
@@ -0,0 +1,28 @@
|
||||
# Что объяснять на защите
|
||||
|
||||
1. **Изменение относительно lab1.** Память Python исчезает при рестарте.
|
||||
Теперь долговечные данные и сессии находятся в PostgreSQL с named volume.
|
||||
Пользователь определяется по случайному Bearer-токену; X-User-Id игнорируется.
|
||||
2. **Пароль и токен.** Argon2id делает перебор паролей дорогим; соль и параметры
|
||||
находятся внутри hash. Basic содержит base64(username:password), это не
|
||||
шифрование. Токен — 32 случайных байта, в БД хранится только SHA-256 от него.
|
||||
3. **Сессия.** Каждый запрос проверяет expires_at в БД. Logout удаляет строку.
|
||||
После рестарта строка и её прежний срок сохраняются, TTL не продлевается.
|
||||
4. **Транзакция чата.** INSERT chats и все INSERT memberships идут на одном
|
||||
соединении до COMMIT. Несуществующий участник нарушает FK, вся транзакция
|
||||
откатывается. Тест проверяет, что даже строка chats не осталась.
|
||||
5. **Гонка регистрации.** Два запроса могут одновременно не увидеть username.
|
||||
Истинную уникальность обеспечивает UNIQUE в БД; один INSERT проходит,
|
||||
остальные получают конфликт, который API превращает в 409.
|
||||
6. **Авторизация.** Валидная сессия устанавливает личность. Membership отдельно
|
||||
определяет право читать/писать конкретный чат. Чужой чат → 404.
|
||||
7. **Индекс.** B-tree(chat_id,created_at,id) сначала ограничивает чат, затем
|
||||
позволяет идти от cursor в нужном порядке и взять limit+1 строк.
|
||||
OFFSET в API не используется.
|
||||
8. **COMMIT.** Ответ отправляется после подтверждения транзакции. В штатной
|
||||
PostgreSQL включены fsync и synchronous_commit, но один Docker-host не
|
||||
защищает от потери диска/volume. Репликация и backup здесь не реализованы.
|
||||
9. **Как показать.** `make test`, `make test-persistence ACTION_SCRIPT=scripts/restart.sh`,
|
||||
`make test-student`, `make test-expiry`. Последняя
|
||||
команда временно ставит TTL=2, затем
|
||||
восстанавливает обычную конфигурацию. Полный прогон — `make verify`.
|
||||
@@ -0,0 +1,36 @@
|
||||
# Схема и транзакционные границы
|
||||
|
||||
Клиент → HTTP API → PostgreSQL. Все данные и сессии — в PostgreSQL.
|
||||
|
||||
- users: UUID PK, UNIQUE username, Argon2id hash, display_name, created_at.
|
||||
- chats: UUID PK, title, created_at.
|
||||
- memberships: PK(chat_id,user_id), FK на users/chats; индекс(user_id,chat_id).
|
||||
- messages: UUID PK, FK chat/sender и составной FK на membership;
|
||||
text, created_at; B-tree(chat_id,created_at,id).
|
||||
- sessions: SHA-256 случайного токена как PK, FK user_id, абсолютный expires_at.
|
||||
SHA-256 применяется только к случайному токену, пароли защищает Argon2id.
|
||||
- schema_migrations: имя файла и SHA-256 SQL, applied_at. Уже применённый файл
|
||||
изменять нельзя; следующая версия — новый SQL-файл.
|
||||
|
||||
Создание чата и всех memberships — одна транзакция. Неизвестный участник
|
||||
вызывает FK violation и откат, включая уже вставленные строки. Регистрация
|
||||
опирается на UNIQUE, поэтому конкурентный проигравший получает 409.
|
||||
Вставка сообщения, создание/удаление сессии — отдельные транзакции.
|
||||
HTTP 201/204 отправляется только после выхода из connection() и COMMIT.
|
||||
PostgreSQL fsync/synchronous_commit остаются по умолчанию включены.
|
||||
|
||||
Параметризованные SQL; pool 1–8 соединений, ожидание 2 s, очередь до 32;
|
||||
connect 2 s, statement 2.5 s, lock 1.5 s. Ошибка зависимости → 503 без SQL
|
||||
и credentials. Readiness зависит от PostgreSQL, liveness — только от API.
|
||||
|
||||
Проверка Bearer и expiry всегда в PostgreSQL. Logout удаляет сессию в БД.
|
||||
Перезапуск API не меняет токен и срок сессии; volume сохраняет строки БД.
|
||||
Redis для уровня 3 не используется.
|
||||
|
||||
История: WHERE chat_id=? AND (created_at,id)>(?,?) ORDER BY created_at,id
|
||||
LIMIT limit+1. Cursor содержит chat UUID, timestamp и message UUID, кодированные
|
||||
base64url; подделка cursor не заменяет membership-проверку. Список чатов
|
||||
аналогичен и привязан к пользователю. Уровень изоляции READ COMMITTED:
|
||||
при неизменной истории нет повторов/потерь; при конкурентных транзакциях поздно
|
||||
закоммиченная запись с ключом раньше cursor может быть пропущена. Snapshot
|
||||
между HTTP-страницами не обещается; UTC server clock не является уникальным ID.
|
||||
+14
@@ -0,0 +1,14 @@
|
||||
FROM python:3.12.9-slim-bookworm
|
||||
ENV PYTHONDONTWRITEBYTECODE=1 PYTHONUNBUFFERED=1
|
||||
WORKDIR /app
|
||||
COPY requirements.txt ./
|
||||
RUN pip install --no-cache-dir -r requirements.txt && useradd --uid 10001 --create-home messenger
|
||||
COPY app ./app
|
||||
COPY migrations ./migrations
|
||||
COPY tests ./tests
|
||||
COPY contracts ./contracts
|
||||
COPY lab.json ./
|
||||
COPY student-tests ./student-tests
|
||||
USER messenger
|
||||
EXPOSE 8080
|
||||
CMD ["python", "-m", "app.main"]
|
||||
@@ -24,3 +24,14 @@ load:
|
||||
test-persistence:
|
||||
@test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable restart hook"; exit 2)
|
||||
$(PYTHON) tests/resilience.py --mode persistence --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS)
|
||||
|
||||
.PHONY: test-student test-expiry verify
|
||||
|
||||
test-student:
|
||||
docker compose --env-file .env exec -T api python -m unittest discover -s student-tests -v
|
||||
|
||||
test-expiry:
|
||||
$(PYTHON) scripts/test_expiry.py
|
||||
|
||||
verify:
|
||||
$(PYTHON) scripts/verify.py
|
||||
|
||||
@@ -1,37 +1,157 @@
|
||||
# Отчёт — лабораторная 2
|
||||
|
||||
- Автор, группа: TODO
|
||||
- Целевая оценка; выбранный трек 5, если нужен: TODO
|
||||
- Commit/PR: TODO после публикации
|
||||
- Использованные источники, библиотеки и помощь ИИ: TODO
|
||||
- Автор: Бахрамов Бахрам, БПИ2303.
|
||||
- Целевая оценка: **3**.
|
||||
- Ветка: `solution/bpi2303-bakhramov`.
|
||||
- Commit/PR: заполняются после публикации студентом.
|
||||
- Дата проверки: 29 октября 2026 г.
|
||||
|
||||
## Запуск из чистого clone
|
||||
|
||||
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
|
||||
Нужны Git, Python 3.9+, Docker Desktop/Engine и Docker Compose v2+.
|
||||
Образы: Python 3.12.9-slim-bookworm, PostgreSQL 17.4-bookworm.
|
||||
Прямые Python-зависимости закреплены в requirements.txt.
|
||||
|
||||
```sh
|
||||
python3 scripts/bootstrap.py
|
||||
docker compose --env-file .env config --quiet
|
||||
docker compose --env-file .env up -d --build --wait --wait-timeout 120
|
||||
curl -i http://localhost:8080/health/ready
|
||||
make verify
|
||||
```
|
||||
|
||||
bootstrap создаёт случайный учебный пароль PostgreSQL и connection URL в
|
||||
игнорируемой secrets/, создаёт .env. Значения не печатаются, повторный запуск
|
||||
сохраняет существующие файлы. API читает смонтированные файлы Docker secrets.
|
||||
PostgreSQL наружу не опубликован; API доступен на 127.0.0.1:8080. При занятом
|
||||
порте изменить API_PORT в .env и задать тестам BASE_URL через окружение.
|
||||
|
||||
Миграции автоматически применяются перед стартом API. Повторный ручной запуск:
|
||||
|
||||
```sh
|
||||
docker compose exec -T api python -m app.migrate
|
||||
```
|
||||
|
||||
Проверки по отдельности:
|
||||
|
||||
```sh
|
||||
make check
|
||||
make test
|
||||
make test-student
|
||||
make test-persistence ACTION_SCRIPT=scripts/restart.sh
|
||||
make test-expiry
|
||||
```
|
||||
|
||||
`make verify` выполняет эти проверки и сохраняет вывод в evidence/.
|
||||
Persistence-тест перезапускает API и PostgreSQL, не удаляя volumes. Expiry-тест
|
||||
временно пересоздаёт API с SESSION_TTL_SECONDS=2, затем восстанавливает обычную
|
||||
конфигурацию. Обычный TTL — 3600 s, для smoke/persistence требуется минимум 300 s.
|
||||
Выполнять проверки на учебном стенде без параллельной работы.
|
||||
|
||||
Дополнительная полная проверка контракта:
|
||||
|
||||
```sh
|
||||
python3 -m venv .venv
|
||||
.venv/bin/python -m pip install -r requirements-dev.txt
|
||||
make validate PYTHON=.venv/bin/python
|
||||
```
|
||||
|
||||
Остановка с сохранением данных: `docker compose --env-file .env down`.
|
||||
**Намеренное удаление всех учебных данных:** `docker compose --env-file .env down --volumes`.
|
||||
Удаление volumes не используется при проверке сохранности. Не заменять пароль
|
||||
в secrets/ при сохранённом volume БД: POSTGRES_PASSWORD_FILE задаёт его при
|
||||
первичной инициализации, а не при каждом запуске.
|
||||
|
||||
## Архитектура и решения
|
||||
|
||||
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
|
||||
Клиент → HTTP API → PostgreSQL с именованным volume. Redis не используется.
|
||||
Подробная схема — [DESIGN.md](DESIGN.md), SQL — migrations/001_initial.sql.
|
||||
|
||||
Из собственной lab1 перенесены HTTP-обработчик, валидация, JSON-ошибки,
|
||||
пагинация и graceful shutdown. In-memory-хранилище заменено PostgreSQL.
|
||||
Сохранены пользователи, чаты, членство и сообщения. Переход lab2:
|
||||
регистрация требует password, создание сессии использует Basic, остальные
|
||||
защищённые операции — Bearer; X-User-Id доступа не даёт.
|
||||
|
||||
Таблицы: users, chats, memberships, messages, sessions. UUID — первичные ключи,
|
||||
есть внешние ключи, UNIQUE username, составной PK membership и индекс истории.
|
||||
Создание чата и участников — одна транзакция: при неизвестном участнике FK
|
||||
вызывает откат всех вставок. Ответ на запись отправляется после COMMIT.
|
||||
Параметризованные запросы, ограниченный connection pool и таймауты.
|
||||
|
||||
Пароли: Argon2id, time_cost=3, memory_cost=65536 KiB, parallelism=2;
|
||||
случайную соль создаёт библиотека. UTF-8 пароль 12–128 символов, включая двоеточие.
|
||||
Сессия: secrets.token_urlsafe(32), 256 бит энтропии; в БД сохраняется SHA-256
|
||||
случайного токена, user_id и абсолютный expires_at. SHA-256 не используется
|
||||
для паролей. При каждом защищённом запросе проверяются сессия и срок по часам
|
||||
БД. Logout удаляет строку, повторное использование даёт 401. При рестарте срок
|
||||
не продлевается, действующие сессии остаются в PostgreSQL.
|
||||
|
||||
Миграции версионированы: schema_migrations хранит имя и checksum файла;
|
||||
advisory lock защищает от параллельного запуска, вся миграция транзакционна.
|
||||
Повтор не создаёт дубли; изменение применённого SQL обнаруживается.
|
||||
|
||||
Настройки из .env.example: APP_HOST/APP_PORT/APP_ENV заданы в Compose;
|
||||
SESSION_TTL_SECONDS — из .env; DATABASE_URL_FILE указывает на Docker secret;
|
||||
SESSION_STORE=postgres. CACHE_URL_FILE не используется на уровне 3.
|
||||
Дополнительно API_PORT задаёт порт хоста, DB_POOL_SIZE — размер pool (по умолчанию 8).
|
||||
|
||||
## Доказательства критериев
|
||||
|
||||
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
|
||||
| --- | --- | --- | --- |
|
||||
| Публичный smoke | make test | TODO | TODO |
|
||||
| Остальные пункты уровня 3 | TODO | TODO | TODO |
|
||||
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
|
||||
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
|
||||
Публичные tests/ и contracts/, README задания сохранены. Результаты формирует
|
||||
scripts/verify.py; он сохраняет stdout без credentials и сессионных токенов.
|
||||
|
||||
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
|
||||
| Критерий | Команда / сценарий | Наблюдение | Доказательство |
|
||||
| --- | --- | --- | --- |
|
||||
| Целостность skeleton | make check | offline structure PASS | evidence/check.txt |
|
||||
| Минимум lab1 и новая аутентификация | make test | пользователи, чат, Unicode-сообщения, история, доступ и logout | evidence/smoke.txt |
|
||||
| PostgreSQL, ограничения, KDF | make test-student | Argon2id в БД; один 201 и три 409 при гонке username | evidence/integration.txt |
|
||||
| Атомарность создания чата | test_rollback_after_partial_chat_insert | неизвестный member → 400; строки чата после отката нет | evidence/integration.txt |
|
||||
| Миграции с нуля и повторно | bootstrap; test_migrations_are_repeatable | схема создана; повторные миграции не меняют счётчики | evidence/integration.txt |
|
||||
| Неверные credentials, Bearer, отзыв | make test; собственные тесты | неверный пароль, X-User-Id и Basic на бизнес-API → 401; logout отзывает токен | evidence/smoke.txt; evidence/integration.txt |
|
||||
| Данные и сессии переживают рестарт | make test-persistence ACTION_SCRIPT=scripts/restart.sh | прежний токен читает прежние данные | evidence/persistence.txt |
|
||||
| Реальный перезапуск всех компонентов | scripts/verify.py | StartedAt изменился у API и PostgreSQL | evidence/restart-containers.json |
|
||||
| Срок жизни сессии | make test-expiry | TTL=2: сначала 200, после 2.3 s — 401 | evidence/expiry.txt |
|
||||
| OpenAPI | make validate PYTHON=.venv/bin/python | полная валидация контракта PASS | evidence/openapi.txt |
|
||||
|
||||
Фактический прогон 29.10.2026: make check — PASS; make test — PASS;
|
||||
6 собственных тестов — OK (0.685 s); persistence — PASS; StartedAt API и
|
||||
PostgreSQL изменился; TTL=2 — PASS, обычная конфигурация восстановлена;
|
||||
полная OpenAPI-валидация — PASS.
|
||||
|
||||
## Эксперименты и отказы
|
||||
|
||||
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
|
||||
Проверяется гипотеза: данные и действующая сессия хранятся вне памяти API и
|
||||
сохраняются после остановки/запуска API и БД. Публичный persistence-тест создаёт
|
||||
синтетических пользователей, чат, сообщение и сессию; вызывает restart.sh;
|
||||
после ready читает те же данные прежним токеном. verify.py сравнивает StartedAt
|
||||
контейнеров до/после, подтверждая реальность перезапуска.
|
||||
|
||||
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
|
||||
| --- | --- | --- | --- |
|
||||
| TODO | TODO | TODO | TODO |
|
||||
| Воздействие | Ожидаемый результат | Команда / сохранённый результат |
|
||||
| --- | --- | --- |
|
||||
| Перезапуск API и PostgreSQL | сессия и сообщение сохранились, volumes не удалены | make test-persistence; evidence/persistence.txt |
|
||||
| Истечение короткой сессии | запрос до expiry проходит, после — 401 | make test-expiry; evidence/expiry.txt |
|
||||
| Неизвестный участник при создании чата | полный rollback, нет частично созданного чата | make test-student; evidence/integration.txt |
|
||||
|
||||
Стенд проверки: Apple M4/arm64, Docker VM с 10 CPU и около 7.75 GiB RAM.
|
||||
Это функциональные проверки одного локального стенда, не нагрузочное
|
||||
исследование. RPS/p95/p99 без измерения не заявлены. Подтверждается сохранность
|
||||
при штатном рестарте, а не при потере диска или удалении volume.
|
||||
|
||||
## Ограничения и следующие шаги
|
||||
|
||||
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
|
||||
Реализован уровень 3. Redis, HA, backup и исследовательские треки не заявлены.
|
||||
HTTP — только localhost и синтетические данные. Один PostgreSQL не защищает
|
||||
от потери host/volume. ThreadingHTTPServer — учебный сервер; pool БД ограничен,
|
||||
но общее число HTTP-потоков не ограничено. Нет межстраничного snapshot истории:
|
||||
при конкурентных транзакциях поздний COMMIT с ключом раньше cursor может
|
||||
не попасть в продолжение. Истёкшие сессии нужно периодически удалять из БД.
|
||||
|
||||
## Источники
|
||||
|
||||
- README.md, contracts/openapi.json, contracts/README.md, tests/README.md.
|
||||
- Собственная lab1: app/server.py, models.py, errors.py, main.py из папки ВП.
|
||||
- PostgreSQL: https://www.postgresql.org/docs/17/tutorial-transactions.html
|
||||
- Psycopg pool: https://www.psycopg.org/psycopg3/docs/advanced/pool.html
|
||||
- Argon2-cffi: https://argon2-cffi.readthedocs.io/en/stable/howto.html
|
||||
- Basic: https://www.rfc-editor.org/rfc/rfc7617
|
||||
|
||||
@@ -0,0 +1,50 @@
|
||||
# Публикация решения
|
||||
|
||||
Ветка решения: `solution/bpi2303-bakhramov`. Все команды выполнять из корня
|
||||
своего клона mtusi2026lab2. Перед отправкой проверить `git status` и diff.
|
||||
|
||||
```sh
|
||||
git status
|
||||
git add app migrations student-tests scripts Dockerfile compose.yaml requirements.txt Makefile DESIGN.md REPORT.md SUBMISSION.md DEFENSE.md evidence .github/workflows/application.yml
|
||||
git diff --cached --stat
|
||||
git commit -m "ЛР 2: PostgreSQL и сессии"
|
||||
git push -u origin solution/bpi2303-bakhramov
|
||||
```
|
||||
|
||||
В Gitea: свой форк → Запросы на слияние → Новый запрос.
|
||||
- Назначение: mtusi2026/mtusi2026lab2, ветка master.
|
||||
- Источник: bahram/mtusi2026lab2, ветка solution/bpi2303-bakhramov.
|
||||
- Заголовок: **ЛР 2 — БПИ2303 — Бахрамов — на 3**.
|
||||
|
||||
Описание для вставки:
|
||||
|
||||
```markdown
|
||||
Автор / группа: Бахрамов Бахрам, БПИ2303
|
||||
Целевая оценка: 3. Трек 5: не заявлен.
|
||||
|
||||
Перенесены HTTP-обработчик и валидация из собственной lab1.
|
||||
Добавлены PostgreSQL, версионируемые миграции, Argon2id, Basic-вход,
|
||||
opaque Bearer-сессии с expiry/logout.
|
||||
|
||||
Запуск: python3 scripts/bootstrap.py && docker compose --env-file .env up -d --build --wait
|
||||
Проверки: make verify
|
||||
Отчёт: [REPORT.md](REPORT.md), результаты: [evidence](evidence/).
|
||||
|
||||
Проверены публичный smoke, persistence с перезапуском API и PostgreSQL,
|
||||
гонка регистрации, rollback, повторный запуск миграций и expiry при TTL=2.
|
||||
|
||||
Ограничения: один PostgreSQL, локальный HTTP, без межстраничного snapshot.
|
||||
Источники: контракт задания, собственная lab1, документация PostgreSQL,
|
||||
Psycopg и Argon2-cffi. Подробности в REPORT.md.
|
||||
|
||||
- [x] Обязательный минимум сохранён с переходом на новую аутентификацию.
|
||||
- [x] Контракт и публичные проверки не ослаблены.
|
||||
- [x] make check и make test выполнены, вывод в evidence/.
|
||||
- [x] Сценарии отказов своего уровня воспроизведены.
|
||||
- [x] Secrets и приватные данные вне Git.
|
||||
- [x] README задания сохранён; запуск описан в REPORT.md.
|
||||
```
|
||||
|
||||
Отметки проверок соответствуют сохранённому прогону evidence/; при изменении
|
||||
кода повторить `make verify`. Самостоятельно сливать запрос не требуется:
|
||||
после создания его проверяет преподаватель. Исправления отправлять в ту же ветку.
|
||||
@@ -0,0 +1,14 @@
|
||||
"""Runtime configuration; secret values are read only from mounted files."""
|
||||
import os
|
||||
from pathlib import Path
|
||||
|
||||
APP_HOST = os.getenv('APP_HOST', '0.0.0.0')
|
||||
APP_PORT = int(os.getenv('APP_PORT', '8080'))
|
||||
SESSION_TTL_SECONDS = int(os.getenv('SESSION_TTL_SECONDS', '3600'))
|
||||
POOL_SIZE = int(os.getenv('DB_POOL_SIZE', '8'))
|
||||
if SESSION_TTL_SECONDS < 1 or not 1 <= POOL_SIZE <= 32:
|
||||
raise ValueError('Invalid TTL or pool size')
|
||||
|
||||
|
||||
def secret(name):
|
||||
return Path(os.environ[name + '_FILE']).read_text().strip()
|
||||
@@ -0,0 +1,45 @@
|
||||
class APIError(Exception):
|
||||
def __init__(self, code: str, message: str, status_code: int = 400):
|
||||
super().__init__(message)
|
||||
self.code = code
|
||||
self.message = message
|
||||
self.status_code = status_code
|
||||
|
||||
def to_dict(self, request_id: str) -> dict:
|
||||
return {
|
||||
"error": {
|
||||
"code": self.code,
|
||||
"message": self.message,
|
||||
"request_id": request_id,
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
class BadRequestError(APIError):
|
||||
def __init__(self, message: str = "Invalid request"):
|
||||
super().__init__(code="invalid_request", message=message, status_code=400)
|
||||
|
||||
|
||||
class UnauthorizedError(APIError):
|
||||
def __init__(self, message: str = "Unauthorized"):
|
||||
super().__init__(code="unauthorized", message=message, status_code=401)
|
||||
|
||||
|
||||
class NotFoundError(APIError):
|
||||
def __init__(self, message: str = "Object not found"):
|
||||
super().__init__(code="not_found", message=message, status_code=404)
|
||||
|
||||
|
||||
class ConflictError(APIError):
|
||||
def __init__(self, message: str = "Conflict"):
|
||||
super().__init__(code="conflict", message=message, status_code=409)
|
||||
|
||||
|
||||
class UnavailableError(APIError):
|
||||
def __init__(self, message: str = "Service unavailable"):
|
||||
super().__init__(code="unavailable", message=message, status_code=503)
|
||||
|
||||
|
||||
class InternalError(APIError):
|
||||
def __init__(self, message: str = "Internal server error"):
|
||||
super().__init__(code="internal_error", message=message, status_code=500)
|
||||
+53
@@ -0,0 +1,53 @@
|
||||
import logging
|
||||
import signal
|
||||
import sys
|
||||
import threading
|
||||
from pathlib import Path
|
||||
|
||||
# Ensure root directory is in sys.path
|
||||
sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
|
||||
|
||||
from app.config import APP_HOST, APP_PORT
|
||||
from app.server import MessengerServer
|
||||
from app.migrate import migrate
|
||||
|
||||
logging.basicConfig(
|
||||
level=logging.INFO,
|
||||
format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
|
||||
stream=sys.stdout,
|
||||
)
|
||||
logger = logging.getLogger("messenger")
|
||||
|
||||
|
||||
def main():
|
||||
migrate()
|
||||
server = MessengerServer((APP_HOST, APP_PORT))
|
||||
logger.info("Starting MTUSI Messenger server on %s:%d", APP_HOST, APP_PORT)
|
||||
|
||||
def handle_signal(sig_num, frame):
|
||||
sig_name = signal.Signals(sig_num).name
|
||||
logger.info("Received %s, initiating graceful shutdown...", sig_name)
|
||||
server.is_shutting_down = True
|
||||
|
||||
def shutdown_thread():
|
||||
server.shutdown()
|
||||
server.server_close()
|
||||
logger.info("Server stopped cleanly.")
|
||||
|
||||
threading.Thread(target=shutdown_thread, daemon=True).start()
|
||||
|
||||
signal.signal(signal.SIGTERM, handle_signal)
|
||||
signal.signal(signal.SIGINT, handle_signal)
|
||||
|
||||
try:
|
||||
server.serve_forever()
|
||||
except (KeyboardInterrupt, SystemExit):
|
||||
logger.info("Server exiting...")
|
||||
finally:
|
||||
server.server_close()
|
||||
server.storage.close()
|
||||
logger.info("Shutdown completed.")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,28 @@
|
||||
"""Transactional, versioned SQL migrations protected by a database advisory lock."""
|
||||
import hashlib
|
||||
from pathlib import Path
|
||||
import psycopg
|
||||
from app.config import secret
|
||||
|
||||
|
||||
def migrate():
|
||||
with psycopg.connect(secret('DATABASE_URL'), connect_timeout=3) as conn:
|
||||
conn.execute('SELECT pg_advisory_xact_lock(202602)')
|
||||
conn.execute('''CREATE TABLE IF NOT EXISTS schema_migrations (
|
||||
version text PRIMARY KEY, checksum text NOT NULL,
|
||||
applied_at timestamptz NOT NULL DEFAULT clock_timestamp())''')
|
||||
for path in sorted((Path(__file__).resolve().parents[1] / 'migrations').glob('*.sql')):
|
||||
sql = path.read_text()
|
||||
checksum = hashlib.sha256(sql.encode()).hexdigest()
|
||||
row = conn.execute('SELECT checksum FROM schema_migrations WHERE version=%s', (path.name,)).fetchone()
|
||||
if row:
|
||||
if row[0] != checksum:
|
||||
raise RuntimeError('Applied migration has changed: ' + path.name)
|
||||
continue
|
||||
conn.execute(sql)
|
||||
conn.execute('INSERT INTO schema_migrations(version, checksum) VALUES (%s,%s)', (path.name, checksum))
|
||||
print('Applied migration ' + path.name, flush=True)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
migrate()
|
||||
+171
@@ -0,0 +1,171 @@
|
||||
import base64
|
||||
import datetime as dt
|
||||
import json
|
||||
import re
|
||||
import uuid
|
||||
from typing import Any, Dict, List, Optional, Tuple
|
||||
from app.errors import APIError, BadRequestError
|
||||
|
||||
USERNAME_REGEX = re.compile(r'^[a-z0-9_]{3,32}$')
|
||||
|
||||
|
||||
def now_utc_z() -> str:
|
||||
"""Return current server time in RFC 3339 UTC format ending with Z."""
|
||||
return dt.datetime.now(dt.timezone.utc).strftime('%Y-%m-%dT%H:%M:%S.%fZ')
|
||||
|
||||
|
||||
def parse_rfc3339(value: str) -> dt.datetime:
|
||||
"""Parse RFC 3339 UTC timestamp ending with Z."""
|
||||
if not isinstance(value, str) or not value.endswith('Z'):
|
||||
raise ValueError("Timestamp must be UTC ending with Z")
|
||||
return dt.datetime.fromisoformat(value[:-1] + '+00:00')
|
||||
|
||||
|
||||
def validate_uuid(value: Any, field_name: str = "id") -> str:
|
||||
if not isinstance(value, str):
|
||||
raise BadRequestError(f"{field_name} must be a string")
|
||||
try:
|
||||
parsed = uuid.UUID(value)
|
||||
except (ValueError, TypeError, AttributeError):
|
||||
raise BadRequestError(f"{field_name} must be a valid UUID")
|
||||
return str(parsed)
|
||||
|
||||
|
||||
def validate_create_user(body: Any) -> Dict[str, Any]:
|
||||
if not isinstance(body, dict):
|
||||
raise BadRequestError("Request body must be a JSON object")
|
||||
allowed_fields = {'username', 'display_name', 'password'}
|
||||
if set(body.keys()) != allowed_fields:
|
||||
extra = set(body.keys()) - allowed_fields
|
||||
missing = allowed_fields - set(body.keys())
|
||||
if missing:
|
||||
raise BadRequestError(f"Missing required fields: {', '.join(missing)}")
|
||||
if extra:
|
||||
raise BadRequestError(f"Unexpected fields: {', '.join(extra)}")
|
||||
|
||||
username = body.get('username')
|
||||
display_name = body.get('display_name')
|
||||
|
||||
if not isinstance(username, str) or not USERNAME_REGEX.fullmatch(username):
|
||||
raise BadRequestError("username must match ^[a-z0-9_]{3,32}$")
|
||||
|
||||
if not isinstance(display_name, str):
|
||||
raise BadRequestError("display_name must be a string")
|
||||
if len(display_name) < 1 or len(display_name) > 100:
|
||||
raise BadRequestError("display_name length must be between 1 and 100 characters")
|
||||
if not display_name.strip():
|
||||
raise BadRequestError("display_name cannot consist only of whitespace")
|
||||
|
||||
password = body['password']
|
||||
if not isinstance(password, str) or not 12 <= len(password) <= 128 or not password.strip():
|
||||
raise BadRequestError('password must contain 12–128 nonblank characters')
|
||||
return {'username': username, 'display_name': display_name, 'password': password}
|
||||
|
||||
|
||||
def validate_create_chat(body: Any) -> Dict[str, Any]:
|
||||
if not isinstance(body, dict):
|
||||
raise BadRequestError("Request body must be a JSON object")
|
||||
allowed_fields = {'title', 'member_ids'}
|
||||
if set(body.keys()) != allowed_fields:
|
||||
extra = set(body.keys()) - allowed_fields
|
||||
missing = allowed_fields - set(body.keys())
|
||||
if missing:
|
||||
raise BadRequestError(f"Missing required fields: {', '.join(missing)}")
|
||||
if extra:
|
||||
raise BadRequestError(f"Unexpected fields: {', '.join(extra)}")
|
||||
|
||||
title = body.get('title')
|
||||
member_ids = body.get('member_ids')
|
||||
|
||||
if not isinstance(title, str):
|
||||
raise BadRequestError("title must be a string")
|
||||
if len(title) < 1 or len(title) > 100:
|
||||
raise BadRequestError("title length must be between 1 and 100 characters")
|
||||
if not title.strip():
|
||||
raise BadRequestError("title cannot consist only of whitespace")
|
||||
|
||||
if not isinstance(member_ids, list):
|
||||
raise BadRequestError("member_ids must be an array")
|
||||
if len(member_ids) < 1 or len(member_ids) > 100:
|
||||
raise BadRequestError("member_ids length must be between 1 and 100")
|
||||
|
||||
seen = set()
|
||||
cleaned_members = []
|
||||
for mid in member_ids:
|
||||
mid_str = validate_uuid(mid, "member_ids element")
|
||||
if mid_str in seen:
|
||||
raise BadRequestError(f"Duplicate member_id: {mid_str}")
|
||||
seen.add(mid_str)
|
||||
cleaned_members.append(mid_str)
|
||||
|
||||
return {'title': title, 'member_ids': cleaned_members}
|
||||
|
||||
|
||||
def validate_create_message(body: Any) -> Dict[str, Any]:
|
||||
if not isinstance(body, dict):
|
||||
raise BadRequestError("Request body must be a JSON object")
|
||||
allowed_fields = {'text'}
|
||||
if set(body.keys()) != allowed_fields:
|
||||
extra = set(body.keys()) - allowed_fields
|
||||
missing = allowed_fields - set(body.keys())
|
||||
if missing:
|
||||
raise BadRequestError(f"Missing required fields: {', '.join(missing)}")
|
||||
if extra:
|
||||
raise BadRequestError(f"Unexpected fields: {', '.join(extra)}")
|
||||
|
||||
text = body.get('text')
|
||||
if not isinstance(text, str):
|
||||
raise BadRequestError("text must be a string")
|
||||
if len(text) < 1 or len(text) > 4000:
|
||||
raise BadRequestError("text length must be between 1 and 4000 characters")
|
||||
if not text.strip():
|
||||
raise BadRequestError("text cannot consist only of whitespace")
|
||||
|
||||
return {'text': text}
|
||||
|
||||
|
||||
def parse_limit(limit_param: Optional[str]) -> int:
|
||||
if limit_param is None:
|
||||
return 50
|
||||
try:
|
||||
limit = int(limit_param)
|
||||
except (ValueError, TypeError):
|
||||
raise BadRequestError("limit must be an integer")
|
||||
if limit < 1 or limit > 100:
|
||||
raise BadRequestError("limit must be between 1 and 100")
|
||||
return limit
|
||||
|
||||
|
||||
def encode_cursor(created_at: str, item_id: str, resource_type: str, chat_id: Optional[str] = None) -> str:
|
||||
data = {
|
||||
't': created_at,
|
||||
'id': item_id,
|
||||
'type': resource_type,
|
||||
}
|
||||
if chat_id is not None:
|
||||
data['cid'] = chat_id
|
||||
raw = json.dumps(data, separators=(',', ':')).encode('utf-8')
|
||||
return base64.urlsafe_b64encode(raw).decode('ascii')
|
||||
|
||||
|
||||
def decode_cursor(cursor_str: str, expected_type: str, expected_chat_id: Optional[str] = None) -> Tuple[dt.datetime, int]:
|
||||
try:
|
||||
if len(cursor_str) > 2048:
|
||||
raise ValueError
|
||||
raw = base64.b64decode(cursor_str.encode('ascii'), altchars=b'-_', validate=True)
|
||||
data = json.loads(raw.decode('utf-8'))
|
||||
if not isinstance(data, dict):
|
||||
raise ValueError
|
||||
if data.get('type') != expected_type:
|
||||
raise BadRequestError("Cursor does not match resource type")
|
||||
if expected_chat_id is not None and data.get('cid') != expected_chat_id:
|
||||
raise BadRequestError("Cursor belongs to another chat")
|
||||
t = parse_rfc3339(data['t'])
|
||||
if t.utcoffset() != dt.timedelta(0):
|
||||
raise ValueError
|
||||
u_int = uuid.UUID(data['id']).int
|
||||
return t, u_int
|
||||
except APIError:
|
||||
raise
|
||||
except Exception:
|
||||
raise BadRequestError("Invalid cursor format")
|
||||
+300
@@ -0,0 +1,300 @@
|
||||
import base64
|
||||
import binascii
|
||||
import json
|
||||
import socket
|
||||
|
||||
import psycopg
|
||||
from psycopg_pool import PoolTimeout, TooManyRequests
|
||||
import logging
|
||||
import re
|
||||
import time
|
||||
import urllib.parse
|
||||
import uuid
|
||||
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
|
||||
from typing import Any, Dict, Optional, Tuple
|
||||
|
||||
from app.errors import (
|
||||
APIError,
|
||||
BadRequestError,
|
||||
InternalError,
|
||||
NotFoundError,
|
||||
UnauthorizedError,
|
||||
UnavailableError,
|
||||
)
|
||||
from app.models import (
|
||||
parse_limit,
|
||||
validate_create_chat,
|
||||
validate_create_message,
|
||||
validate_create_user,
|
||||
validate_uuid,
|
||||
)
|
||||
from app.storage import PostgresStorage
|
||||
|
||||
logger = logging.getLogger("messenger")
|
||||
|
||||
CHAT_MESSAGES_PATTERN = re.compile(r"^/api/v1/chats/([^/]+)/messages$")
|
||||
CHAT_DETAIL_PATTERN = re.compile(r"^/api/v1/chats/([^/]+)$")
|
||||
|
||||
|
||||
class MessengerHandler(BaseHTTPRequestHandler):
|
||||
server_version = "MTUSI-Messenger/1.0"
|
||||
|
||||
@property
|
||||
def storage(self) -> PostgresStorage:
|
||||
return self.server.storage # type: ignore
|
||||
|
||||
@property
|
||||
def is_shutting_down(self) -> bool:
|
||||
return getattr(self.server, "is_shutting_down", False)
|
||||
|
||||
def log_message(self, format: str, *args: Any):
|
||||
# Suppress default BaseHTTPRequestHandler noisy log
|
||||
pass
|
||||
|
||||
def _get_request_id(self) -> str:
|
||||
return str(uuid.uuid4())
|
||||
|
||||
def setup(self):
|
||||
super().setup()
|
||||
self.connection.settimeout(10)
|
||||
|
||||
def _send_json(self, status_code: int, data: Optional[Dict[str, Any]], request_id: str):
|
||||
body = b""
|
||||
if data is not None and status_code != 204:
|
||||
body = json.dumps(data, ensure_ascii=False).encode("utf-8")
|
||||
|
||||
self.send_response(status_code)
|
||||
self.send_header("Content-Type", "application/json")
|
||||
self.send_header("Content-Length", str(len(body)))
|
||||
self.send_header("X-Request-Id", request_id)
|
||||
if status_code == 401:
|
||||
challenge = ('Basic realm="messenger", charset="UTF-8"' if
|
||||
urllib.parse.urlparse(self.path).path == '/api/v1/auth/sessions'
|
||||
else 'Bearer realm="messenger"')
|
||||
self.send_header('WWW-Authenticate', challenge)
|
||||
self.end_headers()
|
||||
if body:
|
||||
self.wfile.write(body)
|
||||
|
||||
def _send_error(self, err: APIError, request_id: str):
|
||||
payload = err.to_dict(request_id)
|
||||
self._send_json(err.status_code, payload, request_id)
|
||||
|
||||
def _read_json_body(self) -> Any:
|
||||
if self.headers.get('Transfer-Encoding'):
|
||||
raise BadRequestError('Transfer-Encoding is not supported')
|
||||
if self.headers.get_content_type() != 'application/json':
|
||||
raise APIError('unsupported_media_type', 'Expected application/json', 415)
|
||||
content_length_header = self.headers.get("Content-Length")
|
||||
if not content_length_header:
|
||||
raise BadRequestError("Missing request body")
|
||||
try:
|
||||
content_length = int(content_length_header)
|
||||
except (ValueError, TypeError):
|
||||
raise BadRequestError("Invalid Content-Length header")
|
||||
if content_length < 0 or content_length > 10 * 1024 * 1024:
|
||||
raise BadRequestError("Payload size invalid")
|
||||
|
||||
raw_data = self.rfile.read(content_length)
|
||||
if not raw_data:
|
||||
raise BadRequestError("Empty request body")
|
||||
|
||||
try:
|
||||
body = json.loads(raw_data.decode("utf-8"))
|
||||
# Reject unpaired surrogates before a driver/KDF tries to encode them.
|
||||
json.dumps(body, ensure_ascii=False).encode('utf-8')
|
||||
return body
|
||||
except (ValueError, UnicodeError):
|
||||
raise BadRequestError("Malformed JSON in request body")
|
||||
|
||||
def _bearer(self):
|
||||
parts = self.headers.get('Authorization', '').split()
|
||||
if len(parts) != 2 or parts[0].lower() != 'bearer' or len(parts[1]) > 512:
|
||||
raise UnauthorizedError()
|
||||
return parts[1]
|
||||
|
||||
def _authenticate_user(self):
|
||||
return self.storage.authenticate(self._bearer())
|
||||
|
||||
def _login(self):
|
||||
parts = self.headers.get('Authorization', '').split()
|
||||
if len(parts) != 2 or parts[0].lower() != 'basic' or len(parts[1]) > 2048:
|
||||
raise UnauthorizedError('Invalid credentials')
|
||||
try:
|
||||
credential = base64.b64decode(parts[1], validate=True).decode('utf-8')
|
||||
username, password = credential.split(':', 1)
|
||||
if not re.fullmatch(r'[a-z0-9_]{3,32}', username) or not 12 <= len(password) <= 128:
|
||||
raise ValueError
|
||||
except (ValueError, UnicodeError, binascii.Error):
|
||||
raise UnauthorizedError('Invalid credentials') from None
|
||||
if self.headers.get('Transfer-Encoding') or self.headers.get('Content-Length', '0') != '0':
|
||||
raise BadRequestError('Session creation has no body')
|
||||
return self.storage.login(username, password)
|
||||
|
||||
def do_PUT(self):
|
||||
self._handle_request("PUT")
|
||||
|
||||
def do_PATCH(self):
|
||||
self._handle_request("PATCH")
|
||||
|
||||
def do_OPTIONS(self):
|
||||
self._handle_request("OPTIONS")
|
||||
|
||||
def do_DELETE(self):
|
||||
self._handle_request("DELETE")
|
||||
|
||||
def do_GET(self):
|
||||
self._handle_request("GET")
|
||||
|
||||
def do_POST(self):
|
||||
self._handle_request("POST")
|
||||
|
||||
def _handle_request(self, method: str):
|
||||
start_time = time.monotonic()
|
||||
request_id = self._get_request_id()
|
||||
parsed_url = urllib.parse.urlparse(self.path)
|
||||
path = parsed_url.path
|
||||
query = urllib.parse.parse_qs(parsed_url.query, keep_blank_values=True)
|
||||
|
||||
status_code = 200
|
||||
try:
|
||||
if self.is_shutting_down and not path.startswith("/health/"):
|
||||
raise UnavailableError("Server is shutting down")
|
||||
|
||||
# Route dispatcher
|
||||
if method == "GET" and path == "/health/live":
|
||||
self._send_json(200, {"status": "ok"}, request_id)
|
||||
status_code = 200
|
||||
|
||||
elif method == "GET" and path == "/health/ready":
|
||||
if self.is_shutting_down:
|
||||
raise UnavailableError("Server is shutting down")
|
||||
self.storage.ready()
|
||||
self._send_json(200, {"status": "ok"}, request_id)
|
||||
status_code = 200
|
||||
|
||||
elif method == "POST" and path == "/api/v1/users":
|
||||
body = self._read_json_body()
|
||||
validated = validate_create_user(body)
|
||||
user = self.storage.create_user(**validated)
|
||||
self._send_json(201, user, request_id)
|
||||
status_code = 201
|
||||
|
||||
elif method == 'POST' and path == '/api/v1/auth/sessions':
|
||||
self._send_json(201, self._login(), request_id)
|
||||
status_code = 201
|
||||
|
||||
elif method == 'DELETE' and path == '/api/v1/auth/sessions/current':
|
||||
self.storage.logout(self._bearer())
|
||||
self._send_json(204, None, request_id)
|
||||
status_code = 204
|
||||
|
||||
elif method == "GET" and path == "/api/v1/users/me":
|
||||
actor = self._authenticate_user()
|
||||
self._send_json(200, actor, request_id)
|
||||
status_code = 200
|
||||
|
||||
elif method == "POST" and path == "/api/v1/chats":
|
||||
actor = self._authenticate_user()
|
||||
body = self._read_json_body()
|
||||
validated = validate_create_chat(body)
|
||||
chat = self.storage.create_chat(
|
||||
creator_id=actor["id"],
|
||||
title=validated["title"],
|
||||
member_ids=validated["member_ids"],
|
||||
)
|
||||
self._send_json(201, chat, request_id)
|
||||
status_code = 201
|
||||
|
||||
elif method == "GET" and path == "/api/v1/chats":
|
||||
actor = self._authenticate_user()
|
||||
limit_val = query.get("limit", [None])[0]
|
||||
cursor_val = query.get("cursor", [None])[0]
|
||||
limit = parse_limit(limit_val)
|
||||
result = self.storage.list_chats(actor["id"], limit=limit, cursor=cursor_val)
|
||||
self._send_json(200, result, request_id)
|
||||
status_code = 200
|
||||
|
||||
else:
|
||||
# Check regex routes
|
||||
match_messages = CHAT_MESSAGES_PATTERN.match(path)
|
||||
match_chat = CHAT_DETAIL_PATTERN.match(path)
|
||||
|
||||
if match_messages:
|
||||
raw_chat_id = match_messages.group(1)
|
||||
actor = self._authenticate_user()
|
||||
chat_id = validate_uuid(raw_chat_id, "chat_id")
|
||||
|
||||
if method == "POST":
|
||||
body = self._read_json_body()
|
||||
validated = validate_create_message(body)
|
||||
msg = self.storage.create_message(
|
||||
chat_id=chat_id,
|
||||
sender_id=actor["id"],
|
||||
text=validated["text"],
|
||||
)
|
||||
self._send_json(201, msg, request_id)
|
||||
status_code = 201
|
||||
elif method == "GET":
|
||||
limit_val = query.get("limit", [None])[0]
|
||||
cursor_val = query.get("cursor", [None])[0]
|
||||
limit = parse_limit(limit_val)
|
||||
result = self.storage.list_messages(
|
||||
user_id=actor["id"],
|
||||
chat_id=chat_id,
|
||||
limit=limit,
|
||||
cursor=cursor_val,
|
||||
)
|
||||
self._send_json(200, result, request_id)
|
||||
status_code = 200
|
||||
else:
|
||||
raise NotFoundError("Endpoint not found")
|
||||
|
||||
elif match_chat:
|
||||
raw_chat_id = match_chat.group(1)
|
||||
actor = self._authenticate_user()
|
||||
chat_id = validate_uuid(raw_chat_id, "chat_id")
|
||||
|
||||
if method == "GET":
|
||||
chat = self.storage.get_chat(user_id=actor["id"], chat_id=chat_id)
|
||||
self._send_json(200, chat, request_id)
|
||||
status_code = 200
|
||||
else:
|
||||
raise NotFoundError("Endpoint not found")
|
||||
else:
|
||||
raise NotFoundError(f"Route not found: {method} {path}")
|
||||
|
||||
except APIError as err:
|
||||
status_code = err.status_code
|
||||
self._send_error(err, request_id)
|
||||
except (psycopg.OperationalError, psycopg.InterfaceError, psycopg.errors.QueryCanceled,
|
||||
psycopg.errors.LockNotAvailable, PoolTimeout, TooManyRequests):
|
||||
status_code = 503
|
||||
self._send_error(UnavailableError(), request_id)
|
||||
except (socket.timeout, ConnectionError):
|
||||
status_code = 408
|
||||
self.close_connection = True
|
||||
except Exception as exc:
|
||||
status_code = 500
|
||||
logger.error("Unhandled exception type: %s", type(exc).__name__)
|
||||
self._send_error(InternalError("Internal server error"), request_id)
|
||||
finally:
|
||||
elapsed_ms = (time.monotonic() - start_time) * 1000
|
||||
# Safe structured log without payload content
|
||||
logger.info(
|
||||
"%s %s %d %.2fms req_id=%s",
|
||||
method,
|
||||
path,
|
||||
status_code,
|
||||
elapsed_ms,
|
||||
request_id,
|
||||
)
|
||||
|
||||
|
||||
class MessengerServer(ThreadingHTTPServer):
|
||||
daemon_threads = True
|
||||
|
||||
def __init__(self, server_address: Tuple[str, int], storage: Optional[PostgresStorage] = None):
|
||||
super().__init__(server_address, MessengerHandler)
|
||||
self.storage = storage or PostgresStorage()
|
||||
self.is_shutting_down = False
|
||||
+172
@@ -0,0 +1,172 @@
|
||||
"""Persistent users, chats, messages and sessions in PostgreSQL."""
|
||||
import datetime as dt
|
||||
import hashlib
|
||||
import secrets
|
||||
import uuid
|
||||
|
||||
import psycopg
|
||||
from psycopg.rows import dict_row
|
||||
from psycopg_pool import ConnectionPool
|
||||
from argon2 import PasswordHasher
|
||||
from argon2.exceptions import VerifyMismatchError, VerificationError, InvalidHashError
|
||||
|
||||
from app.config import secret, POOL_SIZE, SESSION_TTL_SECONDS
|
||||
from app.errors import BadRequestError, ConflictError, NotFoundError, UnauthorizedError
|
||||
from app.models import decode_cursor, encode_cursor
|
||||
|
||||
|
||||
def public(row):
|
||||
return {key: (str(value) if isinstance(value, uuid.UUID) else
|
||||
value.isoformat(timespec='microseconds').replace('+00:00', 'Z')
|
||||
if isinstance(value, dt.datetime) else value)
|
||||
for key, value in row.items() if key != 'password_hash'}
|
||||
|
||||
|
||||
def token_hash(token):
|
||||
return hashlib.sha256(token.encode()).hexdigest()
|
||||
|
||||
|
||||
class PostgresStorage:
|
||||
def __init__(self):
|
||||
self.pool = ConnectionPool(
|
||||
secret('DATABASE_URL'), min_size=1, max_size=POOL_SIZE, timeout=2,
|
||||
max_waiting=32, reconnect_timeout=3,
|
||||
kwargs={'connect_timeout': 2, 'row_factory': dict_row,
|
||||
'options': '-c statement_timeout=2500 -c lock_timeout=1500 -c timezone=UTC'},
|
||||
check=ConnectionPool.check_connection,
|
||||
)
|
||||
self.pool.wait(timeout=15)
|
||||
self.hasher = PasswordHasher(time_cost=3, memory_cost=65536, parallelism=2)
|
||||
self.dummy_hash = self.hasher.hash(secrets.token_urlsafe(32))
|
||||
|
||||
def close(self):
|
||||
self.pool.close()
|
||||
|
||||
def ready(self):
|
||||
with self.pool.connection() as conn:
|
||||
conn.execute('SELECT 1')
|
||||
|
||||
def create_user(self, username, display_name, password):
|
||||
password_hash = self.hasher.hash(password)
|
||||
try:
|
||||
with self.pool.connection() as conn:
|
||||
row = conn.execute('''INSERT INTO users(id, username, display_name, password_hash)
|
||||
VALUES (%s,%s,%s,%s) RETURNING id, username, display_name, created_at''',
|
||||
(uuid.uuid4(), username, display_name, password_hash)).fetchone()
|
||||
return public(row)
|
||||
except psycopg.errors.UniqueViolation:
|
||||
raise ConflictError('Username is already taken') from None
|
||||
|
||||
def get_user(self, user_id):
|
||||
with self.pool.connection() as conn:
|
||||
row = conn.execute('SELECT id,username,display_name,created_at FROM users WHERE id=%s', (user_id,)).fetchone()
|
||||
return public(row) if row else None
|
||||
|
||||
def login(self, username, password):
|
||||
with self.pool.connection() as conn:
|
||||
row = conn.execute('SELECT * FROM users WHERE username=%s', (username,)).fetchone()
|
||||
try:
|
||||
self.hasher.verify(row['password_hash'] if row else self.dummy_hash, password)
|
||||
except (VerifyMismatchError, VerificationError, InvalidHashError):
|
||||
raise UnauthorizedError('Invalid credentials') from None
|
||||
if not row:
|
||||
raise UnauthorizedError('Invalid credentials')
|
||||
token = secrets.token_urlsafe(32) # 256 random bits; never persist/log the raw token.
|
||||
with self.pool.connection() as conn:
|
||||
session = conn.execute('''INSERT INTO sessions(token_hash,user_id,expires_at)
|
||||
VALUES (%s,%s,clock_timestamp() + %s * interval '1 second') RETURNING expires_at''',
|
||||
(token_hash(token), row['id'], SESSION_TTL_SECONDS)).fetchone()
|
||||
return {'token': token, 'token_type': 'Bearer',
|
||||
'expires_at': public(session)['expires_at'], 'user': public(row)}
|
||||
|
||||
def authenticate(self, token):
|
||||
# Check expiry against the database clock on every protected request.
|
||||
with self.pool.connection() as conn:
|
||||
row = conn.execute('''SELECT user_id FROM sessions
|
||||
WHERE token_hash=%s AND expires_at > clock_timestamp()''', (token_hash(token),)).fetchone()
|
||||
if not row:
|
||||
raise UnauthorizedError()
|
||||
user = self.get_user(row['user_id'])
|
||||
if not user:
|
||||
raise UnauthorizedError()
|
||||
return user
|
||||
|
||||
def logout(self, token):
|
||||
with self.pool.connection() as conn:
|
||||
row = conn.execute('''DELETE FROM sessions WHERE token_hash=%s
|
||||
AND expires_at > clock_timestamp() RETURNING user_id''', (token_hash(token),)).fetchone()
|
||||
if not row:
|
||||
raise UnauthorizedError()
|
||||
|
||||
@staticmethod
|
||||
def _chat(conn, chat_id):
|
||||
row = conn.execute('SELECT * FROM chats WHERE id=%s', (chat_id,)).fetchone()
|
||||
result = public(row)
|
||||
result['member_ids'] = [str(r['user_id']) for r in conn.execute(
|
||||
'SELECT user_id FROM memberships WHERE chat_id=%s ORDER BY user_id', (chat_id,))]
|
||||
return result
|
||||
|
||||
@staticmethod
|
||||
def _access(conn, user_id, chat_id):
|
||||
if not conn.execute('SELECT 1 FROM memberships WHERE chat_id=%s AND user_id=%s',
|
||||
(chat_id, user_id)).fetchone():
|
||||
raise NotFoundError('Chat not found')
|
||||
|
||||
def create_chat(self, creator_id, title, member_ids):
|
||||
if creator_id not in member_ids:
|
||||
raise BadRequestError('Creator must be included in member_ids')
|
||||
try:
|
||||
with self.pool.connection() as conn:
|
||||
chat_id = uuid.uuid4()
|
||||
conn.execute('INSERT INTO chats(id,title) VALUES (%s,%s)', (chat_id, title))
|
||||
with conn.cursor() as cur:
|
||||
cur.executemany('INSERT INTO memberships(chat_id,user_id) VALUES (%s,%s)',
|
||||
[(chat_id, user_id) for user_id in member_ids])
|
||||
chat = self._chat(conn, chat_id)
|
||||
return chat
|
||||
except psycopg.errors.ForeignKeyViolation:
|
||||
# Exiting connection() rolls back chat and every already inserted member.
|
||||
raise BadRequestError('Unknown participant') from None
|
||||
|
||||
def get_chat(self, user_id, chat_id):
|
||||
with self.pool.connection() as conn:
|
||||
self._access(conn, user_id, chat_id)
|
||||
return self._chat(conn, chat_id)
|
||||
|
||||
def list_chats(self, user_id, limit=50, cursor=None):
|
||||
params = [user_id]
|
||||
condition = ''
|
||||
if cursor is not None:
|
||||
stamp, item_id = decode_cursor(cursor, 'chat', user_id)
|
||||
condition = ' AND (c.created_at,c.id) > (%s,%s)'
|
||||
params.extend([stamp, uuid.UUID(int=item_id)])
|
||||
params.append(limit + 1)
|
||||
with self.pool.connection() as conn:
|
||||
rows = conn.execute('''SELECT c.* FROM chats c JOIN memberships m ON m.chat_id=c.id
|
||||
WHERE m.user_id=%s''' + condition + ' ORDER BY c.created_at,c.id LIMIT %s', params).fetchall()
|
||||
items = [self._chat(conn, row['id']) for row in rows[:limit]]
|
||||
next_cursor = encode_cursor(items[-1]['created_at'], items[-1]['id'], 'chat', user_id) if len(rows) > limit else None
|
||||
return {'items': items, 'next_cursor': next_cursor}
|
||||
|
||||
def create_message(self, chat_id, sender_id, text):
|
||||
with self.pool.connection() as conn:
|
||||
self._access(conn, sender_id, chat_id)
|
||||
row = conn.execute('''INSERT INTO messages(id,chat_id,sender_id,text)
|
||||
VALUES (%s,%s,%s,%s) RETURNING *''', (uuid.uuid4(), chat_id, sender_id, text)).fetchone()
|
||||
return public(row)
|
||||
|
||||
def list_messages(self, user_id, chat_id, limit=50, cursor=None):
|
||||
params = [chat_id]
|
||||
condition = ''
|
||||
if cursor is not None:
|
||||
stamp, item_id = decode_cursor(cursor, 'message', chat_id)
|
||||
condition = ' AND (created_at,id) > (%s,%s)'
|
||||
params.extend([stamp, uuid.UUID(int=item_id)])
|
||||
params.append(limit + 1)
|
||||
with self.pool.connection() as conn:
|
||||
self._access(conn, user_id, chat_id)
|
||||
rows = conn.execute('SELECT * FROM messages WHERE chat_id=%s' + condition +
|
||||
' ORDER BY created_at,id LIMIT %s', params).fetchall()
|
||||
items = [public(row) for row in rows[:limit]]
|
||||
next_cursor = encode_cursor(items[-1]['created_at'], items[-1]['id'], 'message', chat_id) if len(rows) > limit else None
|
||||
return {'items': items, 'next_cursor': next_cursor}
|
||||
@@ -0,0 +1,48 @@
|
||||
name: mtusi-lab2
|
||||
services:
|
||||
postgres:
|
||||
image: postgres:17.4-bookworm
|
||||
environment:
|
||||
POSTGRES_DB: messenger
|
||||
POSTGRES_USER: messenger
|
||||
POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password
|
||||
secrets: [postgres_password]
|
||||
volumes:
|
||||
- postgres_data:/var/lib/postgresql/data
|
||||
healthcheck:
|
||||
test: [CMD-SHELL, 'pg_isready -U messenger -d messenger']
|
||||
interval: 2s
|
||||
timeout: 3s
|
||||
retries: 30
|
||||
restart: unless-stopped
|
||||
api:
|
||||
build: .
|
||||
environment:
|
||||
APP_HOST: 0.0.0.0
|
||||
APP_PORT: '8080'
|
||||
APP_ENV: lab
|
||||
DATABASE_URL_FILE: /run/secrets/database_url
|
||||
SESSION_STORE: postgres
|
||||
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
|
||||
DB_POOL_SIZE: ${DB_POOL_SIZE:-8}
|
||||
secrets: [database_url]
|
||||
ports:
|
||||
- '127.0.0.1:${API_PORT:-8080}:8080'
|
||||
depends_on:
|
||||
postgres:
|
||||
condition: service_healthy
|
||||
healthcheck:
|
||||
test: [CMD, python, -c, "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=4)"]
|
||||
interval: 2s
|
||||
timeout: 5s
|
||||
retries: 30
|
||||
init: true
|
||||
stop_grace_period: 15s
|
||||
restart: unless-stopped
|
||||
volumes:
|
||||
postgres_data:
|
||||
secrets:
|
||||
postgres_password:
|
||||
file: ./secrets/postgres_password
|
||||
database_url:
|
||||
file: ./secrets/database_url
|
||||
@@ -0,0 +1,2 @@
|
||||
python3 scripts/check_contract.py
|
||||
PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.
|
||||
@@ -0,0 +1,10 @@
|
||||
Container mtusi-lab2-api-1 Recreate
|
||||
Container mtusi-lab2-api-1 Recreated
|
||||
Container mtusi-lab2-api-1 Starting
|
||||
Container mtusi-lab2-api-1 Started
|
||||
PASS SESSION_TTL_SECONDS=2: session accepted before expiry and rejected afterwards
|
||||
Container mtusi-lab2-api-1 Recreate
|
||||
Container mtusi-lab2-api-1 Recreated
|
||||
Container mtusi-lab2-api-1 Starting
|
||||
Container mtusi-lab2-api-1 Started
|
||||
PASS expiry scenario; normal API configuration restored
|
||||
@@ -0,0 +1,11 @@
|
||||
test_bad_credentials_and_validation (test_integration.IntegrationTests.test_bad_credentials_and_validation) ... ok
|
||||
test_history_and_cross_chat_cursor (test_integration.IntegrationTests.test_history_and_cross_chat_cursor) ... ok
|
||||
test_logout_revokes_session (test_integration.IntegrationTests.test_logout_revokes_session) ... ok
|
||||
test_migrations_are_repeatable (test_integration.IntegrationTests.test_migrations_are_repeatable) ... ok
|
||||
test_registration_race_and_password_storage (test_integration.IntegrationTests.test_registration_race_and_password_storage) ... ok
|
||||
test_rollback_after_partial_chat_insert (test_integration.IntegrationTests.test_rollback_after_partial_chat_insert) ... ok
|
||||
|
||||
----------------------------------------------------------------------
|
||||
Ran 6 tests in 0.685s
|
||||
|
||||
OK
|
||||
@@ -0,0 +1,2 @@
|
||||
.venv/bin/python scripts/validate_openapi.py
|
||||
PASS: full OpenAPI 3.1 and JSON Schema validation; application NOT tested.
|
||||
@@ -0,0 +1,3 @@
|
||||
python3 tests/resilience.py --mode persistence --action-script "scripts/restart.sh" --base-url "http://localhost:8080"
|
||||
Executing explicit persistence hook; hook output suppressed to avoid leaking secrets.
|
||||
PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.
|
||||
@@ -0,0 +1,22 @@
|
||||
{
|
||||
"before": {
|
||||
"api": {
|
||||
"container_id": "56edea40b5725e2d7cb53b3845e3add8736cd97b0d3aa5d6ed7f3edd60d39490",
|
||||
"started_at": "2026-10-29T14:14:33.964585083Z"
|
||||
},
|
||||
"postgres": {
|
||||
"container_id": "06377e012859509c85940553ce08940f53b54784f689bb743a20f2a0e27c9940",
|
||||
"started_at": "2026-10-29T14:14:31.393036638Z"
|
||||
}
|
||||
},
|
||||
"after": {
|
||||
"api": {
|
||||
"container_id": "56edea40b5725e2d7cb53b3845e3add8736cd97b0d3aa5d6ed7f3edd60d39490",
|
||||
"started_at": "2026-10-29T14:14:45.403053172Z"
|
||||
},
|
||||
"postgres": {
|
||||
"container_id": "06377e012859509c85940553ce08940f53b54784f689bb743a20f2a0e27c9940",
|
||||
"started_at": "2026-10-29T14:14:45.180754422Z"
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,2 @@
|
||||
python3 tests/smoke.py --base-url "http://localhost:8080"
|
||||
PASS: lab2 public API scenario; infrastructure and grading evidence remain separate.
|
||||
@@ -0,0 +1,36 @@
|
||||
CREATE TABLE users (
|
||||
id uuid PRIMARY KEY,
|
||||
username text NOT NULL UNIQUE CHECK (username ~ '^[a-z0-9_]{3,32}$'),
|
||||
display_name text NOT NULL CHECK (char_length(display_name) BETWEEN 1 AND 100),
|
||||
password_hash text NOT NULL,
|
||||
created_at timestamptz NOT NULL DEFAULT clock_timestamp()
|
||||
);
|
||||
CREATE TABLE chats (
|
||||
id uuid PRIMARY KEY,
|
||||
title text NOT NULL CHECK (char_length(title) BETWEEN 1 AND 100),
|
||||
created_at timestamptz NOT NULL DEFAULT clock_timestamp()
|
||||
);
|
||||
CREATE TABLE memberships (
|
||||
chat_id uuid NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
|
||||
user_id uuid NOT NULL REFERENCES users(id),
|
||||
PRIMARY KEY (chat_id, user_id)
|
||||
);
|
||||
CREATE INDEX memberships_by_user ON memberships(user_id, chat_id);
|
||||
CREATE INDEX chats_history ON chats(created_at, id);
|
||||
CREATE TABLE messages (
|
||||
id uuid PRIMARY KEY,
|
||||
chat_id uuid NOT NULL REFERENCES chats(id),
|
||||
sender_id uuid NOT NULL REFERENCES users(id),
|
||||
text text NOT NULL CHECK (char_length(text) BETWEEN 1 AND 4000),
|
||||
created_at timestamptz NOT NULL DEFAULT clock_timestamp(),
|
||||
FOREIGN KEY (chat_id, sender_id) REFERENCES memberships(chat_id, user_id)
|
||||
);
|
||||
CREATE INDEX messages_history ON messages(chat_id, created_at, id);
|
||||
CREATE TABLE sessions (
|
||||
token_hash text PRIMARY KEY,
|
||||
user_id uuid NOT NULL REFERENCES users(id) ON DELETE CASCADE,
|
||||
created_at timestamptz NOT NULL DEFAULT clock_timestamp(),
|
||||
expires_at timestamptz NOT NULL,
|
||||
CHECK (expires_at > created_at)
|
||||
);
|
||||
CREATE INDEX sessions_expiry ON sessions(expires_at);
|
||||
@@ -0,0 +1,3 @@
|
||||
psycopg[binary]==3.2.6
|
||||
psycopg-pool==3.2.6
|
||||
argon2-cffi==23.1.0
|
||||
@@ -0,0 +1,27 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Create local synthetic credentials once. Never print their values."""
|
||||
import os
|
||||
from pathlib import Path
|
||||
import secrets
|
||||
|
||||
root = Path(__file__).resolve().parents[1]
|
||||
os.umask(0o077)
|
||||
folder = root / 'secrets'
|
||||
folder.mkdir(exist_ok=True)
|
||||
password_path = folder / 'postgres_password'
|
||||
if not password_path.exists():
|
||||
password_path.write_text(secrets.token_hex(24))
|
||||
password = password_path.read_text().strip()
|
||||
for name, value in {
|
||||
'database_url': 'postgresql://messenger:' + password + '@postgres:5432/messenger',
|
||||
}.items():
|
||||
path = folder / name
|
||||
if not path.exists():
|
||||
path.write_text(value)
|
||||
# Docker Desktop mounts are read by the non-root API user too. Directory remains private.
|
||||
for path in folder.iterdir():
|
||||
path.chmod(0o444)
|
||||
env = root / '.env'
|
||||
if not env.exists():
|
||||
env.write_text('API_PORT=8080\nSESSION_TTL_SECONDS=3600\nDB_POOL_SIZE=8\n')
|
||||
print('Local secrets and .env ready (values hidden; existing files preserved).')
|
||||
Executable
+5
@@ -0,0 +1,5 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
cd "$(dirname "$0")/.."
|
||||
# All state stores and API; named volumes remain attached. No reseeding.
|
||||
docker compose --env-file .env restart postgres api
|
||||
@@ -0,0 +1,52 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Check real session expiry with TTL=2 and restore normal API configuration."""
|
||||
import os
|
||||
from pathlib import Path
|
||||
import subprocess
|
||||
import sys
|
||||
import time
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
sys.path.insert(0,str(ROOT / 'tests'))
|
||||
from client import Client, Failure, check
|
||||
|
||||
COMPOSE = ['docker','compose','--env-file','.env']
|
||||
|
||||
|
||||
def compose(*args, env=None):
|
||||
subprocess.run(COMPOSE+list(args),cwd=ROOT,env=env,check=True,
|
||||
stdout=subprocess.DEVNULL)
|
||||
|
||||
|
||||
def ready(c):
|
||||
deadline=time.monotonic()+60
|
||||
while time.monotonic()<deadline:
|
||||
try:
|
||||
c.call('GET','/health/ready')
|
||||
return
|
||||
except Failure:
|
||||
time.sleep(0.5)
|
||||
raise AssertionError('Readiness timeout')
|
||||
|
||||
|
||||
def main():
|
||||
c=Client()
|
||||
ready(c)
|
||||
try:
|
||||
env=dict(os.environ,SESSION_TTL_SECONDS='2')
|
||||
compose('up','-d','--no-deps','--force-recreate','api',env=env)
|
||||
ready(c)
|
||||
short=c.user('expiry')
|
||||
c.call('GET','/api/v1/users/me',actor=short,schema='User')
|
||||
time.sleep(2.3)
|
||||
c.call('GET','/api/v1/users/me',401,actor=short)
|
||||
c.call('DELETE','/api/v1/auth/sessions/current',401,actor=short)
|
||||
print('PASS SESSION_TTL_SECONDS=2: session accepted before expiry and rejected afterwards',flush=True)
|
||||
finally:
|
||||
compose('up','-d','--no-deps','--force-recreate','api')
|
||||
ready(c)
|
||||
print('PASS expiry scenario; normal API configuration restored',flush=True)
|
||||
|
||||
|
||||
if __name__=='__main__':
|
||||
main()
|
||||
@@ -0,0 +1,50 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Run all lab2 checks and save sanitized evidence. Start Compose first."""
|
||||
import json
|
||||
from pathlib import Path
|
||||
import subprocess
|
||||
import sys
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
COMPOSE = ['docker','compose','--env-file','.env']
|
||||
|
||||
|
||||
def capture(name, args):
|
||||
result = subprocess.run(args,cwd=ROOT,text=True,stdout=subprocess.PIPE,stderr=subprocess.STDOUT)
|
||||
(ROOT/'evidence'/name).write_text(result.stdout)
|
||||
print(result.stdout,end='',flush=True)
|
||||
if result.returncode:
|
||||
raise SystemExit(result.returncode)
|
||||
|
||||
|
||||
def snapshot():
|
||||
ids = subprocess.check_output(COMPOSE+['ps','-q'],cwd=ROOT,text=True).split()
|
||||
result = {}
|
||||
for cid in ids:
|
||||
# Select fields explicitly: full inspect includes private configuration.
|
||||
fields = subprocess.check_output(['docker','inspect','--format',
|
||||
'{{ index .Config.Labels "com.docker.compose.service" }}|{{.Id}}|{{.State.StartedAt}}',cid],text=True).strip().split('|')
|
||||
result[fields[0]]={'container_id':fields[1],'started_at':fields[2]}
|
||||
return result
|
||||
|
||||
|
||||
def main():
|
||||
capture('check.txt',['make','check'])
|
||||
capture('smoke.txt',['make','test'])
|
||||
capture('integration.txt',COMPOSE+['exec','-T','api','python','-m','unittest','discover','-s','student-tests','-v'])
|
||||
before = snapshot()
|
||||
capture('persistence.txt',['make','test-persistence','ACTION_SCRIPT=scripts/restart.sh'])
|
||||
after = snapshot()
|
||||
if set(before) != {'api','postgres'} or set(after) != set(before):
|
||||
raise AssertionError('Expected API and PostgreSQL')
|
||||
for role in before:
|
||||
if before[role]['started_at']==after[role]['started_at']:
|
||||
raise AssertionError(role+' was not restarted')
|
||||
(ROOT/'evidence'/'restart-containers.json').write_text(json.dumps({'before':before,'after':after},indent=2)+'\n')
|
||||
print('PASS restart timestamps changed for API and PostgreSQL',flush=True)
|
||||
capture('expiry.txt',[sys.executable,'scripts/test_expiry.py'])
|
||||
print('PASS full verification; evidence/ updated',flush=True)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
main()
|
||||
@@ -0,0 +1,100 @@
|
||||
"""Run inside the API container against the real PostgreSQL stack."""
|
||||
import base64
|
||||
from concurrent.futures import ThreadPoolExecutor
|
||||
import json
|
||||
from pathlib import Path
|
||||
import sys
|
||||
import unittest
|
||||
from urllib.parse import quote
|
||||
import uuid
|
||||
|
||||
sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
|
||||
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'tests'))
|
||||
import psycopg
|
||||
from client import Client
|
||||
from app.config import secret
|
||||
from app.migrate import migrate
|
||||
from app.storage import token_hash
|
||||
|
||||
|
||||
class IntegrationTests(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.c = Client('http://127.0.0.1:8080')
|
||||
cls.alice, cls.bob, cls.eve, cls.chat = cls.c.bootstrap()
|
||||
|
||||
def test_registration_race_and_password_storage(self):
|
||||
body = {'username': 'race_' + uuid.uuid4().hex[:16], 'display_name': 'Гонка', 'password': 'пароль:🔑' * 16}
|
||||
def register(_):
|
||||
return Client('http://127.0.0.1:8080').call('POST', '/api/v1/users', [201,409], body=body)['status']
|
||||
with ThreadPoolExecutor(max_workers=4) as pool:
|
||||
codes = list(pool.map(register, range(4)))
|
||||
self.assertEqual(sorted(codes), [201,409,409,409])
|
||||
credential = base64.b64encode((body['username'] + ':' + body['password']).encode()).decode()
|
||||
session = self.c.call('POST','/api/v1/auth/sessions',201,headers={'Authorization': 'Basic ' + credential},schema='Session')['json']
|
||||
with psycopg.connect(secret('DATABASE_URL')) as conn:
|
||||
hashed = conn.execute('SELECT password_hash FROM users WHERE username=%s', (body['username'],)).fetchone()[0]
|
||||
self.assertTrue(hashed.startswith('$argon2id$'))
|
||||
self.assertNotEqual(hashed, body['password'])
|
||||
self.assertEqual(len(base64.urlsafe_b64decode(session['token'] + '=')), 32)
|
||||
stored = conn.execute('SELECT token_hash FROM sessions WHERE token_hash=%s', (token_hash(session['token']),)).fetchone()[0]
|
||||
self.assertNotEqual(stored, session['token'])
|
||||
|
||||
def test_rollback_after_partial_chat_insert(self):
|
||||
title = 'rollback_' + uuid.uuid4().hex
|
||||
self.c.call('POST','/api/v1/chats',400,actor=self.alice,
|
||||
body={'title':title,'member_ids':[self.alice['id'],str(uuid.uuid4())]})
|
||||
with psycopg.connect(secret('DATABASE_URL')) as conn:
|
||||
count = conn.execute('SELECT count(*) FROM chats WHERE title=%s',(title,)).fetchone()[0]
|
||||
self.assertEqual(count,0, 'failed chat creation must roll back inserted chat')
|
||||
|
||||
def test_logout_revokes_session(self):
|
||||
actor = self.c.user('logout')
|
||||
self.c.call('GET','/api/v1/users/me',actor=actor,schema='User')
|
||||
self.c.call('DELETE','/api/v1/auth/sessions/current',204,actor=actor)
|
||||
self.c.call('GET','/api/v1/users/me',401,actor=actor)
|
||||
self.c.call('DELETE','/api/v1/auth/sessions/current',401,actor=actor)
|
||||
|
||||
def test_history_and_cross_chat_cursor(self):
|
||||
chat = self.c.call('POST','/api/v1/chats',201,actor=self.alice,
|
||||
body={'title':'Cursor','member_ids':[self.alice['id']]},schema='Chat')['json']
|
||||
sent = [self.c.message(self.alice,chat,'Строка ' + str(i))['json'] for i in range(5)]
|
||||
path = '/api/v1/chats/' + chat['id'] + '/messages'
|
||||
page = self.c.call('GET',path+'?limit=2',actor=self.alice,schema='MessagePage')['json']
|
||||
received = page['items'][:]
|
||||
foreign = '/api/v1/chats/' + self.chat['id'] + '/messages?cursor=' + quote(page['next_cursor'],safe='')
|
||||
self.c.call('GET',foreign,400,actor=self.alice)
|
||||
while page['next_cursor']:
|
||||
page = self.c.call('GET',path+'?limit=1&cursor='+quote(page['next_cursor'],safe=''),actor=self.alice,schema='MessagePage')['json']
|
||||
received.extend(page['items'])
|
||||
self.assertEqual(sent,received)
|
||||
for query in ('cursor=broken','cursor=','limit=','limit=101','limit=1.5'):
|
||||
self.c.call('GET',path+'?'+query,400,actor=self.alice)
|
||||
self.c.call('GET',path,404,actor=self.eve)
|
||||
self.c.call('GET','/api/v1/chats/not-a-uuid/messages',401)
|
||||
|
||||
def test_migrations_are_repeatable(self):
|
||||
def counts():
|
||||
with psycopg.connect(secret('DATABASE_URL')) as conn:
|
||||
return conn.execute('SELECT (SELECT count(*) FROM schema_migrations), (SELECT count(*) FROM users), (SELECT count(*) FROM chats)').fetchone()
|
||||
before = counts()
|
||||
migrate()
|
||||
migrate()
|
||||
self.assertEqual(counts(),before)
|
||||
|
||||
def test_bad_credentials_and_validation(self):
|
||||
actor = self.c.user('negative')
|
||||
for credential in ('!!!',base64.b64encode((actor['registration']['username']+':wrong-password').encode()).decode(),
|
||||
base64.b64encode(b'unknown_user:wrong-password').decode()):
|
||||
response = self.c.call('POST','/api/v1/auth/sessions',401,headers={'Authorization':'Basic '+credential})
|
||||
self.assertEqual(response['json']['error']['message'],'Invalid credentials')
|
||||
self.c.call('GET','/api/v1/users/me',401,headers={'Authorization':'Bearer not-a-session'})
|
||||
self.c.call('POST','/api/v1/users',400,raw=b'{broken',headers={'Content-Type':'application/json'})
|
||||
self.c.call('POST','/api/v1/users',400,body={**actor['registration'],'extra':True})
|
||||
self.c.call('POST','/api/v1/users',400,body={**actor['registration'],'password':'short'})
|
||||
self.c.call('POST','/api/v1/users',400,body={**actor['registration'],'username':'bad\n'})
|
||||
self.c.call('POST','/api/v1/users',400,raw=json.dumps({**actor['registration'],'display_name':'\ud800'}).encode(),headers={'Content-Type':'application/json'})
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main(verbosity=2)
|
||||
Reference in New Issue
Block a user