Author SHA1 Message Date
Otto 44b6ec1052 Lab 2: PostgreSQL storage and Redis sessions
Skeleton contracts / contracts (pull_request) Canceled after 0s
2026-10-19 23:40:31 +03:00
38 changed files with 1523 additions and 27 deletions
+3 -10
View File
@@ -1,11 +1,4 @@
# Copy to .env for your LOCAL synthetic test environment; never commit .env.
# These are logical interface suggestions; map actual framework names in REPORT.md.
APP_HOST=0.0.0.0
APP_PORT=8080
APP_ENV=lab
POSTGRES_DB=messenger
POSTGRES_USER=messenger
POSTGRES_PASSWORD=replace-with-your-local-password
SESSION_TTL_SECONDS=3600
# Choose credentials locally. File paths contain no secret values.
DATABASE_URL_FILE=/run/secrets/database_url
# Optional on 3, required use on 4 in lab2; Redis OR Valkey:
SESSION_STORE=postgres
CACHE_URL_FILE=/run/secrets/cache_url
+5
View File
@@ -0,0 +1,5 @@
*.py text eol=lf
*.sh text eol=lf
*.cmd text eol=crlf
*.yaml text eol=lf
*.sql text eol=lf
+29
View File
@@ -0,0 +1,29 @@
FROM python:3.14.8-slim-bookworm
ENV PYTHONDONTWRITEBYTECODE=1 \
PYTHONUNBUFFERED=1 \
APP_HOST=0.0.0.0 \
APP_PORT=8080 \
APP_ENV=lab
WORKDIR /app
COPY requirements.txt ./
RUN python -m pip install --no-cache-dir -r requirements.txt
RUN groupadd --gid 10001 appuser \
&& useradd --uid 10001 --gid appuser --no-create-home --shell /usr/sbin/nologin appuser
COPY src ./src
COPY migrations ./migrations
COPY tests ./tests
COPY student-tests ./student-tests
COPY scripts ./scripts
COPY contracts ./contracts
COPY lab.json ./
USER 10001:10001
EXPOSE 8080
STOPSIGNAL SIGTERM
HEALTHCHECK --interval=5s --timeout=3s --start-period=5s --retries=3 \
CMD ["python", "-c", "import os, urllib.request; urllib.request.urlopen('http://127.0.0.1:'+os.getenv('APP_PORT','8080')+'/health/ready', timeout=2).close()"]
CMD ["python", "-m", "src.run"]
+199 -17
View File
@@ -1,37 +1,219 @@
# Отчёт — лабораторная 2
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- Автор, группа: Рестеу Даниил Андреевич, БВТ2302.
- Целевая оценка: 4. Трек уровня 5 не выполнялся.
- Commit/PR: вписать ссылку после публикации в своём fork.
- Использованные источники, библиотеки и помощь ИИ: собственный API лабораторной 1;
FastAPI, Pydantic, Psycopg 3/psycopg-pool, argon2-cffi, redis-py, Uvicorn;
документация PostgreSQL, Redis, Psycopg, Docker и RFC 7617/6750.
ChatGPT/Codex использован для доработки реализации, проверки требований,
тестов, ревью и подготовки объяснения кода. Это отмечается как помощь ИИ,
а не как полностью самостоятельное написание всех строк.
## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
Необходимы Docker с Compose v2 и Python 3.9+ для публичных скриптов на хосте.
В Dockerfile закреплён `python:3.14.8-slim-bookworm`, в Compose —
`postgres:17.11-bookworm` и `redis:8.2.10-bookworm`. Зависимости Python
перечислены в requirements.txt с точными версиями.
На чистом стенде скопировать .env.example в .env и задать локальный учебный
POSTGRES_PASSWORD. Если данные PostgreSQL уже существуют, использовать
прежние настройки .env: изменение переменной само не меняет пароль в БД.
PowerShell:
```powershell
Copy-Item .env.example .env
# Здесь задать свой POSTGRES_PASSWORD в .env, если стенд создаётся впервые.
docker compose config --quiet
docker compose up -d --build --wait api
Invoke-RestMethod http://localhost:8080/health/ready
python scripts/check_contract.py
docker compose exec -T api python tests/smoke.py
docker compose exec -T api python -m unittest discover -s student-tests -v
docker compose exec -T api python scripts/explain_history.py
python scripts/check_grade4.py --base-url http://127.0.0.1:8080
python tests/resilience.py --mode persistence --action-script scripts/restart.cmd
```
Для уже существующего стенда строку Copy-Item пропустить, сохранив .env.
Linux:
```sh
cp .env.example .env
# Задать локальный POSTGRES_PASSWORD.
docker compose config --quiet
docker compose up -d --build --wait api
make check
make test
docker compose exec -T api python -m unittest discover -s student-tests -v
docker compose exec -T api python scripts/explain_history.py
python3 scripts/check_grade4.py
chmod +x scripts/restart.sh
make test-persistence ACTION_SCRIPT=scripts/restart.sh
```
Мигратор автоматически запускается перед api. Для отдельного повторного
запуска: `docker compose run --rm migrate`. Уже применённые файлы получают SKIP.
Обычная остановка: `docker compose down` — volumes сохраняются.
Намеренное удаление всех учебных данных: `docker compose down -v`.
В .gitignore/.dockerignore исключены .env, закрытые ключи и локальные данные.
## Архитектура и решения
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
Клиент обращается к api. PostgreSQL — источник истины для users, chats,
chat_members и messages. Redis — единственный источник истины для сессий.
Кэширование истории не используется; чтения идут в основную БД.
Из lab1 перенесены API, валидация, формат ошибок, request ID, health endpoints,
Docker-запуск и собственные HTTP-тесты. MemoryStore удалён. X-User-Id игнорируется.
Basic используется только для POST /api/v1/auth/sessions. Пароли 12–128 code points
хешируются Argon2id. Оpaque Bearer token генерируется из 32 случайных байт.
Redis хранит UUID владельца под session:<token> с абсолютным PXAT. TTL по
умолчанию 3600 секунд, задаётся SESSION_TTL_SECONDS. Logout удаляет ключ.
AOF с appendfsync always и volume redis_data сохраняет действующие сессии и
отзыв; рестарт не продлевает срок. FLUSHALL уничтожит сессии, но не доменные данные.
Таблицы имеют UUID PK, FK и UNIQUE username. Составной PK (chat_id,user_id)
предотвращает дубли членства. 01_initial.sql создаёт схему, 02_chat_order.sql
добавляет индекс списка чатов. schema_migrations предотвращает повторное
применение. Создание чата и всех его участников выполняется в одной транзакции;
ошибка FK неизвестного участника откатывает весь чат.
SQL параметризован. Пул одного api-процесса содержит 1–5 соединений, очередь
ожидающих ограничена 20. Ожидание пула — 3 с, подключение — 5 с,
statement_timeout — 5000 мс, lock_timeout — 3000 мс. Redis имеет socket/connect
timeouts по 2 с и не делает автоматические retry. При отказах защищённые
операции возвращают 503 в общем формате. /health/live не зависит от хранилищ;
/health/ready проверяет PostgreSQL и Redis, обе зависимости критичны.
История сортируется по (created_at,id) ASC. SQL получает максимум limit+1 строк
через ключевую границу; полного чтения/сортировки истории в Python нет.
Cursor содержит область запроса, UTC timestamp и UUID. Для неизменной истории
повторов нет, изменение limit допускается. Общего snapshot между страницами нет:
конкурентная запись с уже пройденным временем может быть пропущена этим обходом.
Часы БД должны быть корректны. Подтверждённая запись видна следующему чтению.
POSTGRES_DB/USER/PASSWORD и SESSION_TTL_SECONDS из .env.example действительно
используются Compose и приложением. Внутренние адреса — postgres:5432 и
redis:6379, наружу опубликован только api на 127.0.0.1:8080.
POSTGRES_HOST/PORT и REDIS_HOST/PORT дополнительно можно переопределить
для локальной проверки без Docker.
## Доказательства критериев
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
Итоговый прогон выполнен 19.10.2026 на Windows в PowerShell с Docker Desktop.
Приложение собрано из python:3.14.8-slim-bookworm, PostgreSQL —
17.11-bookworm, Redis — 8.2.10-bookworm. Публичный smoke, все 16 собственных
тестов, короткий TTL, отказы обоих хранилищ и полный persistence-сценарий
завершились успешно. Публичные tests/, contracts/, Makefile и README.md
по содержимому не изменены.
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
evidence/windows-api.txt — предоставленный исходный вывод PowerShell со
сборкой, smoke и 16 тестами. evidence/windows-summary.md — сводка остальных
предоставленных результатов; это не полный необработанный журнал всех команд.
evidence/grade4-windows.txt содержит вывод проверки TTL/отказов.
Файлы с native-результатами относятся к отдельному предварительному прогону
на Python 3.12.14 / PostgreSQL 16.15 / Redis 7.0.15. Его версии и параметры
оборудования не являются характеристиками компьютера студента.
| Критерий README | Команда/сценарий | Наблюдаемый результат локальной проверки | Файл доказательства |
| --- | --- | --- | --- |
| Структура контракта | python scripts/check_contract.py | PASS на Windows | evidence/windows-summary.md |
| Синтаксис Compose и сборка | docker compose config --quiet; up -d --build --wait api | конфигурация принята, образы собраны, api/postgres/redis healthy | evidence/windows-api.txt |
| Публичный API | docker compose exec -T api python tests/smoke.py | PASS lab2 на Windows/Docker | evidence/windows-api.txt |
| Миграции с нуля | python -m src.migrate на новой БД предварительного native-стенда | APPLIED обе миграции; этот лог относится к native-прогону | evidence/migrations.txt |
| Повтор миграций | повтор python -m src.migrate на native-стенде | SKIP обе миграции | evidence/migrations-repeat.txt |
| Сохранены проверки API lab1 | docker compose exec -T api python -m unittest discover -s student-tests -v | 16 тестов OK, 5.909 с на Windows/Docker | evidence/windows-api.txt |
| Безопасные запросы, конкурентная регистрация | test_registration_race | тест OK: один 201, три 409; в БД одна строка | evidence/windows-api.txt |
| Атомарное создание чата | test_chat_rollback_after_unknown_member | тест OK: 400; нет частичного чата и членства | evidence/windows-api.txt |
| KDF, UTF-8 пароль с двоеточием, 256 бит токена | test_unicode_password_with_colon_and_hash | тест OK: вход успешен, Argon2id в БД, 32 случайных байта токена | evidence/windows-api.txt |
| Bearer, неправильный пароль, logout, X-User-Id | smoke и test_login_logout_and_legacy_header | smoke PASS и тест OK на Windows/Docker | evidence/windows-api.txt |
| Expiry в Redis при TTL=2 | python scripts/check_grade4.py --base-url http://127.0.0.1:8080 | PASS: активный токен после истечения получает 401 | evidence/grade4-windows.txt |
| Отказы Redis и БД | тот же scripts/check_grade4.py | оба PASS: bounded 503, live=200, anonymous=401; старый токен работает после восстановления | evidence/grade4-windows.txt |
| Сохранность после полного рестарта | python tests/resilience.py --mode persistence --action-script scripts/restart.cmd | PASS: confirmed data и прежняя сессия сохранились | evidence/windows-summary.md |
| Область фактического native restart hook | PID api, postgres, redis до/после | все три процесса заменены | evidence/native-restart-processes.json |
| Индекс на >=10000 сообщениях | docker compose exec -T api python scripts/explain_history.py | PostgreSQL 17.11, 10000 сообщений; обе страницы используют messages_history_idx | evidence/windows-summary.md |
| Собственные негативные проверки | cursor scope/time, NUL, строгие поля, чужой чат | соответствующие тесты OK на Windows/Docker | evidence/windows-api.txt |
| Фактический Compose restart hook | restart.cmd вызывает restart.py в persistence-тесте | сценарий PASS; hook записывает service/ID/StartedAt/status до и после | evidence/restart-before.txt, evidence/restart-after.txt |
## Эксперименты и отказы
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
Среда предварительного прогона: x86_64, 9 видимых CPU, cgroup RAM limit 8 GiB.
У контейнеров Compose отдельные CPU/RAM limits не назначены. Конкурентный
тест: 10 HTTP-клиентов, по 10 последовательных отправок; прочитаны все 100
уникальных сообщений, ID и тексты совпали. В предварительном native-прогоне 16 тестов заняли 5.023 с;
на Windows/Docker — 5.909 с. Параметры CPU/RAM компьютера студента не фиксировались.
Это проверка корректности, не измерение максимальной производительности;
RPS, p50/p95/p99 и CPU/RAM под нагрузкой не измерялись и не заявляются.
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
EXPLAIN использует 10000 синтетических сообщений одного чата в транзакции с
принудительным rollback. После измерения фикстуры не сохраняются. Выполняется
ANALYZE и затем EXPLAIN (ANALYZE, BUFFERS) тех же SQL-констант, которые использует
API. LIMIT 51 соответствует странице 50 + одной строке для next_cursor.
Для выбора тестовой границы после 9000-й строки используется OFFSET только
при подготовке эксперимента; запрос страницы использует keyset.
В итоговом Windows/Docker-прогоне на PostgreSQL 17.11 первая страница имела
Execution Time 0.031 мс и 4 shared buffer hits; страница после 9000-й записи —
0.056 мс и 3 hits. Обе читали 51 строку через Index Scan messages_history_idx.
Это один локальный прогон с прогретыми данными, а не универсальный SLA.
После замены адреса тестового API с localhost на 127.0.0.1 проверка короткой
сессии на Windows завершилась успешно. Значение TTL осталось равным 2 секундам.
Из одного первоначального 401 нельзя однозначно установить причину задержки.
| Воздействие | Что ожидаем | Что наблюдали | Восстановление / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
| Истечение TTL=2 с | токен больше не принимается | 200 до ожидания, 401 после 2.2 с | повторный вход нужен |
| Logout | немедленный отзыв | 204, затем GET/DELETE с тем же токеном 401 | повторный вход нужен |
| Остановка Redis | безопасный отказ | 503; live=200; анонимный GET=401 | после старта старый действующий токен работает |
| Остановка PostgreSQL | безопасный отказ | 503; live=200; анонимный GET=401 | пул восстанавливается, старый токен работает |
| Перезапуск api и обоих хранилищ | данные и сессия сохраняются | публичный persistence PASS | исходное подтверждённое сообщение не потеряно |
| Неизвестный участник после INSERT чата | rollback всей операции | 400; частичных строк нет | состояние БД не изменилось |
Native restart проверял реальные процессы предварительного стенда.
Итоговый Windows persistence-тест вызвал Docker hook через restart.cmd;
он перезапускает api, postgres и redis с сохранением volumes. Для проверки
области рестарта приложены restart-before.txt и restart-after.txt со StartedAt.
Времена полного восстановления отдельно не измерялись: тесты подтвердили
восстановление в пределах своих ожиданий, а не обещание конкретного SLA.
## Ограничения и следующие шаги
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
Один api, PostgreSQL и Redis на одном узле; высокой доступности и резервного
копирования нет. Volumes и AOF выдерживают проверяемый рестарт, но не заменяют
backup при удалении данных, потере диска или аппаратном сбое. Гарантии COMMIT
зависят от настроек PostgreSQL, fsync и реального диска; они не отключались.
Redis appendfsync always выбран ради durability, цена — дополнительные fsync.
HTTP и синтетические credentials предназначены для локального стенда; удалённая
демонстрация требует TLS согласно заданию. История не кэшируется, поэтому
отсутствует задача инвалидации кэша сообщений. После потери Redis-сессий нужен
повторный вход. В текущем API нет удаления пользователей/членства и редактирования
сообщений. Между HTTP-страницами не поддерживается snapshot.
Публичные тесты проверяют схему WWW-Authenticate; отдельные собственные assertions
на точное значение realm не добавлялись. Заголовки задаются явно в error_response.
Закреплённые Docker-версии проверены на Windows. Перед сдачей остаётся
вписать ссылку commit/PR после публикации и подготовиться объяснить код.
## Первичные источники
- https://www.postgresql.org/docs/17/tutorial-transactions.html
- https://www.postgresql.org/docs/17/indexes-multicolumn.html
- https://www.postgresql.org/docs/17/using-explain.html
- https://www.psycopg.org/psycopg3/docs/basic/transactions.html
- https://www.psycopg.org/psycopg3/docs/advanced/pool.html
- https://redis.io/docs/latest/operate/oss_and_stack/management/persistence/
- https://redis.io/docs/latest/commands/set/
- https://argon2-cffi.readthedocs.io/en/stable/howto.html
- https://www.rfc-editor.org/rfc/rfc7617
- https://www.rfc-editor.org/rfc/rfc6750
- https://docs.docker.com/reference/cli/docker/compose/up/
+57
View File
@@ -0,0 +1,57 @@
services:
postgres:
image: postgres:17.11-bookworm
environment:
POSTGRES_DB: ${POSTGRES_DB:?Set POSTGRES_DB in .env}
POSTGRES_USER: ${POSTGRES_USER:?Set POSTGRES_USER in .env}
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?Set POSTGRES_PASSWORD in .env}
volumes:
- postgres_data:/var/lib/postgresql/data
healthcheck:
test: ["CMD-SHELL", "pg_isready -U $$POSTGRES_USER -d $$POSTGRES_DB"]
interval: 5s
timeout: 3s
retries: 10
redis:
image: redis:8.2.10-bookworm
command: ["redis-server", "--appendonly", "yes", "--appendfsync", "always"]
volumes:
- redis_data:/data
healthcheck:
test: ["CMD", "redis-cli", "ping"]
interval: 5s
timeout: 3s
retries: 10
migrate:
build: .
command: ["python", "-m", "src.migrate"]
environment: &database_settings
POSTGRES_DB: ${POSTGRES_DB}
POSTGRES_USER: ${POSTGRES_USER}
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
depends_on:
postgres:
condition: service_healthy
healthcheck:
disable: true
api:
build: .
environment:
<<: *database_settings
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
ports:
- "127.0.0.1:8080:8080"
depends_on:
postgres:
condition: service_healthy
redis:
condition: service_healthy
migrate:
condition: service_completed_successfully
volumes:
postgres_data:
redis_data:
+19
View File
@@ -0,0 +1,19 @@
# Среда и область проверки
Дата: 19.10.2026. Приложенные логи относятся к предварительному native-прогону,
а не к Docker Desktop студента.
- Python 3.12.14, PostgreSQL 16.15, Redis 7.0.15, x86_64.
- 9 видимых CPU, cgroup RAM limit 8 GiB.
- Использовались настоящие PostgreSQL и Redis, не моки хранилищ.
- tests/smoke.py и tests/resilience.py запускались без изменений.
- Все 16 student-tests прошли; итоговый прогон — 5.023 с.
- EXPLAIN выполнен на 10000 временных сообщениях; обе страницы используют индекс.
- Короткий TTL, остановка каждого хранилища и полный рестарт реальных процессов прошли.
- native-restart-processes.json фиксирует PID api/postgres/redis до/после полного рестарта.
- Compose CLI 2.40.3 проверил compose.yaml командой config --quiet, код завершения 0.
- Docker daemon отсутствует. Docker build/up, закреплённые версии образов,
Windows restart.cmd и Docker restart.sh здесь не запускались.
На компьютере студента нужно повторить команды START_HERE_RU.md, сохранить вывод
в отдельные файлы и обновить REPORT.md. Эти результаты не гарантируют оценку.
+2
View File
@@ -0,0 +1,2 @@
.venv/bin/python scripts/check_contract.py
PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.
+5
View File
@@ -0,0 +1,5 @@
Compose CLI version: 2.40.3
Command: docker compose config --quiet
Result: exit 0, no validation output
Synthetic environment supplied for POSTGRES_DB/USER/PASSWORD.
Docker daemon/build/up were not tested in this environment.
+21
View File
@@ -0,0 +1,21 @@
PostgreSQL 16.15 (Ubuntu 16.15-0ubuntu0.24.04.1) on x86_64-pc-linux-gnu, compiled by gcc (Ubuntu 13.3.0-6ubuntu2~24.04.1) 13.3.0, 64-bit
Fixture messages: 10000
FIRST PAGE: LIMIT 51 (50 items + lookahead)
Limit (cost=0.29..5.65 rows=51 width=76) (actual time=0.006..0.012 rows=51 loops=1)
Buffers: shared hit=3
-> Index Scan using messages_history_idx on messages (cost=0.29..1052.02 rows=10000 width=76) (actual time=0.005..0.009 rows=51 loops=1)
Index Cond: (chat_id = '799a61aa-3fa2-4535-84e9-28889941c357'::uuid)
Buffers: shared hit=3
Planning:
Buffers: shared hit=18
Planning Time: 0.046 ms
Execution Time: 0.018 ms
LATER PAGE: after message 9000, LIMIT 51
Limit (cost=0.29..17.73 rows=51 width=76) (actual time=0.004..0.012 rows=51 loops=1)
Buffers: shared hit=4
-> Index Scan using messages_history_idx on messages (cost=0.29..375.19 rows=1096 width=76) (actual time=0.003..0.008 rows=51 loops=1)
Index Cond: ((chat_id = '799a61aa-3fa2-4535-84e9-28889941c357'::uuid) AND (ROW(created_at, id) > ROW('2026-01-01 00:00:00.009+00'::timestamp with time zone, 'a598e58f-565a-4ff7-b30b-19dcc8524574'::uuid)))
Buffers: shared hit=4
Planning Time: 0.035 ms
Execution Time: 0.024 ms
PASS: 10000 messages; first/later pages use messages_history_idx; fixtures rolled back
+3
View File
@@ -0,0 +1,3 @@
PASS: SESSION_TTL_SECONDS=2; active token becomes 401 after expiry
PASS: redis outage -> bounded 503; live=200; anonymous=401; old token recovers
PASS: postgres outage -> bounded 503; live=200; anonymous=401; old token recovers
+3
View File
@@ -0,0 +1,3 @@
PASS: SESSION_TTL_SECONDS=2; active token becomes 401 after expiry
PASS: redis outage -> bounded 503; live=200; anonymous=401; old token recovers
PASS: postgres outage -> bounded 503; live=200; anonymous=401; old token recovers
+2
View File
@@ -0,0 +1,2 @@
SKIP 01_initial.sql
SKIP 02_chat_order.sql
+2
View File
@@ -0,0 +1,2 @@
APPLIED 01_initial.sql
APPLIED 02_chat_order.sql
+30
View File
@@ -0,0 +1,30 @@
{
"before": {
"api": {
"pid": 24,
"running": true
},
"postgres": {
"pid": 3775,
"running": true
},
"redis": {
"pid": 3674,
"running": true
}
},
"after": {
"api": {
"pid": 4090,
"running": true
},
"postgres": {
"pid": 4077,
"running": true
},
"redis": {
"pid": 4084,
"running": true
}
}
}
+2
View File
@@ -0,0 +1,2 @@
Executing explicit persistence hook; hook output suppressed to avoid leaking secrets.
PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.
+3
View File
@@ -0,0 +1,3 @@
api dafaccaefd42497d456f3e26d23ac6be4f70f0e37949c138328d0c97295311b3 2026-10-19T20:18:14.844180844Z running
postgres 9c96af6664fb6aae298d6153c6ecca2d88260d0e45c6e04f9642b45c669db5fb 2026-10-19T20:18:07.973412169Z running
redis a8784a6f176fdff2ede5e350216d9fc94963c57ff611944cac275fc61df49b5b 2026-10-19T20:18:07.799371434Z running
+3
View File
@@ -0,0 +1,3 @@
api dafaccaefd42497d456f3e26d23ac6be4f70f0e37949c138328d0c97295311b3 2026-10-19T20:11:47.430509928Z running
postgres 9c96af6664fb6aae298d6153c6ecca2d88260d0e45c6e04f9642b45c669db5fb 2026-10-19T18:28:42.086328397Z running
redis a8784a6f176fdff2ede5e350216d9fc94963c57ff611944cac275fc61df49b5b 2026-10-19T19:26:54.47293161Z running
+1
View File
@@ -0,0 +1 @@
PASS: lab2 public API scenario; infrastructure and grading evidence remain separate.
+22
View File
@@ -0,0 +1,22 @@
test_concurrency_100_messages_10_clients (test_api.ApiTests.test_concurrency_100_messages_10_clients) ... ok
test_duplicate_username (test_api.ApiTests.test_duplicate_username) ... ok
test_empty_message (test_api.ApiTests.test_empty_message) ... ok
test_foreign_chat (test_api.ApiTests.test_foreign_chat) ... ok
test_malformed_json (test_api.ApiTests.test_malformed_json) ... ok
test_multiple_pages_and_cursor_scope (test_api.ApiTests.test_multiple_pages_and_cursor_scope) ... ok
test_validation_and_auth (test_api.ApiTests.test_validation_and_auth) ... ok
test_chat_rollback_after_unknown_member (test_grade4.Grade4Tests.test_chat_rollback_after_unknown_member) ... ok
test_equal_timestamp_pages (test_grade4.Grade4Tests.test_equal_timestamp_pages) ... ok
test_login_logout_and_legacy_header (test_grade4.Grade4Tests.test_login_logout_and_legacy_header) ... ok
test_nul_in_persisted_fields_returns_400 (test_grade4.Grade4Tests.test_nul_in_persisted_fields_returns_400) ... ok
test_registration_race (test_grade4.Grade4Tests.test_registration_race) ... ok
test_unicode_password_with_colon_and_hash (test_grade4.Grade4Tests.test_unicode_password_with_colon_and_hash) ... ok
test_cursor_requires_complete_utc_datetime (test_pagination.PaginationTests.test_cursor_requires_complete_utc_datetime) ... ok
test_cursor_round_trip_and_scope (test_pagination.PaginationTests.test_cursor_round_trip_and_scope) ... ok
test_invalid_limits_and_cursors (test_pagination.PaginationTests.test_invalid_limits_and_cursors) ... ok
----------------------------------------------------------------------
Ran 16 tests in 5.023s
OK
PASS: 10 clients; 100 POST; 100 unique messages; IDs/text match
+30
View File
@@ -0,0 +1,30 @@
CREATE TABLE users (
id UUID PRIMARY KEY,
username VARCHAR(32) NOT NULL UNIQUE,
display_name VARCHAR(100) NOT NULL,
password_hash TEXT NOT NULL,
created_at TIMESTAMPTZ NOT NULL DEFAULT now()
);
CREATE TABLE chats (
id UUID PRIMARY KEY,
title VARCHAR(100) NOT NULL,
created_at TIMESTAMPTZ NOT NULL DEFAULT now()
);
CREATE TABLE chat_members (
chat_id UUID NOT NULL REFERENCES chats(id),
user_id UUID NOT NULL REFERENCES users(id),
PRIMARY KEY (chat_id, user_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 VARCHAR(4000) NOT NULL,
created_at TIMESTAMPTZ NOT NULL DEFAULT now()
);
CREATE INDEX chat_members_user_idx ON chat_members (user_id, chat_id);
CREATE INDEX messages_history_idx ON messages (chat_id, created_at, id);
+1
View File
@@ -0,0 +1 @@
CREATE INDEX chats_order_idx ON chats (created_at, id);
+18
View File
@@ -0,0 +1,18 @@
annotated-doc==0.0.5
annotated-types==0.8.0
anyio==4.15.1
click==8.5.0
fastapi==0.143.0
h11==0.16.0
idna==3.20
opentelemetry-api==1.45.1
pydantic==2.14.1
pydantic_core==2.50.1
starlette==1.7.0
typing-inspection==0.4.4
typing_extensions==4.16.0
uvicorn==0.54.0
psycopg[binary]==3.3.6
psycopg-pool==3.3.3
argon2-cffi==25.1.0
redis==8.1.0
+85
View File
@@ -0,0 +1,85 @@
"""Explicit local Docker checks: expiry, then Redis/PostgreSQL outages."""
import argparse
import subprocess
import sys
import time
from pathlib import Path
from uuid import uuid4
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT / "tests"))
from client import Client, Failure, check
def docker(*args):
subprocess.run(["docker", *args], cwd=ROOT, check=True, timeout=90,
stdout=subprocess.DEVNULL)
def wait_ready(c):
deadline = time.monotonic() + 45
while True:
try:
c.call("GET", "/health/ready", schema="Health")
return
except Failure:
if time.monotonic() >= deadline:
raise
time.sleep(0.2)
def check_expiry(base_url):
c = Client(base_url, timeout=8)
wait_ready(c)
actor = c.user("expiry")
c.call("GET", "/api/v1/users/me", actor=actor, schema="User")
time.sleep(2.2)
c.call("GET", "/api/v1/users/me", 401, actor=actor)
print("PASS: SESSION_TTL_SECONDS=2; active token becomes 401 after expiry")
def check_outage(c, service, stop, start):
wait_ready(c)
actor = c.user("outage")
try:
stop()
for path in ("/health/ready", "/api/v1/users/me"):
response = c.call("GET", path, 503,
actor=actor if path.startswith("/api/") else None)
check(response["elapsed"] < 8, service + " failure took too long")
check(response["json"]["error"]["code"] == "unavailable", "wrong outage error")
c.call("GET", "/health/live", schema="Health")
c.call("GET", "/api/v1/users/me", 401)
finally:
start()
wait_ready(c)
c.call("GET", "/api/v1/users/me", actor=actor, schema="User")
print("PASS: " + service + " outage -> bounded 503; live=200; anonymous=401; old token recovers")
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("--base-url", default="http://localhost:8080")
parser.add_argument("--expiry-port", type=int, default=8081)
args = parser.parse_args()
check(1 <= args.expiry_port <= 65535, "invalid expiry port")
name = "lab2-expiry-" + uuid4().hex[:12]
started = False
try:
docker("compose", "run", "-d", "--rm", "--no-deps", "--name", name,
"-e", "SESSION_TTL_SECONDS=2", "-p", "127.0.0.1:" + str(args.expiry_port) + ":8080", "api")
started = True
check_expiry("http://127.0.0.1:" + str(args.expiry_port))
finally:
if started:
docker("stop", name)
c = Client(args.base_url, timeout=8)
for service in ("redis", "postgres"):
check_outage(c, service,
lambda s=service: docker("compose", "stop", s),
lambda s=service: docker("compose", "up", "-d", "--wait", s))
if __name__ == "__main__":
main()
+60
View File
@@ -0,0 +1,60 @@
"""EXPLAIN on 10,000 synthetic messages; transaction rolls fixtures back."""
import sys
from pathlib import Path
from uuid import uuid4
import psycopg
from argon2 import PasswordHasher
sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
from src.db import connection_kwargs
from src.main import HISTORY_AFTER_SQL, HISTORY_FIRST_SQL
def explain(conn, query, params):
plan = conn.execute("EXPLAIN (ANALYZE, BUFFERS) " + query, params).fetchall()
text = "\n".join(row["QUERY PLAN"] for row in plan)
print(text)
if "messages_history_idx" not in text or "Seq Scan on messages" in text:
raise AssertionError("Expected history index without full messages scan")
def main():
user_id, chat_id = uuid4(), uuid4()
with psycopg.connect(**connection_kwargs()) as conn:
print(conn.execute("SELECT version() AS version").fetchone()["version"])
with conn.transaction(force_rollback=True):
conn.execute(
"INSERT INTO users (id,username,display_name,password_hash) VALUES (%s,%s,%s,%s)",
(user_id, "plan_" + uuid4().hex[:20], "EXPLAIN fixture",
PasswordHasher().hash("Synthetic-password-123")),
)
conn.execute("INSERT INTO chats (id,title) VALUES (%s,%s)", (chat_id, "EXPLAIN fixture"))
conn.execute("INSERT INTO chat_members (chat_id,user_id) VALUES (%s,%s)", (chat_id, user_id))
conn.execute("""
INSERT INTO messages (id,chat_id,sender_id,text,created_at)
SELECT gen_random_uuid(), %s, %s, 'EXPLAIN fixture ' || n,
TIMESTAMPTZ '2026-01-01T00:00:00Z' + n * INTERVAL '1 microsecond'
FROM generate_series(1,10000) AS n
""", (chat_id, user_id))
conn.execute("ANALYZE messages")
count = conn.execute("SELECT count(*) AS n FROM messages WHERE chat_id=%s",
(chat_id,)).fetchone()["n"]
assert count >= 10000
print("Fixture messages:", count)
print("FIRST PAGE: LIMIT 51 (50 items + lookahead)")
explain(conn, HISTORY_FIRST_SQL, (chat_id, 51))
# OFFSET only selects a reproducible fixture boundary, outside the page query.
boundary = conn.execute(
"SELECT created_at,id FROM messages WHERE chat_id=%s "
"ORDER BY created_at,id OFFSET 8999 LIMIT 1", (chat_id,),
).fetchone()
print("LATER PAGE: after message 9000, LIMIT 51")
explain(conn, HISTORY_AFTER_SQL,
(chat_id, boundary["created_at"], boundary["id"], 51))
conn.execute("ANALYZE messages")
print("PASS: 10000 messages; first/later pages use messages_history_idx; fixtures rolled back")
if __name__ == "__main__":
main()
+4
View File
@@ -0,0 +1,4 @@
@echo off
cd /d "%~dp0.."
python scripts\restart.py
exit /b %errorlevel%
+34
View File
@@ -0,0 +1,34 @@
"""Restart the complete lab stack; keep volumes and record actual start times."""
import subprocess
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
SERVICES = ["api", "postgres", "redis"]
def snapshot(filename):
ids = subprocess.check_output(
["docker", "compose", "ps", "--all", "-q", *SERVICES], cwd=ROOT, text=True
).split()
if len(ids) != 3:
raise RuntimeError("Expected one api, postgres and redis container")
template = ('{{index .Config.Labels "com.docker.compose.service"}} '
'{{.Id}} {{.State.StartedAt}} {{.State.Status}}')
lines = subprocess.check_output(
["docker", "inspect", "--format", template, *ids], cwd=ROOT, text=True
)
(ROOT / "evidence").mkdir(exist_ok=True)
(ROOT / "evidence" / filename).write_text(lines, encoding="utf-8")
def main():
snapshot("restart-before.txt")
subprocess.run(["docker", "compose", "stop", *SERVICES], cwd=ROOT, check=True, timeout=45)
subprocess.run(["docker", "compose", "up", "-d", "--wait", "api"],
cwd=ROOT, check=True, timeout=40)
snapshot("restart-after.txt")
if __name__ == "__main__":
main()
+4
View File
@@ -0,0 +1,4 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
exec python3 scripts/restart.py
View File
+29
View File
@@ -0,0 +1,29 @@
import os
from psycopg.rows import dict_row
from psycopg_pool import ConnectionPool
def connection_kwargs():
return {
"host": os.getenv("POSTGRES_HOST", "postgres"),
"port": int(os.getenv("POSTGRES_PORT", "5432")),
"dbname": os.environ["POSTGRES_DB"],
"user": os.environ["POSTGRES_USER"],
"password": os.environ["POSTGRES_PASSWORD"],
"connect_timeout": 5,
"options": "-c statement_timeout=5000 -c lock_timeout=3000",
"autocommit": True,
"row_factory": dict_row,
}
pool = ConnectionPool(
kwargs=connection_kwargs(),
min_size=1,
max_size=5,
max_waiting=20,
timeout=3,
check=ConnectionPool.check_connection,
open=False,
)
+14
View File
@@ -0,0 +1,14 @@
class ApiError(Exception):
def __init__(self, status, code, message):
super().__init__(message)
self.status = status
self.code = code
self.message = message
def invalid(message="Неверный запрос"):
raise ApiError(400, "invalid_request", message)
def unauthorized():
raise ApiError(401, "unauthorized", "Неверные данные авторизации")
+398
View File
@@ -0,0 +1,398 @@
import base64
import binascii
import logging
import re
import time
from contextlib import asynccontextmanager
from datetime import datetime, timezone
from uuid import UUID, uuid4
from argon2 import PasswordHasher
from argon2.exceptions import VerifyMismatchError
from fastapi import FastAPI, Header, Query, Request
from fastapi.exceptions import RequestValidationError
from fastapi.responses import JSONResponse, Response
from psycopg import InterfaceError, OperationalError
from psycopg.errors import ForeignKeyViolation, UniqueViolation
from pydantic import BaseModel, ConfigDict, Field, field_validator
from redis.exceptions import RedisError
from starlette.concurrency import run_in_threadpool
from starlette.exceptions import HTTPException as StarletteHTTPException
from src.db import pool
from src.errors import ApiError, invalid, unauthorized
from src.pagination import encode_cursor, parse_page
from src.sessions import issue_session, redis_client
log = logging.getLogger("messenger")
password_hasher = PasswordHasher()
ready = False
def parse_uuid(value):
try:
return UUID(value)
except (ValueError, TypeError, AttributeError):
invalid("Некорректный UUID")
def row_response(row):
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 key == "member_ids":
value = [str(member) for member in value]
result[key] = value
return result
class InputModel(BaseModel):
model_config = ConfigDict(extra="forbid", strict=True)
@field_validator("*", check_fields=False)
@classmethod
def reject_blank(cls, value):
if isinstance(value, str) and not value.strip():
raise ValueError("Строка не должна быть пустой")
return value
@field_validator("display_name", "title", "text", check_fields=False)
@classmethod
def reject_nul(cls, value):
if "\u0000" in value:
raise ValueError("Нулевой символ недопустим в текстовом поле")
return value
class CreateUser(InputModel):
username: str = Field(min_length=3, max_length=32)
display_name: str = Field(min_length=1, max_length=100)
password: str = Field(min_length=12, max_length=128)
@field_validator("username")
@classmethod
def validate_username(cls, value):
if re.fullmatch(r"[a-z0-9_]{3,32}", value) is None:
raise ValueError("Некорректный username")
return value
class CreateChat(InputModel):
title: str = Field(min_length=1, max_length=100)
member_ids: list[str] = Field(min_length=1, max_length=100)
class CreateMessage(InputModel):
text: str = Field(min_length=1, max_length=4000)
def bearer_token(value):
scheme, _, token = (value or "").partition(" ")
if scheme.lower() != "bearer" or not token:
unauthorized()
return token
def current_user(value):
token = bearer_token(value)
user_id = redis_client.get("session:" + token)
if user_id is None:
unauthorized()
with pool.connection() as conn:
user = conn.execute(
"SELECT id, username, display_name, created_at FROM users WHERE id = %s",
(UUID(user_id),),
).fetchone()
if user is None:
unauthorized()
return row_response(user)
@asynccontextmanager
async def lifespan(app):
global ready
try:
await run_in_threadpool(pool.open, wait=True, timeout=10)
await run_in_threadpool(redis_client.ping)
ready = True
log.info("startup ready=true")
yield
finally:
ready = False
redis_client.close()
pool.close()
log.info("shutdown complete")
app = FastAPI(title="Lab 2 Messenger", lifespan=lifespan)
def error_response(request, status, code, message):
request_id = request.state.request_id
headers = {"X-Request-Id": request_id}
if status == 401:
if request.method == "POST" and request.url.path == "/api/v1/auth/sessions":
headers["WWW-Authenticate"] = 'Basic realm="messenger", charset="UTF-8"'
else:
headers["WWW-Authenticate"] = 'Bearer realm="messenger"'
return JSONResponse(
status_code=status,
content={"error": {"code": code, "message": message, "request_id": request_id}},
headers=headers,
)
@app.exception_handler(ApiError)
async def api_error(request, exc):
return error_response(request, exc.status, exc.code, exc.message)
@app.exception_handler(RequestValidationError)
async def validation_error(request, exc):
return error_response(request, 400, "invalid_request", "Некорректные поля или JSON")
@app.exception_handler(StarletteHTTPException)
async def http_error(request, exc):
code = "not_found" if exc.status_code == 404 else "invalid_request"
return error_response(request, exc.status_code, code, "Некорректный запрос")
@app.middleware("http")
async def process_request(request: Request, call_next):
request.state.request_id = str(uuid4())
started = time.perf_counter()
try:
is_login = request.method == "POST" and request.url.path == "/api/v1/auth/sessions"
public = request.method == "POST" and request.url.path in (
"/api/v1/users", "/api/v1/auth/sessions"
)
if request.url.path.startswith("/api/v1/") and not public:
request.state.user = await run_in_threadpool(
current_user, request.headers.get("Authorization")
)
if is_login:
if await request.body():
invalid("Для входа тело запроса должно быть пустым")
elif request.method == "POST" and request.url.path.startswith("/api/v1/"):
media_type = request.headers.get("content-type", "").split(";")[0]
if media_type.strip().lower() != "application/json":
raise ApiError(415, "unsupported_media_type", "Нужен application/json")
response = await call_next(request)
except ApiError as exc:
response = error_response(request, exc.status, exc.code, exc.message)
except (OperationalError, InterfaceError, RedisError):
response = error_response(request, 503, "unavailable", "Хранилище недоступно")
except Exception as exc:
# Не пишем body, Authorization, SQL или текст исключения в журнал.
log.error("request_failed type=%s request_id=%s",
type(exc).__name__, request.state.request_id)
response = error_response(request, 500, "internal_error", "Внутренняя ошибка")
response.headers["X-Request-Id"] = request.state.request_id
route = request.scope.get("route")
log.info("request method=%s route=%s status=%s duration_ms=%.2f request_id=%s",
request.method, getattr(route, "path", "unmatched"), response.status_code,
(time.perf_counter() - started) * 1000, request.state.request_id)
return response
@app.get("/health/live")
def live():
return {"status": "ok"}
@app.get("/health/ready")
def readiness():
if not ready:
raise ApiError(503, "unavailable", "Приложение не готово")
with pool.connection() as conn:
conn.execute("SELECT 1")
redis_client.ping()
return {"status": "ok"}
@app.post("/api/v1/users", status_code=201)
def create_user(body: CreateUser):
password_hash = password_hasher.hash(body.password)
try:
with pool.connection() as conn:
user = conn.execute(
"INSERT INTO users (id, username, display_name, password_hash) "
"VALUES (%s, %s, %s, %s) RETURNING id, username, display_name, created_at",
(uuid4(), body.username, body.display_name, password_hash),
).fetchone()
except UniqueViolation as exc:
if exc.diag.constraint_name == "users_username_key":
raise ApiError(409, "conflict", "Username занят") from None
raise
return row_response(user)
@app.post("/api/v1/auth/sessions", status_code=201)
def login(authorization: str | None = Header(default=None)):
scheme, _, encoded = (authorization or "").partition(" ")
if scheme.lower() != "basic" or not encoded:
unauthorized()
try:
decoded = base64.b64decode(encoded, validate=True).decode("utf-8")
username, password = decoded.split(":", 1)
except (ValueError, binascii.Error):
unauthorized()
if re.fullmatch(r"[a-z0-9_]{3,32}", username) is None or not 12 <= len(password) <= 128:
unauthorized()
with pool.connection() as conn:
user = conn.execute(
"SELECT id, username, display_name, password_hash, created_at "
"FROM users WHERE username = %s", (username,),
).fetchone()
if user is None:
unauthorized()
try:
password_hasher.verify(user["password_hash"], password)
except VerifyMismatchError:
unauthorized()
token, expires_at = issue_session(user["id"])
del user["password_hash"]
return {"token": token, "token_type": "Bearer", "expires_at": expires_at,
"user": row_response(user)}
@app.delete("/api/v1/auth/sessions/current", status_code=204)
def logout(request: Request):
token = bearer_token(request.headers.get("Authorization"))
redis_client.delete("session:" + token)
return Response(status_code=204)
@app.get("/api/v1/users/me")
def get_me(request: Request):
return request.state.user
def require_member(conn, chat_id, user_id):
found = conn.execute(
"SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s",
(chat_id, UUID(user_id)),
).fetchone()
if found is None:
raise ApiError(404, "not_found", "Чат не найден")
CHAT_SELECT = """
SELECT c.id, c.title, c.created_at,
ARRAY(SELECT user_id FROM chat_members
WHERE chat_id = c.id ORDER BY user_id) AS member_ids
FROM chats c
JOIN chat_members mine ON mine.chat_id = c.id
WHERE mine.user_id = %s
"""
HISTORY_FIRST_SQL = """
SELECT id, chat_id, sender_id, text, created_at
FROM messages WHERE chat_id = %s
ORDER BY created_at, id LIMIT %s
"""
HISTORY_AFTER_SQL = """
SELECT id, chat_id, sender_id, text, created_at
FROM messages WHERE chat_id = %s AND (created_at, id) > (%s, %s)
ORDER BY created_at, id LIMIT %s
"""
def page_response(rows, size, scope):
items = [row_response(row) for row in rows[:size]]
cursor = encode_cursor(scope, items[-1]) if len(rows) > size else None
return {"items": items, "next_cursor": cursor}
@app.post("/api/v1/chats", status_code=201)
def create_chat(body: CreateChat, request: Request):
members = sorted(parse_uuid(value) for value in body.member_ids)
if len(members) != len(set(members)):
invalid("Участники повторяются")
if UUID(request.state.user["id"]) not in members:
invalid("Вызывающий должен входить в member_ids")
try:
with pool.connection() as conn:
with conn.transaction():
chat = conn.execute(
"INSERT INTO chats (id, title) VALUES (%s, %s) "
"RETURNING id, title, created_at", (uuid4(), body.title),
).fetchone()
with conn.cursor() as cur:
cur.executemany(
"INSERT INTO chat_members (chat_id, user_id) VALUES (%s, %s)",
[(chat["id"], member) for member in members],
)
except ForeignKeyViolation:
invalid("Неизвестный участник")
chat["member_ids"] = members
return row_response(chat)
@app.get("/api/v1/chats")
def list_chats(request: Request, limit: str = Query(default="50"),
cursor: str | None = Query(default=None)):
user_id = request.state.user["id"]
scope = "chats:" + user_id
size, after = parse_page(limit, cursor, scope)
query = CHAT_SELECT
params = [UUID(user_id)]
if after is not None:
query += " AND (c.created_at, c.id) > (%s, %s)"
params.extend(after)
query += " ORDER BY c.created_at, c.id LIMIT %s"
params.append(size + 1)
with pool.connection() as conn:
rows = conn.execute(query, params).fetchall()
return page_response(rows, size, scope)
@app.get("/api/v1/chats/{chat_id}")
def get_chat(chat_id: str, request: Request):
with pool.connection() as conn:
chat = conn.execute(
CHAT_SELECT + " AND c.id = %s",
(UUID(request.state.user["id"]), parse_uuid(chat_id)),
).fetchone()
if chat is None:
raise ApiError(404, "not_found", "Чат не найден")
return row_response(chat)
@app.post("/api/v1/chats/{chat_id}/messages", status_code=201)
def create_message(chat_id: str, body: CreateMessage, request: Request):
chat_uuid = parse_uuid(chat_id)
user_id = request.state.user["id"]
with pool.connection() as conn:
require_member(conn, chat_uuid, user_id)
message = conn.execute(
"INSERT INTO messages (id, chat_id, sender_id, text) VALUES (%s, %s, %s, %s) "
"RETURNING id, chat_id, sender_id, text, created_at",
(uuid4(), chat_uuid, UUID(user_id), body.text),
).fetchone()
return row_response(message)
@app.get("/api/v1/chats/{chat_id}/messages")
def list_messages(chat_id: str, request: Request, limit: str = Query(default="50"),
cursor: str | None = Query(default=None)):
chat_uuid = parse_uuid(chat_id)
scope = "messages:" + str(chat_uuid)
size, after = parse_page(limit, cursor, scope)
with pool.connection() as conn:
require_member(conn, chat_uuid, request.state.user["id"])
if after is None:
rows = conn.execute(HISTORY_FIRST_SQL, (chat_uuid, size + 1)).fetchall()
else:
rows = conn.execute(
HISTORY_AFTER_SQL, (chat_uuid, after[0], after[1], size + 1)
).fetchall()
return page_response(rows, size, scope)
+37
View File
@@ -0,0 +1,37 @@
from pathlib import Path
import psycopg
from src.db import connection_kwargs
def main():
files = sorted((Path(__file__).resolve().parents[1] / "migrations").glob("*.sql"))
if not files:
raise RuntimeError("Миграции не найдены")
with psycopg.connect(**connection_kwargs()) as conn:
conn.execute("""
CREATE TABLE IF NOT EXISTS schema_migrations (
version TEXT PRIMARY KEY,
applied_at TIMESTAMPTZ NOT NULL DEFAULT now()
)
""")
for file in files:
applied = False
with conn.transaction():
# Один мигратор за раз, даже при одновременном запуске команд.
conn.execute("SELECT pg_advisory_xact_lock(202602)")
exists = conn.execute(
"SELECT 1 FROM schema_migrations WHERE version = %s", (file.name,)
).fetchone()
if exists is None:
conn.execute(file.read_text(encoding="utf-8"))
conn.execute(
"INSERT INTO schema_migrations (version) VALUES (%s)", (file.name,)
)
applied = True
print(("APPLIED " if applied else "SKIP ") + file.name)
if __name__ == "__main__":
main()
+47
View File
@@ -0,0 +1,47 @@
import base64
import binascii
import json
import re
from datetime import datetime
from uuid import UUID
from src.errors import invalid
def encode_cursor(scope, item):
data = {"scope": scope, "created_at": item["created_at"], "id": item["id"]}
raw = json.dumps(data, separators=(",", ":")).encode("utf-8")
return base64.urlsafe_b64encode(raw).decode("ascii").rstrip("=")
def parse_page(limit, cursor, scope):
if len(limit) > 10 or re.fullmatch(r"[0-9]+", limit) is None:
invalid("limit должен быть целым числом от 1 до 100")
size = int(limit)
if not 1 <= size <= 100:
invalid("limit должен быть от 1 до 100")
if cursor is None:
return size, None
if not cursor or len(cursor) > 2048:
invalid("Некорректный cursor")
try:
raw = base64.b64decode(
cursor + "=" * (-len(cursor) % 4), altchars=b"-_", validate=True
)
data = json.loads(raw)
if not isinstance(data, dict) or set(data) != {"scope", "created_at", "id"}:
raise ValueError
if data["scope"] != scope or not isinstance(data["created_at"], str):
raise ValueError
if re.fullmatch(
r"[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}(?:\.[0-9]{1,6})?Z",
data["created_at"],
) is None:
raise ValueError
created_at = datetime.fromisoformat(data["created_at"][:-1] + "+00:00")
if created_at.tzinfo is None:
raise ValueError
item_id = UUID(data["id"])
except (ValueError, TypeError, AttributeError, binascii.Error):
invalid("Некорректный cursor или cursor от другого ресурса")
return size, (created_at, item_id)
+23
View File
@@ -0,0 +1,23 @@
import logging
import os
import uvicorn
if __name__ == "__main__":
logging.basicConfig(
level=logging.INFO,
format="%(asctime)s %(levelname)s %(name)s %(message)s",
)
logging.getLogger("messenger").info(
"config app_env=%s", os.getenv("APP_ENV", "lab")
)
uvicorn.run(
"src.main:app",
host=os.getenv("APP_HOST", "0.0.0.0"),
port=int(os.getenv("APP_PORT", "8080")),
workers=1,
timeout_graceful_shutdown=5,
timeout_keep_alive=1,
access_log=False,
)
+33
View File
@@ -0,0 +1,33 @@
import os
import secrets
import time
from datetime import datetime, timezone
from redis import Redis
from redis.backoff import NoBackoff
from redis.retry import Retry
redis_client = Redis(
host=os.getenv("REDIS_HOST", "redis"),
port=int(os.getenv("REDIS_PORT", "6379")),
decode_responses=True,
socket_connect_timeout=2,
socket_timeout=2,
max_connections=10,
retry=Retry(NoBackoff(), 0),
)
SESSION_TTL_SECONDS = int(os.getenv("SESSION_TTL_SECONDS", "3600"))
if SESSION_TTL_SECONDS <= 0:
raise RuntimeError("SESSION_TTL_SECONDS должен быть положительным")
def issue_session(user_id):
token = secrets.token_urlsafe(32)
expires_ms = int(time.time() * 1000) + SESSION_TTL_SECONDS * 1000
redis_client.set("session:" + token, str(user_id), pxat=expires_ms)
expires_at = datetime.fromtimestamp(
expires_ms / 1000, timezone.utc
).isoformat(timespec="milliseconds").replace("+00:00", "Z")
return token, expires_at
+122
View File
@@ -0,0 +1,122 @@
import sys
import unittest
import uuid
from concurrent.futures import ThreadPoolExecutor
from pathlib import Path
from urllib.parse import quote
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT / "tests"))
from client import Client, timestamp
class ApiTests(unittest.TestCase):
def setUp(self):
self.c = Client()
self.alice, self.bob, self.eve, self.chat = self.c.bootstrap()
self.path = "/api/v1/chats/" + self.chat["id"]
def read_all(self, client, actor, path, limit=17):
items = []
cursor = None
seen = set()
for _ in range(1000):
url = path + "?limit=" + str(limit)
if cursor is not None:
url += "&cursor=" + quote(cursor, safe="")
page = client.call("GET", url, actor=actor, schema="MessagePage")["json"]
items.extend(page["items"])
cursor = page["next_cursor"]
if cursor is None:
return items
self.assertNotIn(cursor, seen, "cursor зациклился")
seen.add(cursor)
self.fail("Слишком много страниц")
def test_malformed_json(self):
result = self.c.call("POST", "/api/v1/users", 400,
raw=b'{"username":',
headers={"Content-Type": "application/json"})
self.assertEqual(result["json"]["error"]["code"], "invalid_request")
def test_foreign_chat(self):
self.c.call("GET", self.path, 404, actor=self.eve)
self.c.call("GET", self.path + "/messages", 404, actor=self.eve)
self.c.call("POST", self.path + "/messages", 404,
actor=self.eve, body={"text": "Чужой чат"})
page = self.c.call("GET", "/api/v1/chats", actor=self.eve,
schema="ChatPage")["json"]
self.assertNotIn(self.chat["id"], [item["id"] for item in page["items"]])
def test_empty_message(self):
for value in ("", " ", "\n\t"):
with self.subTest(text=repr(value)):
self.c.call("POST", self.path + "/messages", 400,
actor=self.alice, body={"text": value})
def test_duplicate_username(self):
self.c.call("POST", "/api/v1/users", 409,
body=self.alice["registration"])
def test_multiple_pages_and_cursor_scope(self):
expected = [self.c.message(self.alice, self.chat, "Страница " + str(i))["json"]
for i in range(7)]
actual = self.read_all(self.c, self.bob, self.path + "/messages", limit=2)
self.assertEqual(actual, sorted(expected, key=lambda x:
(timestamp(x["created_at"]), uuid.UUID(x["id"]).int)))
self.assertEqual(len({item["id"] for item in actual}), 7)
page = self.c.call("GET", self.path + "/messages?limit=1",
actor=self.alice, schema="MessagePage")["json"]
other = self.c.call("POST", "/api/v1/chats", 201, actor=self.alice,
body={"title": "Другой", "member_ids": [self.alice["id"]]},
schema="Chat")["json"]
self.c.call("GET", "/api/v1/chats/" + other["id"] + "/messages?cursor="
+ quote(page["next_cursor"], safe=""), 400, actor=self.alice)
def test_validation_and_auth(self):
for body in ({"text": 123}, {"text": "ok", "sender_id": self.bob["id"]},
{"text": "x" * 4001}):
self.c.call("POST", self.path + "/messages", 400,
actor=self.alice, body=body)
for limit in ("0", "101", "abc", "1.5"):
self.c.call("GET", self.path + "/messages?limit=" + limit,
400, actor=self.alice)
self.c.call("GET", self.path + "/messages?cursor=garbage", 400,
actor=self.alice)
self.c.call("GET", "/api/v1/users/me", 401)
self.c.call("GET", "/api/v1/users/me", 401,
headers={"X-User-Id": str(uuid.uuid4())})
self.c.call("POST", self.path + "/messages", 401, raw=b'{',
headers={"Content-Type": "application/json"})
self.c.call("POST", self.path + "/messages", 415, actor=self.alice,
raw=b'plain', headers={"Content-Type": "text/plain"})
for members in ([self.alice["id"], self.alice["id"]],
[self.bob["id"]], [self.alice["id"], str(uuid.uuid4())]):
self.c.call("POST", "/api/v1/chats", 400, actor=self.alice,
body={"title": "Неверный чат", "member_ids": members})
def test_concurrency_100_messages_10_clients(self):
# У каждого из 10 потоков свой HTTP-клиент и 10 последовательных POST.
def send_batch(worker):
client = Client()
sent = []
for i in range(10):
text = "worker=" + str(worker) + ";message=" + str(i)
sent.append(client.message(self.alice, self.chat, text)["json"])
return sent
with ThreadPoolExecutor(max_workers=10) as pool:
batches = list(pool.map(send_batch, range(10)))
sent = [item for batch in batches for item in batch]
actual = self.read_all(self.c, self.bob, self.path + "/messages")
self.assertEqual(len(sent), 100)
self.assertEqual(len(actual), 100)
self.assertEqual(len({item["id"] for item in actual}), 100)
self.assertEqual({item["id"] for item in actual}, {item["id"] for item in sent})
self.assertEqual({item["text"] for item in actual}, {item["text"] for item in sent})
self.assertTrue(all(item["sender_id"] == self.alice["id"] for item in actual))
print("PASS: 10 clients; 100 POST; 100 unique messages; IDs/text match")
if __name__ == "__main__":
unittest.main(verbosity=2)
+125
View File
@@ -0,0 +1,125 @@
"""HTTP + PostgreSQL checks; run inside api so its DB settings are available."""
import base64
import sys
import threading
import unittest
from concurrent.futures import ThreadPoolExecutor
from pathlib import Path
from uuid import uuid4
import psycopg
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT / "tests"))
sys.path.insert(0, str(ROOT))
from client import Client
from src.db import connection_kwargs
class Grade4Tests(unittest.TestCase):
def setUp(self):
self.c = Client()
def test_registration_race(self):
body = {"username": "race_" + uuid4().hex[:16],
"display_name": "Гонка регистрации", "password": "Example-password-123"}
barrier = threading.Barrier(4)
def register(_):
c = Client()
barrier.wait(timeout=10)
return c.call("POST", "/api/v1/users", [201, 409], body=body)["status"]
with ThreadPoolExecutor(max_workers=4) as workers:
statuses = list(workers.map(register, range(4)))
self.assertEqual(sorted(statuses), [201, 409, 409, 409])
with psycopg.connect(**connection_kwargs()) as conn:
row = conn.execute("SELECT count(*) AS n FROM users WHERE username=%s",
(body["username"],)).fetchone()
self.assertEqual(row["n"], 1)
def test_chat_rollback_after_unknown_member(self):
alice = self.c.user("rollback")
title = "rollback_" + uuid4().hex
with psycopg.connect(**connection_kwargs()) as conn:
before = conn.execute("SELECT count(*) AS n FROM chat_members WHERE user_id=%s",
(alice["id"],)).fetchone()["n"]
self.c.call("POST", "/api/v1/chats", 400, actor=alice,
body={"title": title, "member_ids": [alice["id"], str(uuid4())]})
with psycopg.connect(**connection_kwargs()) as conn:
self.assertEqual(conn.execute("SELECT count(*) AS n FROM chats WHERE title=%s",
(title,)).fetchone()["n"], 0)
after = conn.execute("SELECT count(*) AS n FROM chat_members WHERE user_id=%s",
(alice["id"],)).fetchone()["n"]
self.assertEqual(before, after)
def test_login_logout_and_legacy_header(self):
alice = self.c.user("sessions")
wrong = base64.b64encode(
(alice["registration"]["username"] + ":wrong-password-123").encode()
).decode()
self.c.call("POST", "/api/v1/auth/sessions", 401,
headers={"Authorization": "Basic " + wrong})
self.c.call("GET", "/api/v1/users/me", 401,
headers={"X-User-Id": alice["id"]})
me = self.c.call("GET", "/api/v1/users/me", actor=alice,
headers={"X-User-Id": str(uuid4())}, schema="User")["json"]
self.assertEqual(me["id"], alice["id"])
self.c.call("DELETE", "/api/v1/auth/sessions/current", 204, actor=alice)
self.c.call("GET", "/api/v1/users/me", 401, actor=alice)
self.c.call("DELETE", "/api/v1/auth/sessions/current", 401, actor=alice)
def test_unicode_password_with_colon_and_hash(self):
body = {"username": "utf_" + uuid4().hex[:16], "display_name": "Студент 👋",
"password": "Пароль:мандарин🍊123"}
user = self.c.call("POST", "/api/v1/users", 201, body=body, schema="User")["json"]
basic = base64.b64encode((body["username"] + ":" + body["password"]).encode()).decode()
session = self.c.call("POST", "/api/v1/auth/sessions", 201,
headers={"Authorization": "Basic " + basic}, schema="Session")["json"]
self.assertEqual(session["user"], user)
self.assertEqual(len(base64.urlsafe_b64decode(session["token"] + "=")), 32)
with psycopg.connect(**connection_kwargs()) as conn:
stored = conn.execute("SELECT password_hash FROM users WHERE id=%s",
(user["id"],)).fetchone()["password_hash"]
self.assertTrue(stored.startswith("$argon2id$"))
self.assertNotIn(body["password"], stored)
def test_equal_timestamp_pages(self):
alice, bob, _, chat = self.c.bootstrap()
ids = [uuid4() for _ in range(5)]
with psycopg.connect(**connection_kwargs()) as conn:
with conn.cursor() as cur:
cur.executemany(
"INSERT INTO messages (id,chat_id,sender_id,text,created_at) "
"VALUES (%s,%s,%s,%s,'2026-01-01T00:00:00Z')",
[(i, chat["id"], alice["id"], "Одинаковое время") for i in ids],
)
from urllib.parse import quote
found, cursor = [], None
for _ in range(6):
path = "/api/v1/chats/" + chat["id"] + "/messages?limit=2"
if cursor:
path += "&cursor=" + quote(cursor, safe="")
page = self.c.call("GET", path, actor=bob, schema="MessagePage")["json"]
found.extend(x["id"] for x in page["items"])
cursor = page["next_cursor"]
if cursor is None:
break
self.assertIsNone(cursor)
self.assertEqual(found, [str(i) for i in sorted(ids)])
def test_nul_in_persisted_fields_returns_400(self):
self.c.call("POST", "/api/v1/users", 400,
body={"username": "nul_" + uuid4().hex[:16], "display_name": "x\u0000y",
"password": "Example-password-123"})
alice = self.c.user("nul")
self.c.call("POST", "/api/v1/chats", 400, actor=alice,
body={"title": "x\u0000y", "member_ids": [alice["id"]]})
chat = self.c.call("POST", "/api/v1/chats", 201, actor=alice,
body={"title": "NUL check", "member_ids": [alice["id"]]}, schema="Chat")["json"]
self.c.call("POST", "/api/v1/chats/" + chat["id"] + "/messages", 400,
actor=alice, body={"text": "x\u0000y"})
if __name__ == "__main__":
unittest.main(verbosity=2)
+48
View File
@@ -0,0 +1,48 @@
"""Pure cursor checks: python -m unittest discover -s student-tests -p test_pagination.py."""
import importlib.util
import unittest
from datetime import datetime, timezone
from uuid import UUID
class PaginationTests(unittest.TestCase):
def setUp(self):
self.assertIsNotNone(
importlib.util.find_spec("src.pagination"),
"SQL pagination helper has not been implemented",
)
from src import pagination
from src.errors import ApiError
self.p = pagination
self.error = ApiError
def test_cursor_round_trip_and_scope(self):
item = {"id": "00000000-0000-4000-8000-000000000001",
"created_at": "2026-10-19T12:00:00.123456Z"}
cursor = self.p.encode_cursor("messages:chat-a", item)
limit, after = self.p.parse_page("17", cursor, "messages:chat-a")
self.assertEqual(limit, 17)
self.assertEqual(after, (datetime(2026, 10, 19, 12, 0, 0, 123456,
tzinfo=timezone.utc), UUID(item["id"])))
with self.assertRaises(self.error):
self.p.parse_page("17", cursor, "messages:chat-b")
def test_invalid_limits_and_cursors(self):
for value in ("0", "101", "1.5", "abc", "-1"):
with self.subTest(limit=value), self.assertRaises(self.error):
self.p.parse_page(value, None, "scope")
for value in ("", "garbage", "!!!!", "bnVsbA", "W10"):
with self.subTest(cursor=value), self.assertRaises(self.error):
self.p.parse_page("50", value, "scope")
self.assertEqual(self.p.parse_page("50", None, "scope"), (50, None))
def test_cursor_requires_complete_utc_datetime(self):
for timestamp in ("2026-01-01Z", "2026-01-01T00:00:00", "2026-01-01T00:00:00+03:00"):
item = {"id": "00000000-0000-4000-8000-000000000001", "created_at": timestamp}
cursor = self.p.encode_cursor("scope", item)
with self.subTest(timestamp=timestamp), self.assertRaises(self.error):
self.p.parse_page("50", cursor, "scope")
if __name__ == "__main__":
unittest.main(verbosity=2)