Solution/bpi2304 sirenko #190

Closed
nothingredmouth wants to merge 8 commits from nothingredmouth/mtusi2026lab2-fork:solution/BPI2304-sirenko into master
29 changed files with 1203 additions and 23 deletions
+28
View File
@@ -0,0 +1,28 @@
name: Application
on: [push, pull_request]
permissions:
contents: read
jobs:
postgres-compose:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: actions/setup-python@v5
with:
python-version: '3.11'
- run: python scripts/init_local.py
- run: docker compose config --quiet
- run: docker compose up -d --build --wait --wait-timeout 120
- run: make check test
- run: docker compose exec -T api python -m messenger.migrate
- run: |
docker compose cp student-tests api:/app/student-tests
docker compose exec -T api python -m unittest discover -s student-tests -v
- run: chmod +x scripts/restart.sh && make test-persistence ACTION_SCRIPT=scripts/restart.sh
- uses: actions/upload-artifact@v4
if: always()
with:
name: restart-evidence
path: evidence/restart-*.txt
- if: always()
run: docker compose down
+10
View File
@@ -0,0 +1,10 @@
FROM python:3.11.11-slim-bookworm
WORKDIR /app
ENV PYTHONDONTWRITEBYTECODE=1 PYTHONUNBUFFERED=1 APP_HOST=0.0.0.0 APP_PORT=8080 APP_ENV=lab
COPY requirements.txt ./
RUN pip install --no-cache-dir -r requirements.txt
COPY messenger ./messenger
EXPOSE 8080
COPY migrations ./migrations
COPY scripts/start.sh ./scripts/start.sh
CMD ["sh", "scripts/start.sh"]
+8
View File
@@ -24,3 +24,11 @@ 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: run migrate student-test
run:
$(PYTHON) -m messenger
migrate:
$(PYTHON) -m messenger.migrate
student-test:
$(PYTHON) -m unittest discover -s student-tests -v
+147 -23
View File
@@ -1,37 +1,161 @@
# Отчёт — лабораторная 2
# Отчёт — лабораторная работа №2
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- Автор: **Сиренко Илья**.
- Группа: **БПИ2304**.
- Целевая оценка: **3**. Redis/Valkey и треки уровней 4–5 не заявлены.
- Commit / PR: заполнить после публикации в своём fork.
- Стек сохранён из lab1: Python 3.9+, Flask 3.1.0, Waitress 3.0.2. Добавлены PostgreSQL, psycopg 3.2.6 и argon2-cffi 23.1.0.
## Запуск из чистого clone
## Запуск из чистого clone / ZIP
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
Нужны Docker Engine / Docker Desktop с Compose v2 (поддержкой `up --wait`), Python 3.9+ и доступ к Docker Hub/PyPI для первой сборки. Все команды выполняются в корне `mtusi2026lab2`. Для Linux/macOS или Windows WSL:
## Архитектура и решения
```sh
python3 scripts/init_local.py
docker compose config --quiet
docker compose up -d --build --wait --wait-timeout 120
curl --fail http://localhost:8080/health/ready
make check
make test
chmod +x scripts/restart.sh
make test-persistence ACTION_SCRIPT=scripts/restart.sh
```
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
`init_local.py` создаёт `.env` из шаблона и случайные credentials в `secrets/`. Повторный запуск сохраняет имеющиеся файлы. Не удалять secrets при сохранённом volume: PostgreSQL не меняет пароль существующего пользователя от замены POSTGRES_PASSWORD_FILE. При неполном комплекте secrets скрипт останавливается, не перезаписывая оставшийся файл.
## Доказательства критериев
Если нет make, публичные тесты запускаются непосредственно Python:
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
```sh
python3 scripts/check_contract.py
python3 tests/smoke.py --base-url http://localhost:8080
python3 tests/resilience.py --mode persistence \
--action-script scripts/restart.sh --base-url http://localhost:8080
```
Hook написан для POSIX shell. В Windows выполняйте persistence-сценарий через WSL с доступным Docker; `python3` можно заменить на `python`, если так называется установленный интерпретатор.
Первый старт API применяет миграции и затем делает `exec python -m messenger`; HTTP-сервер — основной процесс контейнера. БД должна быть healthy до старта API. Файлы `001_initial.sql` и учёт применённых версий находятся в проекте/БД соответственно. Без повторного выполнения DDL можно перезапускать контейнер сколько угодно.
```sh
# Явно повторить миграции (данные не дублируются):
docker compose exec -T api python -m messenger.migrate
# Остановить стенд; данные сохраняются:
docker compose down
# Снова поднять на том же volume:
docker compose up -d --wait --wait-timeout 120
# Пересобрать после изменений:
docker compose up -d --build --wait --wait-timeout 120
# Только для НАМЕРЕННОГО удаления всех учебных данных:
docker compose down -v
```
В последнем случае следующий запуск создаст пустую БД, прежние пользователи и токены исчезнут. `.env`, secrets и файлы БД исключены из Git и ZIP. При проблеме запуска проверить `docker compose ps` и логи сервисов; не публиковать вывод конфигурации с вручную добавленными секретами.
### Собственные тесты в контейнере
Тесты создают синтетические данные, используйте учебный стенд.
```sh
docker compose cp student-tests api:/app/student-tests
docker compose exec -T api python -m unittest discover -s student-tests -v
```
Полная валидация OpenAPI на host:
```sh
python3 -m venv .venv
.venv/bin/python -m pip install -r requirements-dev.txt
make validate PYTHON=.venv/bin/python
```
### Конфигурация и инфраструктура
| Роль | Сервис / версия | Readiness | Постоянные данные | Сеть и credentials |
| --- | --- | --- | --- | --- |
| API | api; python:3.11.11-slim-bookworm; Flask/Waitress | /health/ready проверяет доступность таблиц БД | Нет локальных данных | Host 127.0.0.1:8080; DATABASE_URL_FILE — Compose secret |
| БД и сессии | db; postgres:16.6-bookworm | pg_isready | Именованный postgres_data, /var/lib/postgresql/data | Только внутренняя сеть Compose, порт БД на host не опубликован; POSTGRES_PASSWORD_FILE |
| Переменная | Реальное назначение |
| --- | --- |
| APP_HOST | Адрес bind API; по умолчанию 0.0.0.0 внутри контейнера |
| APP_PORT | Внутренний порт API, по умолчанию 8080; host-порт Compose остаётся 8080 |
| APP_ENV | Метка окружения стартового лога; debug не включает |
| SESSION_TTL_SECONDS | Срок новой сессии, по умолчанию 3600; для smoke/persistence оставить не менее 300 |
| DATABASE_URL_FILE | Файл строки подключения; Compose фиксирует /run/secrets/database_url |
| DATABASE_URL | Альтернатива для локального запуска без Docker; файл имеет приоритет |
| SESSION_STORE | Только postgres; иное значение отклоняется при старте |
| CACHE_URL_FILE | Сохранён из шаблона задания, на уровне 3 не используется |
Папка secrets создаётся с правами 0700. Файл пароля PostgreSQL имеет 0644, чтобы отдельный UID postgres мог прочитать индивидуально смонтированный Compose secret; на host доступ к нему закрывает родительская папка. Файл URL имеет 0600 и читается API. Для этой учебной Compose-конфигурации API работает от пользователя базового образа, не заявляется hardening уровня 4/7.
## Архитектура и перенос из первой работы
Путь запроса: клиент → Waitress → Flask HTTP-адаптер → Messenger / Authentication → Repository → PostgreSQL. Flask, Waitress, фабрика приложения, разделение HTTP / сценариев / хранилища сохранены. Контракт и публичные tests взяты именно из второй работы, без замены файлами lab1. Первая работа не изменялась.
| Компонент | Что изменилось относительно lab1 |
| --- | --- |
| domain.py | Сохранены общие проверки полей, строк, UUID и ошибки; NUL отклоняется как 400, поскольку PostgreSQL text его не хранит |
| api.py | Те же маршруты пользователей, чатов и истории; добавлены login/logout и WWW-Authenticate; X-User-Id больше не выбирает пользователя |
| service.py | Сохранены сценарии и валидация; регистрация теперь включает пароль, пагинация получает ограниченную выборку SQL |
| repository.py | Сохранена роль интерфейса Repository; порт расширен для credentials и сессий |
| postgres.py / database.py | MemoryRepository заменён SQL-адаптером с транзакциями и параметризованными запросами |
| security.py | Argon2id, разбор Basic, проверка Bearer, генерация токена |
| pagination.py | Сохранён формат подписанного keyset-курсора; ключ постоянен в БД, страницы выбираются через SQL LIMIT+1 |
| config.py / migrate.py | Загрузка конфигурации и versioned migration runner |
Схема, ключи, индексы и транзакционные границы описаны **до SQL-реализации** в [infra/DATABASE.md](infra/DATABASE.md). Данные пользователей, чатов, участников, сообщений и сессий живут в PostgreSQL. Память процесса не является источником истины. SQLite, Redis и внешние готовые серверы решения не используются.
Каждая запись завершается COMMIT до успешного HTTP-ответа. Создание чата и всех его участников атомарно. Ошибки приводят к rollback. Уникальность username обеспечивает UNIQUE, повтор даёт 409. Поля id — UUID; FK связывают пользователей, чаты, членство, отправителей сообщений. Индекс истории `(chat_id, created_at, id)` соответствует SQL keyset-пагинации. Соединение открывается на операцию и закрывается по её завершении; пул не добавлен для уровня 3. Таймаут подключения — 3 секунды, statement_timeout — 5 секунд, lock_timeout — 3 секунды.
Курсор связан с конкретным чатом или списком чатов пользователя. Ключ подписи генерируется один раз миграцией и сохраняется в app_settings. Он не меняется при рестарте API/БД. Обычный обход неизменной истории не пропускает и не повторяет записи. Время назначает PostgreSQL (clock_timestamp), сортировка — `(created_at, id)`. Между HTTP-страницами snapshot отсутствует: конкурентная запись, закоммиченная позже, с ключом до уже выданного курсора может не войти в текущий обход. Подтверждённая запись видна следующему новому чтению; кэша нет.
### Аутентификация
- POST `/api/v1/users` публичен и принимает username, display_name, password (12–128 Unicode code points).
- POST `/api/v1/auth/sessions` принимает Basic без тела. Пароль может содержать двоеточие и Unicode: деление выполняется только по первому `:`.
- Пароль хранится как Argon2id: память 65536 KiB, time_cost=3, parallelism=2, случайная соль. Поле password_hash никогда не входит в User.
- Успешный вход создаёт случайный opaque-токен из 32 случайных байт (256 бит). В БД сохраняется SHA-256 токена и expires_at. Быстрый SHA-256 используется для высокоэнтропийного токена, а не как хеш пароля.
- Остальные бизнес-endpoint требуют Bearer. X-User-Id игнорируется; Basic на бизнес-endpoint — 401.
- Expiry назначается временем БД один раз; проверяется при каждом запросе и не продлевается перезапуском или чтением. Истёкшая сессия остаётся строкой БД, но никогда не даёт доступ.
- Logout удаляет сессию; повторный запрос с прежним токеном получает 401. 401 содержит нужный WWW-Authenticate. Посторонний участник получает 404 для чужого чата.
Сессию проверяем в начале запроса. Уже начатая операция может завершиться одновременно с logout; отмена выполняющихся запросов не заявлена. HTTP/Basic допустимы только на локальном изолированном учебном стенде. Для удалённого доступа нужен TLS.
## Доказательства и фактические проверки
Дата: 16.11.2026, Москва. Среда проверки: Linux x86_64, Python 3.12.14, настоящий PostgreSQL 16.2 (локальные бинарники из pgserver 0.1.4, **не SQLite и не mock**). Версии приложения — requirements.txt. Это функциональные проверки без исследования производительности, искусственные CPU/RAM-лимиты и прогрев не задавались.
Docker CLI/daemon в среде подготовки отсутствует. Поэтому **сборка образов, Compose-стенд PostgreSQL 16.6 и scripts/restart.sh здесь не запускались**. Вместо этого публичный persistence-тест прошёл с отдельным локальным hook, который действительно перезапустил API и PostgreSQL 16.2 с тем же каталогом данных. Это проверка поведения приложения и БД, но не свидетельство испытания Docker. Для окончательного подтверждения контейнерного запуска выполнить команды первого раздела.
| Критерий / проверка | Команда / методика | Наблюдаемый результат | Доказательство |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
| Структура и контракт | make check / make validate | PASS | evidence/local-checks.txt |
| Минимум API lab2 | make test BASE_URL=http://127.0.0.1:18080 | Публичный smoke PASS | evidence/local-checks.txt |
| Пользователи, чаты, сообщения, действующие сессии после рестарта | make test-persistence с локальным реальным hook | Прежний токен, пользователь и сообщение сохранились | evidence/local-checks.txt |
| Рестарт обоих процессов, тот же каталог БД | scripts/check_local.py | Изменились PID API и pg_postmaster_start_time; данные не пересоздавались | evidence/local-restart.txt |
| Миграции с нуля и повторный запуск | migrate выполнен дважды при старте и повторно в own tests | Одна запись версии, без дублей/потери данных | evidence/local-checks.txt |
| Basic/Bearer, logout, X-User-Id | test_authentication_and_logout | OK | student-tests/test_api.py; evidence/local-checks.txt |
| TTL=2, неизменность expiry после нового экземпляра API | test_expiry_and_restart_app | Сначала 200, через expiry — 401 | evidence/local-checks.txt |
| Ошибки, неизвестные поля и чужой чат | test_strict_validation_and_private_chat | OK | evidence/local-checks.txt |
| Курсоры, размер страницы и продолжение после нового экземпляра API | test_pagination_survives_new_app | Порядок сохранён, чужой курсор — 400 | evidence/local-checks.txt |
| Атомарность отказа создания чата, хранение KDF и token digest | test_atomic_chat_and_migration_repeat | Число чатов не изменилось; Argon2id и digest в БД | evidence/local-checks.txt |
| Потеря БД | Настоящая остановка PostgreSQL | ready=503, live=200 | evidence/local-checks.txt |
| Compose и контейнерный hook | scripts/restart.sh / application.yml | Подготовлены; в этой среде не выполнены | compose.yaml; .github/workflows/application.yml |
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
Логи содержат путь временного окружения проверки и номер порта 18080; эти значения не нужно копировать для стандартного Compose-запуска на 8080. В логах нет токенов и credentials.
## Эксперименты и отказы
### Повтор проверки без Docker
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
При наличии локальных `initdb`, `pg_ctl`, `postgres`:
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
```sh
python3 -m venv .venv
.venv/bin/python -m pip install -r requirements.txt -r requirements-dev.txt
.venv/bin/python scripts/check_local.py --pg-bin /путь/к/postgresql/bin
```
## Ограничения и следующие шаги
Скрипт работает без root на Linux/macOS, создаёт временный изолированный кластер на 127.0.0.1:15432 и API на 127.0.0.1:18080, применяет миграции, запускает проверки и убирает свой временный кластер. Порты должны быть свободны. Временно применяется trust-аутентификация только этого localhost-кластера; существующие БД не затрагиваются. В проекте pgserver не является runtime-зависимостью; для сдачи используется обычный PostgreSQL Compose.
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
### Контейнерный restart hook
`scripts/restart.sh` сохраняет только имена/время старта/статус контейнеров в `evidence/restart-before.txt` и `evidence/restart-after.txt`. Затем останавливает API, перезапускает db, ждёт готовности PostgreSQL и запускает API. Не удаляет volume, не вызывает initdb, не создаёт тестовые данные. API повторяет versioned migrations без повторного применения версии. Публичный тест ожидает готовности и проверяет прежний токен. После распаковки ZIP выполнить `chmod +x scripts/restart.sh`, если архиватор не сохранил права.
+44
View File
@@ -0,0 +1,44 @@
services:
db:
image: postgres:16.6-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
api:
build: .
environment:
APP_HOST: ${APP_HOST:-0.0.0.0}
APP_PORT: ${APP_PORT:-8080}
APP_ENV: ${APP_ENV:-lab}
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
SESSION_STORE: postgres
DATABASE_URL_FILE: /run/secrets/database_url
ports:
- "127.0.0.1:8080:${APP_PORT:-8080}"
secrets:
- database_url
depends_on:
db:
condition: service_healthy
healthcheck:
test: ["CMD", "python", "-c", "import os, urllib.request; urllib.request.urlopen('http://127.0.0.1:'+os.getenv('APP_PORT','8080')+'/health/ready',timeout=3)"]
interval: 3s
timeout: 5s
retries: 20
volumes:
postgres_data:
secrets:
postgres_password:
file: ./secrets/postgres_password
database_url:
file: ./secrets/database_url
+34
View File
@@ -0,0 +1,34 @@
$ /workspace/scratch/a9cc7b7e4e4a/.venv/bin/python -m messenger.migrate
Migrations applied successfully (already applied versions skipped).
$ /workspace/scratch/a9cc7b7e4e4a/.venv/bin/python -m messenger.migrate
Migrations applied successfully (already applied versions skipped).
$ make check validate student-test PYTHON=/workspace/scratch/a9cc7b7e4e4a/.venv/bin/python
/workspace/scratch/a9cc7b7e4e4a/.venv/bin/python scripts/check_contract.py
PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.
/workspace/scratch/a9cc7b7e4e4a/.venv/bin/python scripts/validate_openapi.py
PASS: full OpenAPI 3.1 and JSON Schema validation; application NOT tested.
/workspace/scratch/a9cc7b7e4e4a/.venv/bin/python -m unittest discover -s student-tests -v
test_atomic_chat_and_migration_repeat (test_api.ApiTests.test_atomic_chat_and_migration_repeat) ... ok
test_authentication_and_logout (test_api.ApiTests.test_authentication_and_logout) ... ok
test_expiry_and_restart_app (test_api.ApiTests.test_expiry_and_restart_app) ... ok
test_pagination_survives_new_app (test_api.ApiTests.test_pagination_survives_new_app) ... ok
test_strict_validation_and_private_chat (test_api.ApiTests.test_strict_validation_and_private_chat) ... ok
----------------------------------------------------------------------
Ran 5 tests in 4.193s
OK
$ make test BASE_URL=http://127.0.0.1:18080 PYTHON=/workspace/scratch/a9cc7b7e4e4a/.venv/bin/python
/workspace/scratch/a9cc7b7e4e4a/.venv/bin/python tests/smoke.py --base-url "http://127.0.0.1:18080"
PASS: lab2 public API scenario; infrastructure and grading evidence remain separate.
$ make test-persistence ACTION_SCRIPT=/tmp/messenger-lab2-3_7rknxw/restart.sh BASE_URL=http://127.0.0.1:18080 PYTHON=/workspace/scratch/a9cc7b7e4e4a/.venv/bin/python
/workspace/scratch/a9cc7b7e4e4a/.venv/bin/python tests/resilience.py --mode persistence --action-script "/tmp/messenger-lab2-3_7rknxw/restart.sh" --base-url "http://127.0.0.1:18080"
Executing explicit persistence hook; hook output suppressed to avoid leaking secrets.
PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.
Real local PostgreSQL restart (not Docker)
API PID: 34 -> 1056
PostgreSQL start: 2026-11-15T21:29:56.296193+00:00 -> 2026-11-15T21:30:04.106927+00:00
Same data directory; no initdb/migrations/reseed in restart hook.
Verified database: PostgreSQL 16.2 on x86_64-pc-linux-gnu, compiled by gcc (GCC) 10.2.1 20210130 (Red Hat 10.2.1-11), 64-bit
PASS: DB outage gives ready=503, live=200
+4
View File
@@ -0,0 +1,4 @@
Real local PostgreSQL restart (not Docker)
API PID: 34 -> 1056
PostgreSQL start: 2026-11-15T21:29:56.296193+00:00 -> 2026-11-15T21:30:04.106927+00:00
Same data directory; no initdb/migrations/reseed in restart hook.
+2
View File
@@ -0,0 +1,2 @@
/mtusi2026lab2-db-1 2026-11-15T21:36:49.02822853Z running
/mtusi2026lab2-api-1 2026-11-15T21:36:51.309065877Z running
+2
View File
@@ -0,0 +1,2 @@
/mtusi2026lab2-db-1 2026-11-15T21:35:53.794161714Z running
/mtusi2026lab2-api-1 2026-11-15T21:35:56.415432352Z running
+19
View File
@@ -0,0 +1,19 @@
# Схема и транзакционные границы
Проект схемы составлен перед реализацией SQL-адаптера. PostgreSQL — единый источник истины, включая сессии.
| Таблица | Ключи и ограничения | Индексы и назначение |
| --- | --- | --- |
| users | UUID PK, username UNIQUE, NOT NULL для имени/хеша/времени | UNIQUE username для регистрации и входа |
| chats | UUID PK, title NOT NULL | (created_at, id) для списка |
| chat_members | (chat_id, user_id) PK, два FK, position для порядка участников | (user_id, chat_id) для доступных чатов |
| messages | UUID PK, chat_id FK, sender_id FK, составной FK на членство | (chat_id, created_at, id) для истории |
| sessions | token_hash PK, user_id FK, expires_at NOT NULL | expiry для возможной очистки |
| app_settings | name PK, value NOT NULL | постоянный случайный ключ подписи курсоров |
| schema_migrations | version PK | только учёт применённых миграций |
Каждый метод записи репозитория — одна транзакция с COMMIT до HTTP-ответа. Создание чата: проверить существование всех пользователей, вставить чат и всех участников, COMMIT; ошибка откатывает всё. Регистрация защищена UNIQUE, конфликт возвращает 409. Сообщение вставляется после проверки членства; FK также не позволяет записать отправителя вне чата. Создание/отзыв сессии — отдельные транзакции. Сессия проверяется на каждом защищённом запросе по времени БД; рестарт не меняет expiry.
Миграции нумеруются в migrations/*.sql. Runner выполняет новые файлы и запись версии в одной транзакции под advisory lock. Повторный запуск не выполняет уже учтённую версию. Пароли — Argon2id; в sessions лежит SHA-256 случайного 256-битного токена, а не пароль. SHA-256 здесь служит индексом высокоэнтропийного токена и не заменяет password KDF.
Пагинация SQL keyset, LIMIT + 1; offset не используется. Курсор сохраняет область ресурса и подписан постоянным ключом из БД, поэтому продолжение работает после рестарта. Часы PostgreSQL задают created_at. Между страницами нет snapshot; поздно закоммиченная конкурентная запись с ключом до курсора может не попасть в уже начатый обход. Для неизменной истории гарантируется отсутствие повторов и пропусков.
+1
View File
@@ -0,0 +1 @@
"""Messenger lab series."""
+15
View File
@@ -0,0 +1,15 @@
import logging
from waitress import serve
from .api import create_app
from .config import Settings
def main():
logging.basicConfig(level=logging.INFO)
settings = Settings.from_env()
logging.info('Starting messenger environment=%s', settings.environment)
serve(create_app(settings=settings), host=settings.host, port=settings.port, threads=4)
if __name__ == '__main__':
main()
+115
View File
@@ -0,0 +1,115 @@
"""HTTP adapter and composition root."""
import json
from uuid import uuid4
from flask import Flask, g, request, jsonify
from werkzeug.exceptions import HTTPException
from .domain import ApiError, invalid
from .postgres import PostgresRepository
from .database import Database
from .config import Settings
from .service import Messenger
def create_app(repository=None, settings=None):
app = Flask(__name__)
app.json.ensure_ascii = False
settings = settings or Settings.from_env()
repository = repository if repository is not None else PostgresRepository(Database(settings.database_url))
service = Messenger(repository, settings.session_ttl)
@app.before_request
def identify():
g.request_id = str(uuid4())
if request.path.startswith('/api/v1/') and not (
request.path in ('/api/v1/users', '/api/v1/auth/sessions') and request.method == 'POST'
):
g.user, g.token_hash = service.auth.bearer(request.headers.get('Authorization'))
@app.after_request
def request_id(response):
response.headers['X-Request-Id'] = g.request_id
return response
@app.errorhandler(Exception)
def error(exc):
if isinstance(exc, ApiError):
status, code, message = exc.status, exc.code, exc.message
elif isinstance(exc, HTTPException):
status = exc.code
code = {404: 'not_found', 413: 'payload_too_large', 415: 'unsupported_media_type'}.get(status, 'invalid_request')
message = exc.name
else:
app.logger.error('Unhandled error; request_id=%s', g.request_id)
status, code, message = 500, 'internal_error', 'Internal server error'
response = jsonify(error={'code': code, 'message': message, 'request_id': g.request_id})
response.status_code = status
if status == 401:
response.headers['WWW-Authenticate'] = (
'Basic realm="messenger", charset="UTF-8"'
if request.path == '/api/v1/auth/sessions' and request.method == 'POST'
else 'Bearer realm="messenger"')
return response
def body():
if request.mimetype != 'application/json':
raise ApiError(415, 'unsupported_media_type', 'Use application/json')
try:
def reject_constant(value):
raise ValueError(value)
return json.loads(request.get_data().decode('utf-8'), parse_constant=reject_constant)
except (ValueError, UnicodeError):
invalid('Malformed UTF-8 JSON')
def paging():
for key in ('limit', 'cursor'):
if len(request.args.getlist(key)) > 1:
invalid('Duplicate query parameter')
return request.args.get('limit', '50'), request.args.get('cursor')
@app.get('/health/live')
def health():
return jsonify(status='ok')
@app.get('/health/ready')
def ready():
repository.ready()
return jsonify(status='ok')
@app.post('/api/v1/auth/sessions')
def login():
# Session creation accepts no request body.
if request.get_data():
invalid('Session creation does not accept a body')
return jsonify(service.auth.login(request.headers.get('Authorization'))), 201
@app.delete('/api/v1/auth/sessions/current')
def logout():
repository.revoke_session(g.token_hash)
return '', 204
@app.post('/api/v1/users')
def register():
return jsonify(service.register(body())), 201
@app.get('/api/v1/users/me')
def me():
return jsonify(g.user)
@app.route('/api/v1/chats', methods=['GET', 'POST'])
def chats():
if request.method == 'POST':
return jsonify(service.create_chat(g.user['id'], body())), 201
return jsonify(service.chats(g.user['id'], *paging()))
@app.get('/api/v1/chats/<chat_id>')
def chat(chat_id):
return jsonify(service.chat(g.user['id'], chat_id))
@app.route('/api/v1/chats/<chat_id>/messages', methods=['GET', 'POST'])
def messages(chat_id):
if request.method == 'POST':
service.chat(g.user['id'], chat_id)
return jsonify(service.send(g.user['id'], chat_id, body())), 201
return jsonify(service.history(g.user['id'], chat_id, *paging()))
return app
+28
View File
@@ -0,0 +1,28 @@
"""Configuration is loaded only at process startup; secrets are never logged."""
import os
from dataclasses import dataclass
from pathlib import Path
@dataclass(frozen=True)
class Settings:
database_url: str
host: str = '0.0.0.0'
port: int = 8080
environment: str = 'lab'
session_ttl: int = 3600
@classmethod
def from_env(cls):
source = os.getenv('DATABASE_URL_FILE')
url = Path(source).read_text().strip() if source else os.getenv('DATABASE_URL', '')
if not url:
raise ValueError('Set DATABASE_URL_FILE or DATABASE_URL')
if os.getenv('SESSION_STORE', 'postgres') != 'postgres':
raise ValueError('This lab uses SESSION_STORE=postgres')
port = int(os.getenv('APP_PORT', '8080'))
ttl = int(os.getenv('SESSION_TTL_SECONDS', '3600'))
if not 1 <= port <= 65535 or ttl <= 0:
raise ValueError('Invalid APP_PORT or SESSION_TTL_SECONDS')
return cls(url, os.getenv('APP_HOST', '0.0.0.0'), port,
os.getenv('APP_ENV', 'lab'), ttl)
+20
View File
@@ -0,0 +1,20 @@
"""Short-lived database connections, one transaction per operation."""
from contextlib import contextmanager
import psycopg
from psycopg.rows import dict_row
from .domain import ApiError
class Database:
def __init__(self, url):
self.url = url
@contextmanager
def transaction(self):
try:
with psycopg.connect(self.url, row_factory=dict_row, connect_timeout=3,
options='-c statement_timeout=5000 -c lock_timeout=3000 -c timezone=UTC') as conn:
yield conn
except (psycopg.OperationalError, psycopg.InterfaceError,
psycopg.errors.QueryCanceled, psycopg.errors.LockNotAvailable):
raise ApiError(503, 'unavailable', 'Database temporarily unavailable') from None
+33
View File
@@ -0,0 +1,33 @@
"""Framework-independent validation and application errors."""
import re
from uuid import UUID
class ApiError(Exception):
def __init__(self, status, code, message):
self.status, self.code, self.message = status, code, message
def invalid(message='Invalid request'):
raise ApiError(400, 'invalid_request', message)
def uuid_value(value):
if not isinstance(value, str) or not re.fullmatch(
r'[0-9a-fA-F]{8}(?:-[0-9a-fA-F]{4}){3}-[0-9a-fA-F]{12}', value
):
invalid('Invalid UUID')
return str(UUID(value))
def fields(body, names):
if not isinstance(body, dict) or set(body) != set(names):
invalid('Required fields are missing or unknown fields supplied')
def string(value, maximum):
if (not isinstance(value, str) or not value.strip()
or len(value) > maximum or "\x00" in value
or any(0xD800 <= ord(c) <= 0xDFFF for c in value)):
invalid('Invalid string')
return value
+24
View File
@@ -0,0 +1,24 @@
"""Versioned, transactional migrations; safe to run again."""
from pathlib import Path
import secrets
from .config import Settings
from .database import Database
def migrate(database):
directory = Path(__file__).resolve().parents[1] / 'migrations'
with database.transaction() as conn:
conn.execute('SELECT pg_advisory_xact_lock(20260201)')
conn.execute('CREATE TABLE IF NOT EXISTS schema_migrations (version text PRIMARY KEY)')
versions = {r['version'] for r in conn.execute('SELECT version FROM schema_migrations')}
for path in sorted(directory.glob('*.sql')):
if path.name not in versions:
conn.execute(path.read_text(encoding='utf-8'))
conn.execute('INSERT INTO schema_migrations(version) VALUES (%s)', (path.name,))
conn.execute("INSERT INTO app_settings(name,value) VALUES ('cursor_key',%s) ON CONFLICT DO NOTHING",
(secrets.token_hex(32),))
if __name__ == '__main__':
migrate(Database(Settings.from_env().database_url))
print('Migrations applied successfully (already applied versions skipped).')
+43
View File
@@ -0,0 +1,43 @@
"""Resource-scoped signed cursors; SQL fetches only limit+1 rows."""
import base64
import hashlib
import hmac
import json
import re
from datetime import datetime
from .domain import invalid, uuid_value
class Pagination:
def __init__(self, key):
self._key = key
def decode(self, scope, limit, cursor):
if not re.fullmatch(r'[0-9]{1,3}', limit) or not 1 <= int(limit) <= 100:
invalid('Limit must be between 1 and 100')
after = None
if cursor is not None:
try:
if len(cursor) > 2048:
raise ValueError()
raw = base64.b64decode(cursor, altchars=b'-_', validate=True)
payload, signature = raw[:-32], raw[-32:]
if not hmac.compare_digest(signature, hmac.digest(self._key, payload, hashlib.sha256)):
raise ValueError()
saved_scope, timestamp, identifier = json.loads(payload)
if saved_scope != scope or not isinstance(timestamp, str):
raise ValueError()
datetime.fromisoformat(timestamp.replace('Z', '+00:00'))
after = (timestamp, uuid_value(identifier))
except (ValueError, TypeError, UnicodeError):
invalid('Invalid cursor for this resource')
return int(limit), after
def page(self, rows, scope, limit):
items = rows[:limit]
next_cursor = None
if len(rows) > limit:
last = items[-1]
payload = json.dumps([scope, last['created_at'], last['id']], separators=(',', ':')).encode()
next_cursor = base64.urlsafe_b64encode(payload + hmac.digest(self._key, payload, hashlib.sha256)).decode()
return {'items': items, 'next_cursor': next_cursor}
+133
View File
@@ -0,0 +1,133 @@
"""PostgreSQL repository: all SQL values are bound parameters."""
from datetime import datetime, timezone
from uuid import UUID, uuid4
import psycopg
from .domain import ApiError, invalid
def serialize(row):
if row is None:
return None
result = {}
for key, value in row.items():
if isinstance(value, UUID):
value = str(value)
elif isinstance(value, datetime):
value = value.astimezone(timezone.utc).isoformat(timespec='microseconds').replace('+00:00', 'Z')
elif isinstance(value, list):
value = [str(item) if isinstance(item, UUID) else item for item in value]
result[key] = value
return result
USER_COLUMNS = 'id, username, display_name, created_at'
# Members retain the request order, with no password/session fields in public objects.
CHAT_COLUMNS = '''c.id, c.title, c.created_at,
ARRAY(SELECT m.user_id FROM chat_members m WHERE m.chat_id=c.id ORDER BY m.position) AS member_ids'''
class PostgresRepository:
def __init__(self, database):
self.db = database
def ready(self):
with self.db.transaction() as conn:
conn.execute('SELECT id FROM users LIMIT 0')
conn.execute('SELECT token_hash FROM sessions LIMIT 0')
def cursor_key(self):
with self.db.transaction() as conn:
row = conn.execute("SELECT value FROM app_settings WHERE name='cursor_key'").fetchone()
if row is None:
raise ApiError(503, 'unavailable', 'Database is not initialized')
return bytes.fromhex(row['value'])
def create_user(self, username, display_name, password_hash):
try:
with self.db.transaction() as conn:
row = conn.execute('INSERT INTO users(id,username,display_name,password_hash) VALUES (%s,%s,%s,%s) RETURNING ' + USER_COLUMNS,
(uuid4(), username, display_name, password_hash)).fetchone()
return serialize(row)
except psycopg.errors.UniqueViolation:
raise ApiError(409, 'conflict', 'Username already exists') from None
def credentials(self, username):
with self.db.transaction() as conn:
return serialize(conn.execute('SELECT ' + USER_COLUMNS + ', password_hash FROM users WHERE username=%s',
(username,)).fetchone())
def create_session(self, user_id, token_hash, ttl):
with self.db.transaction() as conn:
row = 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, user_id, ttl)).fetchone()
return serialize(row)['expires_at']
def session_user(self, token_hash):
with self.db.transaction() as conn:
row = conn.execute('''SELECT u.id,u.username,u.display_name,u.created_at FROM users u
JOIN sessions s ON s.user_id=u.id
WHERE s.token_hash=%s AND s.expires_at>clock_timestamp()''', (token_hash,)).fetchone()
if row is None:
raise ApiError(401, 'unauthorized', 'Valid Bearer session required')
return serialize(row)
def revoke_session(self, token_hash):
with self.db.transaction() as conn:
conn.execute('DELETE FROM sessions WHERE token_hash=%s', (token_hash,))
@staticmethod
def _access(conn, actor, chat_id):
if conn.execute('SELECT 1 FROM chat_members WHERE chat_id=%s AND user_id=%s', (chat_id, actor)).fetchone() is None:
raise ApiError(404, 'not_found', 'Chat not found')
def create_chat(self, actor, title, members):
with self.db.transaction() as conn:
count = conn.execute('SELECT count(*) AS n FROM users WHERE id=ANY(%s::uuid[])', (members,)).fetchone()['n']
if actor not in members or count != len(members):
invalid('Members must exist and include the current user')
identifier = uuid4()
conn.execute('INSERT INTO chats(id,title) VALUES (%s,%s)', (identifier, title))
with conn.cursor() as cur:
cur.executemany('INSERT INTO chat_members(chat_id,user_id,position) VALUES (%s,%s,%s)',
[(identifier, member, i) for i, member in enumerate(members)])
row = conn.execute('SELECT ' + CHAT_COLUMNS + ' FROM chats c WHERE c.id=%s', (identifier,)).fetchone()
return serialize(row)
def chat(self, actor, chat_id):
with self.db.transaction() as conn:
self._access(conn, actor, chat_id)
row = conn.execute('SELECT ' + CHAT_COLUMNS + ' FROM chats c WHERE c.id=%s', (chat_id,)).fetchone()
return serialize(row)
def chats(self, actor, limit, after):
params = [actor]
boundary = ''
if after is not None:
boundary = ' AND (c.created_at,c.id)>(%s::timestamptz,%s::uuid)'
params.extend(after)
params.append(limit)
with self.db.transaction() as conn:
rows = conn.execute('SELECT ' + CHAT_COLUMNS + ''' FROM chats c JOIN chat_members own
ON own.chat_id=c.id WHERE own.user_id=%s''' + boundary +
' ORDER BY c.created_at,c.id LIMIT %s', params).fetchall()
return [serialize(r) for r in rows]
def create_message(self, actor, chat_id, text):
with self.db.transaction() as conn:
self._access(conn, actor, chat_id)
row = conn.execute('INSERT INTO messages(id,chat_id,sender_id,text) VALUES (%s,%s,%s,%s) RETURNING *',
(uuid4(), chat_id, actor, text)).fetchone()
return serialize(row)
def messages(self, actor, chat_id, limit, after):
params = [chat_id]
boundary = ''
if after is not None:
boundary = ' AND (created_at,id)>(%s::timestamptz,%s::uuid)'
params.extend(after)
params.append(limit)
with self.db.transaction() as conn:
self._access(conn, actor, chat_id)
rows = conn.execute('SELECT * FROM messages WHERE chat_id=%s' + boundary +
' ORDER BY created_at,id LIMIT %s', params).fetchall()
return [serialize(r) for r in rows]
+17
View File
@@ -0,0 +1,17 @@
"""Storage port. Concrete PostgreSQL adapter is wired in api.create_app."""
from typing import Protocol
class Repository(Protocol):
def ready(self): ...
def cursor_key(self): ...
def create_user(self, username, display_name, password_hash): ...
def credentials(self, username): ...
def create_session(self, user_id, token_hash, ttl): ...
def session_user(self, token_hash): ...
def revoke_session(self, token_hash): ...
def create_chat(self, actor, title, members): ...
def chat(self, actor, chat_id): ...
def chats(self, actor, limit, after): ...
def create_message(self, actor, chat_id, text): ...
def messages(self, actor, chat_id, limit, after): ...
+60
View File
@@ -0,0 +1,60 @@
"""Password KDF and HTTP credential parsing, without framework dependencies."""
import base64
import binascii
import hashlib
import re
import secrets
from argon2 import PasswordHasher, Type
from argon2.exceptions import VerificationError, InvalidHashError
from .domain import ApiError, invalid, string
class Authentication:
def __init__(self, repository, ttl):
self.repository = repository
self.ttl = ttl
self.hasher = PasswordHasher(time_cost=3, memory_cost=65536, parallelism=2,
hash_len=32, salt_len=16, type=Type.ID)
self._dummy = self.hasher.hash(secrets.token_urlsafe(32))
@staticmethod
def password(value):
string(value, 128)
if len(value) < 12:
invalid('Password must contain 12 to 128 Unicode characters')
return value
@staticmethod
def digest(token):
return hashlib.sha256(token.encode('ascii')).hexdigest()
def bearer(self, header):
parts = (header or '').split()
if len(parts) != 2 or parts[0].lower() != 'bearer' or not re.fullmatch(r'[A-Za-z0-9_-]{43}', parts[1]):
raise ApiError(401, 'unauthorized', 'Valid Bearer session required')
token_hash = self.digest(parts[1])
return self.repository.session_user(token_hash), token_hash
def login(self, header):
def denied():
raise ApiError(401, 'unauthorized', 'Invalid credentials')
try:
parts = (header or '').split()
if len(parts) != 2 or parts[0].lower() != 'basic':
denied()
username, password = base64.b64decode(parts[1], validate=True).decode('utf-8').split(':', 1)
if not re.fullmatch(r'[a-z0-9_]{3,32}', username) or not 12 <= len(password) <= 128:
denied()
except (ValueError, UnicodeError, binascii.Error):
denied()
row = self.repository.credentials(username)
try:
self.hasher.verify(row['password_hash'] if row else self._dummy, password)
except (VerificationError, InvalidHashError):
denied()
if row is None:
denied()
user = {key: value for key, value in row.items() if key != 'password_hash'}
token = secrets.token_urlsafe(32)
expires_at = self.repository.create_session(user['id'], self.digest(token), self.ttl)
return {'token': token, 'token_type': 'Bearer', 'expires_at': expires_at, 'user': user}
+53
View File
@@ -0,0 +1,53 @@
"""Use cases; independent of Flask and the concrete storage adapter."""
import re
from .domain import fields, string, uuid_value, invalid, ApiError
from .repository import Repository
from .pagination import Pagination
from .security import Authentication
class Messenger:
def __init__(self, repository: Repository, session_ttl=3600):
self.repository = repository
self.pagination = Pagination(repository.cursor_key())
self.auth = Authentication(repository, session_ttl)
def register(self, body):
fields(body, ('username', 'display_name', 'password'))
username = string(body['username'], 32)
if not re.fullmatch(r'[a-z0-9_]{3,32}', username):
invalid('Invalid username')
display_name = string(body['display_name'], 100)
password = self.auth.password(body['password'])
return self.repository.create_user(username, display_name, self.auth.hasher.hash(password))
def create_chat(self, actor, body):
fields(body, ('title', 'member_ids'))
title = string(body['title'], 100)
members = body['member_ids']
if not isinstance(members, list) or not 1 <= len(members) <= 100:
invalid('Invalid member list')
members = [uuid_value(m) for m in members]
if len(set(members)) != len(members):
invalid('Duplicate members')
return self.repository.create_chat(actor, title, members)
def chat(self, actor, chat_id):
return self.repository.chat(actor, uuid_value(chat_id))
def send(self, actor, chat_id, body):
self.chat(actor, chat_id)
fields(body, ('text',))
return self.repository.create_message(actor, uuid_value(chat_id), string(body['text'], 4000))
def chats(self, actor, limit, cursor):
scope = 'chats:' + actor
limit, after = self.pagination.decode(scope, limit, cursor)
return self.pagination.page(self.repository.chats(actor, limit + 1, after), scope, limit)
def history(self, actor, chat_id, limit, cursor):
chat_id = uuid_value(chat_id)
self.repository.chat(actor, chat_id)
scope = 'messages:' + chat_id
limit, after = self.pagination.decode(scope, limit, cursor)
return self.pagination.page(self.repository.messages(actor, chat_id, limit + 1, after), scope, limit)
+37
View File
@@ -0,0 +1,37 @@
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 INDEX chats_order_idx ON chats(created_at, id);
CREATE TABLE chat_members (
chat_id uuid NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
user_id uuid NOT NULL REFERENCES users(id),
position integer NOT NULL CHECK (position >= 0),
PRIMARY KEY(chat_id, user_id),
UNIQUE(chat_id, position)
);
CREATE INDEX chat_members_user_idx ON chat_members(user_id, chat_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 chat_members(chat_id, user_id)
);
CREATE INDEX messages_history_idx ON messages(chat_id, created_at, id);
CREATE TABLE sessions (
token_hash text PRIMARY KEY CHECK (char_length(token_hash) = 64),
user_id uuid NOT NULL REFERENCES users(id),
expires_at timestamptz NOT NULL
);
CREATE INDEX sessions_expiry_idx ON sessions(expires_at);
CREATE TABLE app_settings (name text PRIMARY KEY, value text NOT NULL);
+13
View File
@@ -0,0 +1,13 @@
Flask==3.1.0
waitress==3.0.2
Werkzeug==3.1.3
Jinja2==3.1.6
MarkupSafe==3.0.3
itsdangerous==2.2.0
click==8.1.8
blinker==1.9.0
psycopg[binary]==3.2.6
argon2-cffi==23.1.0
argon2-cffi-bindings==21.2.0
cffi==1.17.1
pycparser==2.22
+138
View File
@@ -0,0 +1,138 @@
"""Optional Linux/macOS verification with real local PostgreSQL binaries.
Usage: python scripts/check_local.py --pg-bin /path/to/postgresql/bin
Creates a private temporary cluster; never touches an existing database.
The normal delivery/deployment path remains Docker Compose.
"""
import argparse
import json
import os
from pathlib import Path
import shlex
import signal
import subprocess
import sys
import tempfile
import time
from urllib.request import urlopen
ROOT = Path(__file__).resolve().parents[1]
def pg(state, *args):
return subprocess.run([str(Path(state['bin']) / 'pg_ctl'), '-D', state['data'], *args],
check=True, stdout=subprocess.DEVNULL)
def start_api(state, env):
with open(Path(state['data']).parent / 'api.log', 'a') as log:
process = subprocess.Popen([sys.executable, '-m', 'messenger'], cwd=ROOT,
env=env, stdout=log, stderr=log, start_new_session=True)
state['api_pid'] = process.pid
return process
def ready():
for _ in range(100):
try:
with urlopen('http://127.0.0.1:18080/health/ready', timeout=1) as r:
if r.status == 200:
return
except OSError:
time.sleep(0.1)
raise RuntimeError('Local API did not become ready')
def restart(state_path):
import psycopg
state = json.loads(state_path.read_text())
with psycopg.connect(os.environ['DATABASE_URL']) as conn:
before = conn.execute('SELECT pg_postmaster_start_time()').fetchone()[0]
old_pid = state['api_pid']
os.kill(old_pid, signal.SIGTERM)
pg(state, '-m', 'fast', '-w', 'stop')
pg(state, '-l', str(state_path.parent / 'postgres.log'), '-w', 'start')
start_api(state, dict(os.environ))
state_path.write_text(json.dumps(state))
ready()
with psycopg.connect(os.environ['DATABASE_URL']) as conn:
after = conn.execute('SELECT pg_postmaster_start_time()').fetchone()[0]
assert before != after and old_pid != state['api_pid']
(ROOT / 'evidence/local-restart.txt').write_text(
'Real local PostgreSQL restart (not Docker)\n'
'API PID: %s -> %s\nPostgreSQL start: %s -> %s\n'
'Same data directory; no initdb/migrations/reseed in restart hook.\n' %
(old_pid, state['api_pid'], before.isoformat(), after.isoformat()))
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--pg-bin')
parser.add_argument('--restart', type=Path)
args = parser.parse_args()
if args.restart:
restart(args.restart)
return
if not args.pg_bin:
parser.error('--pg-bin is required')
binary = Path(args.pg_bin).resolve()
with tempfile.TemporaryDirectory(prefix='messenger-lab2-') as tmp:
temp = Path(tmp)
state_path = temp / 'state.json'
state = {'bin': str(binary), 'data': str(temp / 'data')}
env = dict(os.environ, DATABASE_URL='postgresql://127.0.0.1:15432/postgres',
APP_PORT='18080', APP_HOST='127.0.0.1', SESSION_TTL_SECONDS='3600')
env.pop('DATABASE_URL_FILE', None)
env['SESSION_STORE'] = 'postgres'
subprocess.run([str(binary / 'initdb'), '-D', state['data'], '-A', 'trust',
'--no-locale', '-E', 'UTF8'], check=True, stdout=subprocess.DEVNULL)
with (Path(state['data']) / 'postgresql.conf').open('a') as f:
f.write("\nport=15432\nlisten_addresses='127.0.0.1'\nunix_socket_directories=''\ntimezone='UTC'\n")
initial_process = None
try:
pg(state, '-l', str(temp / 'postgres.log'), '-w', 'start')
def run(command):
print('$ ' + ' '.join(command), flush=True)
subprocess.run(command, env=env, cwd=ROOT, check=True)
run([sys.executable, '-m', 'messenger.migrate'])
run([sys.executable, '-m', 'messenger.migrate'])
initial_process = start_api(state, env)
state_path.write_text(json.dumps(state))
ready()
run(['make', 'check', 'validate', 'student-test', 'PYTHON=' + sys.executable])
run(['make', 'test', 'BASE_URL=http://127.0.0.1:18080', 'PYTHON=' + sys.executable])
hook = temp / 'restart.sh'
hook.write_text('#!/bin/sh\nexec ' + shlex.join([sys.executable, str(Path(__file__).resolve()),
'--restart', str(state_path)]) + '\n')
hook.chmod(0o700)
run(['make', 'test-persistence', 'ACTION_SCRIPT=' + str(hook),
'BASE_URL=http://127.0.0.1:18080', 'PYTHON=' + sys.executable])
print((ROOT / 'evidence/local-restart.txt').read_text(), flush=True)
import psycopg
with psycopg.connect(env['DATABASE_URL']) as conn:
print('Verified database: ' + conn.execute('SELECT version()').fetchone()[0], flush=True)
# A real dependency outage must not leave the application ready.
pg(state, '-m', 'fast', '-w', 'stop')
from urllib.error import HTTPError
try:
urlopen('http://127.0.0.1:18080/health/ready', timeout=8)
raise AssertionError('Readiness must fail without PostgreSQL')
except HTTPError as error:
assert error.code == 503
assert urlopen('http://127.0.0.1:18080/health/live').status == 200
print('PASS: DB outage gives ready=503, live=200', flush=True)
finally:
if state_path.exists():
current = json.loads(state_path.read_text())
try:
os.kill(current['api_pid'], signal.SIGTERM)
except ProcessLookupError:
pass
if initial_process is not None:
initial_process.wait(timeout=10)
subprocess.run([str(binary / 'pg_ctl'), '-D', state['data'], '-m', 'fast', '-w', 'stop'],
stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
if __name__ == '__main__':
main()
+24
View File
@@ -0,0 +1,24 @@
"""Create local secrets once. Never overwrite existing credentials."""
from pathlib import Path
import secrets
import shutil
root = Path(__file__).resolve().parents[1]
directory = root / 'secrets'
directory.mkdir(mode=0o700, exist_ok=True)
password_file = directory / 'postgres_password'
url_file = directory / 'database_url'
if password_file.exists() != url_file.exists():
raise SystemExit('Incomplete secrets: restore the missing file; do not regenerate credentials for an existing volume.')
if not password_file.exists():
password = secrets.token_hex(32)
for path, value in [(password_file, password),
(url_file, 'postgresql://messenger:' + password + '@db:5432/messenger')]:
with path.open('x', encoding='utf-8') as f:
f.write(value + '\n')
# Compose mounts secret files individually; PostgreSQL runs as a distinct UID.
# The enclosing host directory is 0700, while this mounted file must be readable.
path.chmod(0o644 if path == password_file else 0o600)
if not (root / '.env').exists():
shutil.copyfile(root / '.env.example', root / '.env')
print('Local configuration ready; existing credentials preserved.')
+24
View File
@@ -0,0 +1,24 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
# Stop API first; restart the only store, keeping its named volume.
mkdir -p evidence
snapshot() {
for service in db api; do
id=$(docker compose ps -q "$service")
docker inspect --format '{{.Name}} {{.State.StartedAt}} {{.State.Status}}' "$id"
done
}
snapshot > evidence/restart-before.txt
docker compose stop -t 10 api
docker compose restart -t 10 db
# Wait for DB before the API applies idempotent migrations.
i=0
until docker compose exec -T db pg_isready -U messenger -d messenger >/dev/null 2>&1; do
i=$((i + 1))
[ "$i" -lt 30 ] || exit 1
sleep 1
done
docker compose start api
snapshot > evidence/restart-after.txt
# Public resilience.py waits for readiness and tests the OLD token.
+4
View File
@@ -0,0 +1,4 @@
#!/bin/sh
set -eu
python -m messenger.migrate
exec python -m messenger
+123
View File
@@ -0,0 +1,123 @@
"""Integration tests. DATABASE_URL[_FILE] must point to a disposable PostgreSQL DB."""
import base64
import time
import unittest
from dataclasses import replace
from uuid import uuid4
from messenger.api import create_app
from messenger.config import Settings
from messenger.database import Database
from messenger.migrate import migrate
class ApiTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.settings = Settings.from_env()
cls.db = Database(cls.settings.database_url)
migrate(cls.db)
cls.app = create_app(settings=cls.settings)
def setUp(self):
self.c = self.app.test_client()
self.password = 'Учебный:пароль-12345'
self.name = 'u_' + uuid4().hex[:16]
self.registration = {'username': self.name, 'display_name': 'Имя 👋', 'password': self.password}
r = self.c.post('/api/v1/users', json=self.registration)
self.assertEqual(r.status_code, 201)
self.user = r.json
self.basic = {'Authorization': 'Basic ' + base64.b64encode((self.name + ':' + self.password).encode()).decode()}
r = self.c.post('/api/v1/auth/sessions', headers=self.basic)
self.assertEqual(r.status_code, 201)
self.session = r.json
self.headers = {'Authorization': 'Bearer ' + self.session['token']}
self.chat = self.c.post('/api/v1/chats', headers=self.headers, json={
'title': 'Учебный чат', 'member_ids': [self.user['id']]}).json
self.path = '/api/v1/chats/' + self.chat['id'] + '/messages'
def error(self, response, status):
self.assertEqual(response.status_code, status)
self.assertEqual(response.json['error']['request_id'], response.headers['X-Request-Id'])
def test_authentication_and_logout(self):
for headers in [{}, self.basic, {'X-User-Id': self.user['id']}, {'Authorization': 'Bearer bad'}]:
r = self.c.get('/api/v1/users/me', headers=headers)
self.error(r, 401)
self.assertEqual(r.headers['WWW-Authenticate'], 'Bearer realm="messenger"')
for auth in ['Basic bad', 'Bearer bad', 'Basic ' + base64.b64encode((self.name + ':wrong-password').encode()).decode()]:
r = self.c.post('/api/v1/auth/sessions', headers={'Authorization': auth})
self.error(r, 401)
self.assertEqual(r.headers['WWW-Authenticate'], 'Basic realm="messenger", charset="UTF-8"')
r = self.c.get('/api/v1/users/me', headers=dict(self.headers, **{'X-User-Id': str(uuid4())}))
self.assertEqual(r.json, self.user)
self.error(self.c.post('/api/v1/auth/sessions', headers=self.basic, json={}), 400)
r = self.c.delete('/api/v1/auth/sessions/current', headers=self.headers)
self.assertEqual((r.status_code, r.data), (204, b''))
self.error(self.c.get('/api/v1/users/me', headers=self.headers), 401)
self.error(self.c.delete('/api/v1/auth/sessions/current', headers=self.headers), 401)
def test_expiry_and_restart_app(self):
short = create_app(settings=replace(self.settings, session_ttl=2)).test_client()
r = short.post('/api/v1/auth/sessions', headers=self.basic)
self.assertEqual(r.status_code, 201)
headers = {'Authorization': 'Bearer ' + r.json['token']}
self.assertEqual(short.get('/api/v1/users/me', headers=headers).status_code, 200)
# New app instance must respect the stored original expiry, not renew it.
restarted = create_app(settings=replace(self.settings, session_ttl=3600)).test_client()
self.assertEqual(restarted.get('/api/v1/users/me', headers=headers).status_code, 200)
time.sleep(2.1)
self.error(restarted.get('/api/v1/users/me', headers=headers), 401)
def test_strict_validation_and_private_chat(self):
self.error(self.c.post('/api/v1/users', data='{', content_type='application/json'), 400)
self.error(self.c.post('/api/v1/users', json=self.registration), 409)
for patch in [{'password': 'short'}, {'password': 42}, {'display_name': ' '}, {'extra': 1}]:
self.error(self.c.post('/api/v1/users', json=dict(self.registration, **patch)), 400)
self.error(self.c.post(self.path, headers=self.headers, json={'text': ' \n'}), 400)
self.error(self.c.post(self.path, headers=self.headers, json={'text': 'x', 'sender_id': self.user['id']}), 400)
self.error(self.c.get('/api/v1/chats/' + str(uuid4()), headers=self.headers), 404)
outsider = 'u_' + uuid4().hex[:16]
self.c.post('/api/v1/users', json=dict(self.registration, username=outsider))
basic = {'Authorization': 'Basic ' + base64.b64encode((outsider + ':' + self.password).encode()).decode()}
token = self.c.post('/api/v1/auth/sessions', headers=basic).json['token']
self.error(self.c.get(self.path, headers={'Authorization': 'Bearer ' + token}), 404)
def test_pagination_survives_new_app(self):
expected = [self.c.post(self.path, headers=self.headers, json={'text': str(i)}).json for i in range(5)]
first = self.c.get(self.path + '?limit=2', headers=self.headers).json
cursor = first['next_cursor']
new_client = create_app(settings=self.settings).test_client()
second = new_client.get(self.path, query_string={'limit': 1, 'cursor': cursor}, headers=self.headers).json
third = new_client.get(self.path, query_string={'limit': 100, 'cursor': second['next_cursor']}, headers=self.headers).json
self.assertEqual(first['items'] + second['items'] + third['items'], expected)
self.assertIsNone(third['next_cursor'])
self.error(self.c.get('/api/v1/chats', query_string={'cursor': cursor}, headers=self.headers), 400)
other = self.c.post('/api/v1/chats', headers=self.headers, json={'title': 'Other', 'member_ids': [self.user['id']]}).json
self.error(self.c.get('/api/v1/chats/' + other['id'] + '/messages', query_string={'cursor': cursor}, headers=self.headers), 400)
for limit in ['0', '101', '1.5', 'true']:
self.error(self.c.get(self.path, query_string={'limit': limit}, headers=self.headers), 400)
self.error(self.c.get(self.path, query_string={'cursor': 'invalid'}, headers=self.headers), 400)
page = self.c.get('/api/v1/chats?limit=1', headers=self.headers).json
last = self.c.get('/api/v1/chats', query_string={'cursor': page['next_cursor']}, headers=self.headers).json
self.assertEqual(len(page['items'] + last['items']), 2)
def test_atomic_chat_and_migration_repeat(self):
with self.db.transaction() as conn:
before = conn.execute('SELECT count(*) AS n FROM chats').fetchone()['n']
for members in [[self.user['id'], str(uuid4())], [self.user['id'], self.user['id']], []]:
self.error(self.c.post('/api/v1/chats', headers=self.headers,
json={'title': 'Invalid', 'member_ids': members}), 400)
migrate(self.db)
migrate(self.db)
with self.db.transaction() as conn:
self.assertEqual(conn.execute('SELECT count(*) AS n FROM chats').fetchone()['n'], before)
self.assertEqual(conn.execute('SELECT count(*) AS n FROM schema_migrations').fetchone()['n'], 1)
row = conn.execute('SELECT password_hash FROM users WHERE id=%s', (self.user['id'],)).fetchone()
self.assertTrue(row['password_hash'].startswith('$argon2id$'))
hashes = [r['token_hash'] for r in conn.execute('SELECT token_hash FROM sessions WHERE user_id=%s', (self.user['id'],))]
self.assertNotIn(self.session['token'], hashes)
self.assertEqual(self.c.get('/api/v1/users/me', headers=self.headers).json, self.user)
if __name__ == '__main__':
unittest.main()