Compare commits
1
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
44b6ec1052 |
+3
-10
@@ -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
|
||||
|
||||
@@ -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
@@ -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"]
|
||||
@@ -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/
|
||||
|
||||
@@ -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:
|
||||
@@ -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. Эти результаты не гарантируют оценку.
|
||||
@@ -0,0 +1,2 @@
|
||||
.venv/bin/python scripts/check_contract.py
|
||||
PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.
|
||||
@@ -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.
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -0,0 +1,2 @@
|
||||
SKIP 01_initial.sql
|
||||
SKIP 02_chat_order.sql
|
||||
@@ -0,0 +1,2 @@
|
||||
APPLIED 01_initial.sql
|
||||
APPLIED 02_chat_order.sql
|
||||
@@ -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
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,2 @@
|
||||
Executing explicit persistence hook; hook output suppressed to avoid leaking secrets.
|
||||
PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.
|
||||
@@ -0,0 +1,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
|
||||
@@ -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
|
||||
@@ -0,0 +1 @@
|
||||
PASS: lab2 public API scenario; infrastructure and grading evidence remain separate.
|
||||
@@ -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
|
||||
@@ -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);
|
||||
@@ -0,0 +1 @@
|
||||
CREATE INDEX chats_order_idx ON chats (created_at, id);
|
||||
@@ -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
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
@@ -0,0 +1,4 @@
|
||||
@echo off
|
||||
cd /d "%~dp0.."
|
||||
python scripts\restart.py
|
||||
exit /b %errorlevel%
|
||||
@@ -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()
|
||||
Executable
+4
@@ -0,0 +1,4 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
cd "$(dirname "$0")/.."
|
||||
exec python3 scripts/restart.py
|
||||
@@ -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,
|
||||
)
|
||||
@@ -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
@@ -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)
|
||||
@@ -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()
|
||||
@@ -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
@@ -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,
|
||||
)
|
||||
@@ -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
|
||||
@@ -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)
|
||||
@@ -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)
|
||||
@@ -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)
|
||||
Reference in New Issue
Block a user