Compare commits

1 Commits
Author SHA1 Message Date
gonne 4ca90b0c47 лаба 2 готова
Skeleton contracts / contracts (pull_request) Canceled after 0s
2026-10-22 18:10:52 +03:00
65 changed files with 2399 additions and 37 deletions
+24 -14
View File
@@ -1,18 +1,28 @@
## Лабораторная 2
Автор / группа: TODO
Целевая оценка (3/4/5): TODO
Трек 5, если заявлен: TODO
Автор: Каменский Андрей Игоревич, БПИ2301.
Целевая оценка: 4. Трек на 5 не заявляю.
Что реализовано и что перенесено: TODO
Команды запуска из чистого clone: TODO
Результаты проверок и ссылка на REPORT.md: TODO
Ограничения / известные ошибки: TODO
Источники и использование ИИ: TODO
Из прошлой лабы оставил структуру роутеры → сервисы → репозитории, DTO на dataclass и проверки доступа. Данные перенёс из памяти в PostgreSQL через SQLAlchemy, добавил миграции Alembic. Пароли хешируются Argon2id, вход работает через Basic без тела, остальные запросы — через Bearer. Redis хранит сессии с TTL и кэширует профиль; AOF и volumes сохраняют состояние после обычного restart.
- [ ] Весь обязательный минимум текущей и предыдущих работ сохранён с объявленными переходами.
- [ ] Контракт и публичные тесты не ослаблены.
- [ ] make check и make test выполнены; приложен реальный вывод.
- [ ] Сценарии отказов/безопасности своего уровня воспроизведены.
- [ ] Все секреты и приватные ключи находятся вне Git; отчёт не содержит tokens.
- [ ] README задания сохранён, REPORT.md содержит инструкцию именно моего решения.
Для запуска нужно создать локальный `.env` по `compose.env.example` и задать POSTGRES_PASSWORD. Настройки запуска описаны в [REPORT.md](../REPORT.md).
```sh
docker compose up -d --build --wait
make check
make test
make test-persistence ACTION_SCRIPT=scripts/restart.sh
```
`make validate` требует установки requirements-dev.txt. Если 8080 занят, перед запуском нужно экспортировать APP_PORT и передать соответствующий BASE_URL публичным тестам. Миграции выполняет отдельный сервис до старта API.
Публичный smoke прошёл. Проверены restart с прежним токеном, короткий TTL, logout, отказы PostgreSQL/Redis, гонка регистрации, rollback, 100 конкурентных сообщений и индекс истории на 10000 сообщениях. Выводы лежат в evidence, происхождение результатов до переноса кода указано в [отчёте](../REPORT.md). Контракт и публичные тесты не менялись; дополнительные тестовые файлы из рабочего каталога не переносились.
Ограничения: один экземпляр каждого сервиса, локальный HTTP, нет HA, backup/restore и защиты от перебора. Production и оценка 5 не заявляются. В работе использованы библиотеки из requirements.txt и материалы задания. Изменения пока локальные, PR не опубликован.
- [x] Минимум прошлой лабы сохранён, переход с X-User-Id на Bearer описан.
- [x] Контракт и публичные тесты не ослаблены.
- [x] make check и make test выполнены; приложен реальный вывод.
- [x] Сценарии отказов своего уровня воспроизведены; условия и происхождение evidence указаны в отчёте.
- [x] Локальные секреты исключены из Git; в отчёте нет tokens и пароля PostgreSQL.
- [x] README задания сохранён, REPORT.md описывает мою реализацию.
+24
View File
@@ -0,0 +1,24 @@
FROM python:3.13.0-slim-bookworm
ENV PYTHONDONTWRITEBYTECODE=1 \
PYTHONUNBUFFERED=1
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt \
&& python -m pip uninstall --yes pip \
&& addgroup --system app \
&& adduser --system --ingroup app app
COPY --chown=app:app src ./src
COPY --chown=app:app migrations ./migrations
COPY --chown=app:app alembic.ini ./alembic.ini
USER app
EXPOSE 8080
HEALTHCHECK --interval=10s --timeout=3s --start-period=5s --retries=3 \
CMD python -c "import urllib.request; from src.core.settings import settings; urllib.request.urlopen(f'http://127.0.0.1:{settings.app_port}/health/ready', timeout=settings.healthcheck_timeout_seconds)"
CMD ["python", "-m", "src"]
+40 -23
View File
@@ -1,37 +1,54 @@
# Отчёт — лабораторная 2
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
Каменский Андрей Игоревич, БПИ2301. Целевая оценка — **4**, трек на 5 не выполнял. Изменения пока локальные, PR не создан.
## Запуск из чистого clone
## Запуск
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
Нужны Docker с Compose и Python 3.9+ для публичных проверок. Образы: Python 3.13.0, PostgreSQL 16.6, Redis 7.4.2; зависимости закреплены в requirements.txt.
## Архитектура и решения
```sh
cp compose.env.example .env
# В .env задать POSTGRES_PASSWORD.
docker compose up -d --build --wait
make check
make test
make test-persistence ACTION_SCRIPT=scripts/restart.sh
```
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
API и Swagger: http://localhost:8080/docs. Если порт занят, нужно экспортировать APP_PORT=8081 и передать тестам BASE_URL=http://localhost:8081. Миграции Alembic выполняет сервис migration до старта API. Повторный запуск миграций безопасен.
## Доказательства критериев
Для проверки OpenAPI: установить requirements-dev.txt и выполнить `make validate`. Остановка с сохранением данных — `docker compose down`; намеренный сброс учебных данных — `docker compose down --volumes`.
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
## Что сделал
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
Сохранил структуру прошлой лабы: роутеры → сервисы → репозитории, DTO на dataclass. Данные из памяти перенёс в PostgreSQL через SQLAlchemy. Таблицы users, chats, chat_members и messages имеют ключи, ограничения и индексы. Схема версионируется Alembic, текущая ревизия — 003. Чат и участники создаются одной транзакцией, COMMIT выполняется до ответа 201.
## Эксперименты и отказы
Пароли хешируются Argon2id. Вход — Basic без тела, остальные запросы — Bearer. Redis хранит сессии с абсолютным expiry и TTL, logout удаляет ключ. Профили кэшируются отдельно на 60 секунд; история читается из PostgreSQL. Сессии и данные переживают restart благодаря именованным volumes и Redis AOF с appendfsync always.
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
Настройки находятся в AppSettings. Пул PostgreSQL — 10 соединений без overflow, таймауты — 5 секунд; Redis — 10 соединений, connect/read timeout по 0.3 секунды. Секреты передаются через исключённый из Git .env. Исходный .env.example оставлен как в задании; для реализации используется compose.env.example.
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
## Проверки
## Ограничения и следующие шаги
Основные проверки сделаны до переноса кода из mtusi2026lab1; поэтому это имя встречается в логах. В новом репозитории отдельно прошли сборка и публичный smoke на 8081. Контракт и исходные тесты не менялись; дополнительные тестовые файлы не переносились.
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
| Проверка | Результат | Evidence |
| --- | --- | --- |
| `make check validate test` | Публичный сценарий пройден | [checks](evidence/lab2-checks.txt) |
| Полный restart API, PostgreSQL и Redis | StartedAt изменился у всех; прежний токен читает прежние данные | [persistence](evidence/lab2-persistence.txt) |
| Миграции с нуля, повтор upgrade и alembic check | Схема создаётся, повтор не меняет данные | [alembic](evidence/lab2-alembic.txt) |
| Rollback создания чата | FK-ошибка откатывает чат и участников | [database](evidence/lab2-database.txt) |
| 6 регистраций одного username | Один 201, пять 409 | [verification](evidence/lab2-verification.txt) |
| Неверный пароль, logout, TTL=2 | Отказ во входе; отозванный/истёкший токен получает 401 | [verification](evidence/lab2-verification.txt) |
| Кэш и отказы Redis/PostgreSQL | Профиль восстанавливается при промахе; при отказах — ограниченные 503 без обхода авторизации | [verification](evidence/lab2-verification.txt) |
| 10 клиентов × 10 сообщений | Прочитано 100 уникальных сообщений без потерь | [verification](evidence/lab2-verification.txt) |
| Некорректные поля, JSON и курсоры | Запросы отклоняются; чужие данные не раскрываются | [negative](evidence/lab2-negative.txt) |
## Индекс и ограничения
На 10000 сообщениях проверил глубокую страницу истории через EXPLAIN (ANALYZE, BUFFERS). Запрос использует курсор `(created_at,id)` и LIMIT, индекс — `(chat_id,created_at,id)`. PostgreSQL прочитал 51 строку для страницы из 50: Index Scan, shared hit=9, Execution Time=0.017 ms. Исследовательские данные откатил. Вывод — [database](evidence/lab2-database.txt).
Проверки выполнены на ARM64/macOS, Docker 28.5.1 и Compose 2.40.0. Docker доступно 10 CPU и около 7.65 GiB RAM; отдельных квот контейнерам не задавал. Это локальная функциональная проверка: RPS, p95/p99 и время восстановления отдельно не измерял.
Стенд учебный: один экземпляр каждого сервиса, локальный HTTP, нет HA, backup/restore и защиты от перебора. Потеря volumes не покрывается обычным restart. При недоступном Redis нельзя подтвердить сессию; без PostgreSQL недоступны чаты, но прогретый профиль может читаться из Redis. Между страницами нет общего snapshot, а запрос, авторизованный до logout, может завершиться.
Источники: задание, contracts/README.md, OpenAPI и документация FastAPI, SQLAlchemy, Alembic, Redis и argon2-cffi.
+3
View File
@@ -0,0 +1,3 @@
[alembic]
script_location = %(here)s/migrations
prepend_sys_path = .
+24
View File
@@ -0,0 +1,24 @@
APP_HOST=0.0.0.0
APP_PORT=8080
APP_ENV=lab
POSTGRES_DB=messenger
POSTGRES_USER=messenger
# Задай свой локальный пароль перед запуском. Не добавляй .env в Git.
POSTGRES_PASSWORD=
SESSION_TTL_SECONDS=3600
# REDIS_URL задаётся в compose.yaml; Redis хранит сессии с TTL и кэш профилей на 60 секунд.
LOG_LEVEL=INFO
# DATABASE_URL и REDIS_URL передаёт Compose. При ручном запуске задай их в окружении.
# Остальные параметры и значения по умолчанию: src/core/settings.py (AppSettings).
# Стартовый администратор; повторный запуск не меняет существующий пароль.
ADMIN_USERNAME=admin
ADMIN_PASSWORD=admin-password-123
ADMIN_DISPLAY_NAME=Администратор
# APP_ENV=production запрещает учебный ADMIN_PASSWORD. Пароль существующего
# администратора должен совпадать с настройкой; автоматического сброса нет.
# HTTP_MAX_BODY_BYTES=65536
# HTTP_BODY_TIMEOUT_SECONDS=5
# HTTP_CONCURRENCY_LIMIT=64
# PASSWORD_HASH_CONCURRENCY=2
+82
View File
@@ -0,0 +1,82 @@
x-logging: &logging
driver: json-file
options:
max-size: "10m"
max-file: "3"
x-app: &app
build: .
image: mtusi-messenger:lab2
env_file: ${ENV_FILE:-.env}
logging: *logging
services:
postgres:
logging: *logging
image: postgres:16.6-bookworm
environment:
POSTGRES_DB: ${POSTGRES_DB:-messenger}
POSTGRES_USER: ${POSTGRES_USER:-messenger}
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?Задай POSTGRES_PASSWORD в .env}
volumes:
- postgres_data:/var/lib/postgresql/data
healthcheck:
test: ["CMD-SHELL", "pg_isready -U $$POSTGRES_USER -d $$POSTGRES_DB"]
interval: 2s
timeout: 3s
retries: 30
redis:
logging: *logging
image: redis:7.4.2-bookworm
command: ["redis-server", "--appendonly", "yes", "--appendfsync", "always", "--maxmemory", "64mb", "--maxmemory-policy", "noeviction"]
volumes:
- redis_data:/data
healthcheck:
test: ["CMD", "redis-cli", "ping"]
interval: 2s
timeout: 3s
retries: 30
migration:
<<: *app
command: ["alembic", "upgrade", "head"]
environment:
REDIS_URL: &redis_url redis://redis:6379/0
DATABASE_URL: &database_url postgresql://${POSTGRES_USER:-messenger}:${POSTGRES_PASSWORD:?Задай POSTGRES_PASSWORD в .env}@postgres:5432/${POSTGRES_DB:-messenger}
depends_on:
postgres:
condition: service_healthy
healthcheck:
disable: true
api:
<<: *app
read_only: true
tmpfs:
- /tmp:rw,noexec,nosuid,size=16m
cap_drop: [ALL]
security_opt: ["no-new-privileges:true"]
environment:
APP_HOST: 0.0.0.0
APP_PORT: 8080
DATABASE_URL: *database_url
REDIS_URL: *redis_url
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
LOG_LEVEL: ${LOG_LEVEL:-INFO}
ports:
- "127.0.0.1:${APP_PORT:-8080}:8080"
depends_on:
migration:
condition: service_completed_successfully
redis:
condition: service_healthy
healthcheck:
interval: 2s
timeout: 3s
retries: 30
start_period: 10s
volumes:
redis_data:
postgres_data:
+10
View File
@@ -0,0 +1,10 @@
Дата проверки: 22 октября 2026.
Происхождение: рабочий каталог mtusi2026lab1, до переноса кода в mtusi2026lab2.
Это сохранённый фактический вывод, а не повторный прогон в новом репозитории.
Проверка Alembic с нуля: временная отдельная PostgreSQL database.
alembic upgrade head
alembic upgrade head
alembic check
No new upgrade operations detected.
PASS: upgrade с нуля, повтор upgrade и alembic check; временная БД удалена.
+6
View File
@@ -0,0 +1,6 @@
/Users/andrejkamenskij/PycharmProjects/mtusi2026lab1/.venv/bin/python scripts/check_contract.py
PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.
/Users/andrejkamenskij/PycharmProjects/mtusi2026lab1/.venv/bin/python scripts/validate_openapi.py
PASS: full OpenAPI 3.1 and JSON Schema validation; application NOT tested.
/Users/andrejkamenskij/PycharmProjects/mtusi2026lab1/.venv/bin/python tests/smoke.py --base-url "http://localhost:8081"
PASS: lab2 public API scenario; infrastructure and grading evidence remain separate.
+18
View File
@@ -0,0 +1,18 @@
Дата проверки: 22 октября 2026.
Происхождение: рабочий каталог mtusi2026lab1, до переноса кода в mtusi2026lab2.
Это сохранённый фактический вывод, а не повторный прогон в новом репозитории.
docker compose exec -T api python < tests/database.py
PASS: два повторных запуска миграций не изменили данные; версия 003 одна
PASS: ошибка участника откатила INSERT чата и участников
Сообщений в исследуемом чате: 10000
Limit (cost=0.29..26.66 rows=51 width=70) (actual time=0.004..0.010 rows=51 loops=1)
Buffers: shared hit=9
-> Index Scan using messages_history_idx on messages (cost=0.29..471.92 rows=912 width=70) (actual time=0.004..0.008 rows=51 loops=1)
Index Cond: ((chat_id = '8f42f6b3-9151-45a9-b570-7668b695b09d'::uuid) AND (ROW(created_at, id) > ROW('2026-10-22 14:27:06.975032+00'::timestamp with time zone, '9def9466-06c3-476a-a8c5-2a3a3c04fc80'::uuid)))
Buffers: shared hit=9
Planning:
Buffers: shared hit=7
Planning Time: 0.022 ms
Execution Time: 0.017 ms
PASS: индекс истории используется для глубокой страницы из 10000 сообщений
+11
View File
@@ -0,0 +1,11 @@
Дата проверки: 22 октября 2026.
Происхождение: рабочий каталог mtusi2026lab1, до переноса кода в mtusi2026lab2.
Это сохранённый фактический вывод, а не повторный прогон в новом репозитории.
.venv/bin/python tests/production.py --base-url "http://localhost:8080"
PASS: реальный chunked=413, два Authorization=401, no-store; 4000 emoji в escaped JSON допустимы
PASS: реальное незавершённое тело получает 408; health работает во время ожидания
PASS: SQL-пагинация 13 чатов по 3; курсор принадлежит пользователю, чужие чаты скрыты
PASS: пароль с Unicode, пробелами, двоеточием и NUL не усекается
PASS: независимые токены, конкурентные logout/GET, уникальные request_id
PASS: типы/диапазон курсора, Unicode, размер/формат JSON и повреждённый Redis
+10
View File
@@ -0,0 +1,10 @@
Дата проверки: 22 октября 2026.
Происхождение: рабочий каталог mtusi2026lab1, до переноса кода в mtusi2026lab2.
Это сохранённый фактический вывод, а не повторный прогон в новом репозитории.
.venv/bin/python scripts/test-persistence.py --action-script "scripts/restart.sh" --base-url "http://localhost:8080"
ДО: {"api": {"StartedAt": "2026-10-22T14:27:21.328594545Z", "Pid": 99295}, "postgres": {"StartedAt": "2026-10-22T14:27:06.325191927Z", "Pid": 98001}, "redis": {"StartedAt": "2026-10-22T14:27:03.042514467Z", "Pid": 97746}}
Executing explicit persistence hook; hook output suppressed to avoid leaking secrets.
PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.
ПОСЛЕ: {"api": {"StartedAt": "2026-10-22T14:27:30.551407466Z", "Pid": 830}, "postgres": {"StartedAt": "2026-10-22T14:27:27.694517839Z", "Pid": 448}, "redis": {"StartedAt": "2026-10-22T14:27:27.728625714Z", "Pid": 521}}
PASS: StartedAt изменился у API, PostgreSQL и Redis; прежний токен и данные сохранены
+132
View File
@@ -0,0 +1,132 @@
Дата проверки: 22 октября 2026.
Происхождение: рабочий каталог mtusi2026lab1, до переноса кода в mtusi2026lab2.
Это сохранённый фактический вывод, а не повторный прогон в новом репозитории.
.venv/bin/python tests/production.py --base-url "http://localhost:8080"
PASS: реальный chunked=413, два Authorization=401, no-store; 4000 emoji в escaped JSON допустимы
PASS: SQL-пагинация 13 чатов по 3; курсор принадлежит пользователю, чужие чаты скрыты
PASS: пароль с Unicode, пробелами, двоеточием и NUL не усекается
PASS: независимые токены, конкурентные logout/GET, уникальные request_id
PASS: типы/диапазон курсора, Unicode, размер/формат JSON и повреждённый Redis
docker compose exec -T api python < tests/production_limits.py
PASS: non-root, read-only rootfs, пустые capabilities, no-new-privileges; /tmp доступен
PASS: Content-Length/chunked/ложный размер, timeout, disconnect; слот всегда освобождается
PASS: перегрузка=503 в общем JSON, health доступен, отмена запроса не теряет слот
PASS: очередь Argon2 соблюдает лимит параллелизма; результаты не смешиваются
.venv/bin/python tests/smoke.py --base-url "http://localhost:8080"
PASS: lab2 public API scenario; infrastructure and grading evidence remain separate.
.venv/bin/python tests/regressions.py --base-url "http://localhost:8080"
PASS: обязательные пробельные строки, malformed JSON, типы/лишние поля, MIME 415, Basic без тела
PASS: 101 существующий участник отклонён; курсор сохраняет микросекунды и UUID-порядок, привязан к чату
PASS: исходный текст и его длина сохраняются без strip
PASS: null/повреждённый/чужой профиль заменяется из PostgreSQL с TTL; сессия работает
PASS: Swagger объявляет Basic для входа и Bearer для защищённых методов
.venv/bin/python tests/extra.py --base-url "http://localhost:8080"
{"результат": "ПРОЙДЕНО", "гонка_регистрации": "1 создан, 5 конфликтов", "unicode_пароль_и_logout_с_кэшем": "ПРОЙДЕНО", "параллельных_клиентов": 10, "создано_сообщений": 100, "уникальных_сообщений": 100}
docker compose exec -T api python < tests/passwords.py
PASS: только Argon2id, случайная соль, Unicode 128 символов, неверный пароль
PASS: повторный вход с Argon2id; сессии находятся в Redis; хеш пароля не изменяется
docker compose exec -T api python < tests/callbacks.py
PASS: стартовый администратор создан; повторные callbacks не дублируют и не меняют пароль
PASS: production не принимает старый пароль администратора при изменённой конфигурации
PASS: администратор входит через Basic, читает профиль через Bearer и выходит
PASS: callback не повышает права обычного пользователя с совпавшим username
PASS: ограничения username/password сохранены; is_admin нельзя передать при регистрации
docker compose exec -T api python < tests/settings.py
PASS: AppSettings читает .env, окружение имеет приоритет, URL скрыт в repr
PASS: Pydantic отклоняет неверные TTL, pool, timeout и недостаточную длину токена
PASS: production отвергает учебный пароль; ошибки конфигурации скрывают входные значения
.venv/bin/python tests/auth_logging.py --base-url "http://localhost:8080"
PASS: русские события входа/отказа/logout; пароли и токены не попали в логи
docker compose exec -T api python < tests/database.py
PASS: два повторных запуска миграций не изменили данные; версия 003 одна
PASS: ошибка участника откатила INSERT чата и участников
Сообщений в исследуемом чате: 10000
Limit (cost=0.29..26.66 rows=51 width=70) (actual time=0.004..0.010 rows=51 loops=1)
Buffers: shared hit=9
-> Index Scan using messages_history_idx on messages (cost=0.29..471.92 rows=912 width=70) (actual time=0.004..0.008 rows=51 loops=1)
Index Cond: ((chat_id = '8f42f6b3-9151-45a9-b570-7668b695b09d'::uuid) AND (ROW(created_at, id) > ROW('2026-10-22 14:27:06.975032+00'::timestamp with time zone, '9def9466-06c3-476a-a8c5-2a3a3c04fc80'::uuid)))
Buffers: shared hit=9
Planning:
Buffers: shared hit=7
Planning Time: 0.022 ms
Execution Time: 0.017 ms
PASS: индекс истории используется для глубокой страницы из 10000 сообщений
.venv/bin/python tests/dependencies.py --base-url "http://localhost:8080"
Container mtusi2026lab1-redis-1 Stopping
Container mtusi2026lab1-redis-1 Stopped
Container mtusi2026lab1-redis-1 Starting
Container mtusi2026lab1-redis-1 Started
Container mtusi2026lab1-redis-1 Waiting
Container mtusi2026lab1-redis-1 Healthy
Container mtusi2026lab1-redis-1 Restarting
Container mtusi2026lab1-redis-1 Started
Container mtusi2026lab1-redis-1 Running
Container mtusi2026lab1-redis-1 Waiting
Container mtusi2026lab1-redis-1 Healthy
Container mtusi2026lab1-postgres-1 Stopping
Container mtusi2026lab1-postgres-1 Stopped
Container mtusi2026lab1-postgres-1 Starting
Container mtusi2026lab1-postgres-1 Started
Container mtusi2026lab1-postgres-1 Waiting
Container mtusi2026lab1-postgres-1 Healthy
PASS: сессия хранится в Redis с TTL; чтение не продлевает срок
PASS: профиль кэшируется с TTL<=60; повторный GET даёт cache hit; потеря ключа восполняется
PASS: отсутствующая сессия не восстанавливается из профиля/БД; Redis — источник истины
PASS: Redis выключен; live=200, ready=503; проверка сессий недоступна, доступ не выдаётся
PASS: сессия сохранилась после перезапуска Redis
PASS: logout при отказе Redis возвращает 503; успешный отзыв переживает AOF-рестарт и не даёт доступ
PASS: PostgreSQL выключен; live=200, ready=503, чаты=503; действующая сессия и прогретый профиль доступны в Redis
PASS: после восстановления БД прежняя сессия снова работает
PYTHON=".venv/bin/python" scripts/test-expiry.sh
Container mtusi2026lab1-redis-1 Running
Container mtusi2026lab1-postgres-1 Running
Container mtusi2026lab1-api-1 Recreate
Container mtusi2026lab1-api-1 Recreated
Container mtusi2026lab1-postgres-1 Waiting
Container mtusi2026lab1-postgres-1 Healthy
Container mtusi2026lab1-migration-1 Starting
Container mtusi2026lab1-migration-1 Started
Container mtusi2026lab1-redis-1 Waiting
Container mtusi2026lab1-migration-1 Waiting
Container mtusi2026lab1-redis-1 Healthy
Container mtusi2026lab1-migration-1 Exited
Container mtusi2026lab1-api-1 Starting
Container mtusi2026lab1-api-1 Started
Container mtusi2026lab1-redis-1 Waiting
Container mtusi2026lab1-migration-1 Waiting
Container mtusi2026lab1-api-1 Waiting
Container mtusi2026lab1-postgres-1 Waiting
Container mtusi2026lab1-migration-1 Exited
Container mtusi2026lab1-redis-1 Healthy
Container mtusi2026lab1-postgres-1 Healthy
Container mtusi2026lab1-api-1 Healthy
PASS: действующая сессия стала 401 через 3 секунды при TTL=2
Container mtusi2026lab1-postgres-1 Running
Container mtusi2026lab1-redis-1 Running
Container mtusi2026lab1-api-1 Recreate
Container mtusi2026lab1-api-1 Recreated
Container mtusi2026lab1-postgres-1 Waiting
Container mtusi2026lab1-postgres-1 Healthy
Container mtusi2026lab1-migration-1 Starting
Container mtusi2026lab1-migration-1 Started
Container mtusi2026lab1-migration-1 Waiting
Container mtusi2026lab1-redis-1 Waiting
Container mtusi2026lab1-redis-1 Healthy
Container mtusi2026lab1-migration-1 Exited
Container mtusi2026lab1-api-1 Starting
Container mtusi2026lab1-api-1 Started
Container mtusi2026lab1-postgres-1 Waiting
Container mtusi2026lab1-redis-1 Waiting
Container mtusi2026lab1-migration-1 Waiting
Container mtusi2026lab1-api-1 Waiting
Container mtusi2026lab1-migration-1 Exited
Container mtusi2026lab1-postgres-1 Healthy
Container mtusi2026lab1-redis-1 Healthy
Container mtusi2026lab1-api-1 Healthy
.venv/bin/python scripts/test-persistence.py --action-script "scripts/restart.sh" --base-url "http://localhost:8080"
ДО: {"api": {"StartedAt": "2026-10-22T14:27:21.328594545Z", "Pid": 99295}, "postgres": {"StartedAt": "2026-10-22T14:27:06.325191927Z", "Pid": 98001}, "redis": {"StartedAt": "2026-10-22T14:27:03.042514467Z", "Pid": 97746}}
Executing explicit persistence hook; hook output suppressed to avoid leaking secrets.
PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.
ПОСЛЕ: {"api": {"StartedAt": "2026-10-22T14:27:30.551407466Z", "Pid": 830}, "postgres": {"StartedAt": "2026-10-22T14:27:27.694517839Z", "Pid": 448}, "redis": {"StartedAt": "2026-10-22T14:27:27.728625714Z", "Pid": 521}}
PASS: StartedAt изменился у API, PostgreSQL и Redis; прежний токен и данные сохранены
+34
View File
@@ -0,0 +1,34 @@
import asyncio
from alembic import context
from sqlalchemy import pool
from sqlalchemy.ext.asyncio import create_async_engine
from src.core.db.models import Base
from src.core.settings import settings
url = settings.sqlalchemy_database_url
target_metadata = Base.metadata
def run_migrations(connection):
context.configure(connection=connection, target_metadata=target_metadata, compare_type=True)
with context.begin_transaction():
context.run_migrations()
async def run_online():
engine = create_async_engine(url, poolclass=pool.NullPool)
try:
async with engine.connect() as connection:
await connection.run_sync(run_migrations)
finally:
await engine.dispose()
if context.is_offline_mode():
context.configure(url=url, target_metadata=target_metadata, literal_binds=True)
with context.begin_transaction():
context.run_migrations()
else:
asyncio.run(run_online())
+17
View File
@@ -0,0 +1,17 @@
"""${message}"""
from alembic import op
import sqlalchemy as sa
${imports if imports else ""}
revision = ${repr(up_revision)}
down_revision = ${repr(down_revision)}
branch_labels = ${repr(branch_labels)}
depends_on = ${repr(depends_on)}
def upgrade():
${upgrades if upgrades else "pass"}
def downgrade():
${downgrades if downgrades else "pass"}
+60
View File
@@ -0,0 +1,60 @@
"""Пользователи, чаты, участники, сообщения и сессии."""
from alembic import op
import sqlalchemy as sa
revision = '001'
down_revision = None
branch_labels = None
depends_on = None
def upgrade():
op.create_table(
'users',
sa.Column('id', sa.Uuid(), primary_key=True),
sa.Column('username', sa.String(32), nullable=False, unique=True),
sa.Column('display_name', sa.String(100), nullable=False),
sa.Column('password_hash', sa.Text(), nullable=False),
sa.Column('created_at', sa.DateTime(timezone=True), nullable=False),
sa.CheckConstraint("username ~ '^[a-z0-9_]{3,32}$'"),
sa.CheckConstraint('length(trim(display_name)) > 0'),
)
op.create_table(
'chats',
sa.Column('id', sa.Uuid(), primary_key=True),
sa.Column('title', sa.String(100), nullable=False),
sa.Column('created_at', sa.DateTime(timezone=True), nullable=False),
sa.CheckConstraint('length(trim(title)) > 0'),
)
op.create_table(
'chat_members',
sa.Column('chat_id', sa.Uuid(), sa.ForeignKey('chats.id', ondelete='CASCADE'), primary_key=True),
sa.Column('user_id', sa.Uuid(), sa.ForeignKey('users.id'), primary_key=True),
)
op.create_index('chat_members_user_idx', 'chat_members', ['user_id', 'chat_id'])
op.create_table(
'messages',
sa.Column('id', sa.Uuid(), primary_key=True),
sa.Column('chat_id', sa.Uuid(), sa.ForeignKey('chats.id'), nullable=False),
sa.Column('sender_id', sa.Uuid(), sa.ForeignKey('users.id'), nullable=False),
sa.Column('text', sa.String(4000), nullable=False),
sa.Column('created_at', sa.DateTime(timezone=True), nullable=False),
sa.ForeignKeyConstraint(['chat_id', 'sender_id'], ['chat_members.chat_id', 'chat_members.user_id']),
sa.CheckConstraint('length(trim(text)) > 0'),
)
op.create_index('messages_history_idx', 'messages', ['chat_id', 'created_at', 'id'])
op.create_table(
'sessions',
sa.Column('token_hash', sa.Text(), primary_key=True),
sa.Column('user_id', sa.Uuid(), sa.ForeignKey('users.id', ondelete='CASCADE'), nullable=False),
sa.Column('expires_at', sa.DateTime(timezone=True), nullable=False),
)
op.create_index('sessions_expiry_idx', 'sessions', ['expires_at'])
def downgrade():
op.drop_table('sessions')
op.drop_table('messages')
op.drop_table('chat_members')
op.drop_table('chats')
op.drop_table('users')
+22
View File
@@ -0,0 +1,22 @@
"""Сессии перенесены в Redis."""
from alembic import op
import sqlalchemy as sa
revision = '002'
down_revision = '001'
branch_labels = None
depends_on = None
def upgrade():
op.drop_table('sessions')
def downgrade():
op.create_table(
'sessions',
sa.Column('token_hash', sa.Text(), primary_key=True),
sa.Column('user_id', sa.Uuid(), sa.ForeignKey('users.id', ondelete='CASCADE'), nullable=False),
sa.Column('expires_at', sa.DateTime(timezone=True), nullable=False),
)
op.create_index('sessions_expiry_idx', 'sessions', ['expires_at'])
+16
View File
@@ -0,0 +1,16 @@
"""Признак системного администратора."""
from alembic import op
import sqlalchemy as sa
revision = '003'
down_revision = '002'
branch_labels = None
depends_on = None
def upgrade():
op.add_column('users', sa.Column('is_admin', sa.Boolean(), nullable=False, server_default=sa.false()))
def downgrade():
op.drop_column('users', 'is_admin')
+19
View File
@@ -0,0 +1,19 @@
annotated-doc==0.0.5
annotated-types==0.8.0
anyio==4.15.1
click==8.5.0
fastapi==0.141.1
h11==0.16.0
idna==3.20
pydantic==2.13.5
pydantic-core==2.46.5
starlette==1.7.0
typing-extensions==4.16.0
typing-inspection==0.4.4
uvicorn==0.53.0
asyncpg==0.30.0
redis==5.2.1
argon2-cffi==25.1.0
SQLAlchemy[asyncio]==2.0.44
alembic==1.17.0
pydantic-settings==2.15.0
+6
View File
@@ -0,0 +1,6 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
# --volumes не используется: PostgreSQL и сессии должны сохраниться.
docker compose --env-file "${ENV_FILE:-.env}" restart postgres redis
docker compose --env-file "${ENV_FILE:-.env}" up -d --wait --force-recreate api
View File
+13
View File
@@ -0,0 +1,13 @@
import uvicorn
from src.core.settings import settings
if __name__ == "__main__":
uvicorn.run(
"src.main:app",
host=settings.app_host,
port=settings.app_port,
workers=settings.app_workers,
log_level=settings.log_level.lower(),
timeout_graceful_shutdown=settings.shutdown_timeout_seconds,
)
View File
+106
View File
@@ -0,0 +1,106 @@
import base64
import binascii
import re
from typing import Annotated
from fastapi import Depends, Request
from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
from fastapi.security.http import HTTPBase, HTTPBasicCredentials
from sqlalchemy.ext.asyncio import AsyncSession
from src.core.db.session import get_db_session
from src.core.errors import ApiError
from src.core.settings import settings
from src.service.auth import AuthService
from src.service.chat import ChatService
from src.service.dto import UserDTO
from src.service.exceptions import InvalidSessionException
from src.service.message import MessageService
from src.service.user import UserService
bearer_scheme = HTTPBearer(
scheme_name="bearerAuth",
description="Вставьте токен из ответа на вход, без префикса Bearer.",
auto_error=False,
)
basic_scheme = HTTPBase(scheme="basic", scheme_name="basicAuth", auto_error=False)
async def get_basic_credentials(
request: Request,
credentials: Annotated[HTTPAuthorizationCredentials | None, Depends(basic_scheme)],
) -> HTTPBasicCredentials:
if await request.body():
raise ApiError(400, "invalid_request", "Вход не принимает тело запроса")
try:
authorization = request.headers.getlist("authorization")
if len(authorization) != 1 or len(authorization[0]) > settings.authorization_max_length:
raise ValueError
if credentials is None or credentials.scheme.lower() != "basic":
raise ValueError
decoded = base64.b64decode(credentials.credentials, validate=True).decode("utf-8")
username, separator, password = decoded.partition(":")
if (
not separator
or re.fullmatch(r"[a-z0-9_]{3,32}", username) is None
or not 12 <= len(password) <= 128
or not password.strip()
):
raise ValueError
except (ValueError, UnicodeError, binascii.Error):
raise ApiError(401, "unauthorized", "Неверный логин или пароль") from None
return HTTPBasicCredentials(username=username, password=password)
def get_user_service(
db_session: Annotated[AsyncSession, Depends(get_db_session, scope="function")],
) -> UserService:
return UserService(db_session=db_session)
def get_chat_service(
db_session: Annotated[AsyncSession, Depends(get_db_session, scope="function")],
) -> ChatService:
return ChatService(db_session=db_session)
def get_message_service(
db_session: Annotated[AsyncSession, Depends(get_db_session, scope="function")],
) -> MessageService:
return MessageService(db_session=db_session)
def get_auth_service(
db_session: Annotated[AsyncSession, Depends(get_db_session, scope="function")],
) -> AuthService:
return AuthService(
db_session=db_session,
session_ttl_seconds=settings.session_ttl_seconds,
)
def get_bearer_token(
request: Request,
credentials: Annotated[HTTPAuthorizationCredentials | None, Depends(bearer_scheme)],
) -> str:
if credentials is None or len(request.headers.getlist("authorization")) != 1:
raise ApiError(401, "unauthorized", "Требуется Bearer-токен")
token = credentials.credentials
if (
credentials.scheme.lower() != "bearer"
or not token
or len(token) > 512
or any(c.isspace() for c in token)
):
raise ApiError(401, "unauthorized", "Требуется Bearer-токен")
return token
async def get_current_user(
auth: Annotated[AuthService, Depends(get_auth_service)],
token: Annotated[str, Depends(get_bearer_token)],
) -> UserDTO:
try:
return await auth.get_user(token=token)
except InvalidSessionException as error:
raise ApiError(401, "unauthorized", str(error)) from error
+14
View File
@@ -0,0 +1,14 @@
from fastapi import APIRouter
from src.api.v1.routers.auth.router import router as auth_router
from src.api.v1.routers.chats.router import router as chats_router
from src.api.v1.routers.messages.router import router as messages_router
from src.api.v1.routers.users.router import router as users_router
router = APIRouter(prefix="/api/v1", tags=["Версия 1"])
router.include_router(users_router)
router.include_router(chats_router)
router.include_router(messages_router)
router.include_router(auth_router)
View File
View File
View File
+31
View File
@@ -0,0 +1,31 @@
import logging
from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
from src.core.db.repo.auth import fetch_user_credentials
from src.core.security import verify_password_async
from src.core.settings import settings
from src.service.user import UserService
logger = logging.getLogger(__name__)
async def create_admin(session_factory: async_sessionmaker[AsyncSession]) -> None:
async with session_factory.begin() as session:
admin = await UserService(db_session=session).create_admin(
username=settings.admin_username,
display_name=settings.admin_display_name,
password=settings.admin_password.get_secret_value(),
)
if admin is None and settings.app_env == "production":
credentials = await fetch_user_credentials(session, settings.admin_username)
if credentials is None or not await verify_password_async(
settings.admin_password.get_secret_value(), credentials.password_hash
):
raise RuntimeError(
"Пароль существующего администратора не совпадает с настройкой production"
)
if admin is None:
logger.info("Администратор уже существует")
else:
logger.info("Администратор создан: пользователь=%s", admin.id)
+50
View File
@@ -0,0 +1,50 @@
from dataclasses import asdict
from typing import Annotated
from fastapi import APIRouter, Depends, Response
from fastapi.security import HTTPBasicCredentials
from src.api.dependencies import (
get_auth_service,
get_basic_credentials,
get_bearer_token,
get_current_user,
)
from src.api.v1.routers.auth.schemas import SessionOut
from src.api.v1.routers.users.schemas import UserOut
from src.core.errors import ApiError
from src.service.auth import AuthService
from src.service.dto import UserDTO
from src.service.exceptions import InvalidCredentialsException
router = APIRouter(prefix="/auth/sessions", tags=["Сессии"])
@router.post("", status_code=201, response_model=SessionOut)
async def login(
credentials: Annotated[HTTPBasicCredentials, Depends(get_basic_credentials)],
auth: Annotated[AuthService, Depends(get_auth_service)],
) -> SessionOut:
try:
result = await auth.login(
username=credentials.username,
password=credentials.password,
)
except InvalidCredentialsException as error:
raise ApiError(401, "unauthorized", str(error)) from error
return SessionOut(
token=result.token,
token_type=result.token_type,
expires_at=result.expires_at,
user=UserOut(**asdict(result.user)),
)
@router.delete("/current", status_code=204)
async def logout(
current_user: Annotated[UserDTO, Depends(get_current_user)],
token: Annotated[str, Depends(get_bearer_token)],
auth: Annotated[AuthService, Depends(get_auth_service)],
) -> Response:
await auth.logout(token=token)
return Response(status_code=204)
+13
View File
@@ -0,0 +1,13 @@
from datetime import datetime
from typing import Literal
from pydantic import BaseModel
from src.api.v1.routers.users.schemas import UserOut
class SessionOut(BaseModel):
token: str
token_type: Literal["Bearer"]
expires_at: datetime
user: UserOut
+86
View File
@@ -0,0 +1,86 @@
from typing import Annotated
from uuid import UUID
from fastapi import APIRouter, Depends, Query, status
from src.api.dependencies import get_chat_service, get_current_user
from src.api.v1.routers.chats.schemas import ChatOut, CreateChatIn, GetChatOut
from src.api.v1.schemas import PaginationQuery
from src.core.errors import ApiError
from src.core.pagination import decode_cursor, encode_cursor
from src.service.chat import ChatService
from src.service.dto import ChatDTO, UserDTO
from src.service.exceptions import ChatNotFoundException, InvalidChatMembersException
router = APIRouter(prefix="/chats", tags=["Чаты"])
def _to_chat_out(chat: ChatDTO) -> ChatOut:
return ChatOut(
id=chat.id,
title=chat.title,
member_ids=list(chat.member_ids),
created_at=chat.created_at,
)
@router.post("", status_code=status.HTTP_201_CREATED)
async def create_chat(
chat_in: CreateChatIn,
current_user: Annotated[UserDTO, Depends(get_current_user)],
chat_service: Annotated[ChatService, Depends(get_chat_service)],
) -> ChatOut:
try:
chat = await chat_service.create_chat(
title=chat_in.title,
member_ids=chat_in.member_ids,
current_user_id=current_user.id,
)
except InvalidChatMembersException as error:
raise ApiError(400, "invalid_request", str(error)) from error
return _to_chat_out(chat)
@router.get("", status_code=status.HTTP_200_OK)
async def get_chats(
pagination: Annotated[PaginationQuery, Query()],
current_user: Annotated[UserDTO, Depends(get_current_user)],
chat_service: Annotated[ChatService, Depends(get_chat_service)],
) -> GetChatOut:
after = None
if pagination.cursor is not None:
after = decode_cursor(
pagination.cursor,
expected_kind="chats",
expected_owner_id=current_user.id,
)
chats = await chat_service.get_chats(
current_user_id=current_user.id, limit=pagination.limit + 1, after=after
)
page = chats[: pagination.limit]
next_cursor = None
if len(chats) > pagination.limit:
last = page[-1]
next_cursor = encode_cursor("chats", current_user.id, last.created_at, last.id)
return GetChatOut(
items=[_to_chat_out(chat) for chat in page],
next_cursor=next_cursor,
)
@router.get("/{chat_id}", summary="Получить доступный чат")
async def get_chat(
chat_id: UUID,
current_user: Annotated[UserDTO, Depends(get_current_user)],
chat_service: Annotated[ChatService, Depends(get_chat_service)],
) -> ChatOut:
try:
chat = await chat_service.get_chat(
chat_id=chat_id,
current_user_id=current_user.id,
)
except ChatNotFoundException as error:
raise ApiError(404, "not_found", str(error)) from error
return _to_chat_out(chat)
+43
View File
@@ -0,0 +1,43 @@
from datetime import datetime
from uuid import UUID
from pydantic import BaseModel, ConfigDict, Field, field_validator
class CreateChatIn(BaseModel):
model_config = ConfigDict(extra="forbid")
title: str = Field(min_length=1, max_length=100)
member_ids: list[UUID] = Field(min_length=1, max_length=100)
@field_validator("title")
@classmethod
def title_must_not_be_blank(cls, value: str) -> str:
if "\x00" in value:
raise ValueError("title не может содержать NUL")
if not value.strip():
raise ValueError("title не может состоять только из пробелов")
return value
@field_validator("member_ids")
@classmethod
def member_ids_must_be_unique(cls, value: list[UUID]) -> list[UUID]:
if len(value) != len(set(value)):
raise ValueError("member_ids не должен содержать дубликаты")
return value
class ChatOut(BaseModel):
model_config = ConfigDict(extra="forbid")
id: UUID
title: str
member_ids: list[UUID]
created_at: datetime
class GetChatOut(BaseModel):
model_config = ConfigDict(extra="forbid")
items: list[ChatOut]
next_cursor: str | None
+83
View File
@@ -0,0 +1,83 @@
from typing import Annotated
from uuid import UUID
from fastapi import APIRouter, Depends, Query, status
from src.api.dependencies import get_current_user, get_message_service
from src.api.v1.routers.messages.schemas import (
CreateMessageIn,
MessageOut,
MessagePageOut,
)
from src.api.v1.schemas import PaginationQuery
from src.core.errors import ApiError
from src.core.pagination import decode_cursor, encode_cursor
from src.service.dto import MessageDTO, UserDTO
from src.service.exceptions import ChatNotFoundException
from src.service.message import MessageService
router = APIRouter(prefix="/chats", tags=["Сообщения"])
def _to_message_out(message: MessageDTO) -> MessageOut:
return MessageOut(
id=message.id,
chat_id=message.chat_id,
sender_id=message.sender_id,
text=message.text,
created_at=message.created_at,
)
@router.post("/{chat_id}/messages", status_code=status.HTTP_201_CREATED)
async def create_message(
chat_id: UUID,
message_in: CreateMessageIn,
current_user: Annotated[UserDTO, Depends(get_current_user)],
message_service: Annotated[MessageService, Depends(get_message_service)],
) -> MessageOut:
try:
message = await message_service.create_message(
chat_id=chat_id,
sender_id=current_user.id,
text=message_in.text,
)
except ChatNotFoundException as error:
raise ApiError(404, "not_found", str(error)) from error
return _to_message_out(message)
@router.get("/{chat_id}/messages", status_code=status.HTTP_200_OK)
async def get_messages(
chat_id: UUID,
pagination: Annotated[PaginationQuery, Query()],
current_user: Annotated[UserDTO, Depends(get_current_user)],
message_service: Annotated[MessageService, Depends(get_message_service)],
) -> MessagePageOut:
after = None
if pagination.cursor is not None:
after = decode_cursor(
pagination.cursor,
expected_kind="messages",
expected_owner_id=chat_id,
)
try:
messages = await message_service.get_messages(
chat_id=chat_id,
current_user_id=current_user.id,
limit=pagination.limit + 1,
after=after,
)
except ChatNotFoundException as error:
raise ApiError(404, "not_found", str(error)) from error
page = messages[: pagination.limit]
next_cursor = None
if len(messages) > pagination.limit:
last = page[-1]
next_cursor = encode_cursor("messages", chat_id, last.created_at, last.id)
return MessagePageOut(
items=[_to_message_out(message) for message in page],
next_cursor=next_cursor,
)
+36
View File
@@ -0,0 +1,36 @@
from datetime import datetime
from uuid import UUID
from pydantic import BaseModel, ConfigDict, Field, field_validator
class CreateMessageIn(BaseModel):
model_config = ConfigDict(extra="forbid")
text: str = Field(min_length=1, max_length=4000)
@field_validator("text")
@classmethod
def text_must_not_be_blank(cls, value: str) -> str:
if "\x00" in value:
raise ValueError("text не может содержать NUL")
if not value.strip():
raise ValueError("text не может состоять только из пробелов")
return value
class MessageOut(BaseModel):
model_config = ConfigDict(extra="forbid")
id: UUID
chat_id: UUID
sender_id: UUID
text: str
created_at: datetime
class MessagePageOut(BaseModel):
model_config = ConfigDict(extra="forbid")
items: list[MessageOut]
next_cursor: str | None
+44
View File
@@ -0,0 +1,44 @@
from typing import Annotated
from fastapi import APIRouter, Depends, status
from src.api.dependencies import get_current_user, get_user_service
from src.api.v1.routers.users.schemas import CreateUserIn, UserOut
from src.core.errors import ApiError
from src.service.dto import UserDTO
from src.service.exceptions import UserAlreadyExistsException
from src.service.user import UserService
router = APIRouter(prefix="/users", tags=["Пользователи"])
def _to_user_out(user: UserDTO) -> UserOut:
return UserOut(
id=user.id,
username=user.username,
display_name=user.display_name,
created_at=user.created_at,
)
@router.post("", status_code=status.HTTP_201_CREATED)
async def create_user(
user_in: CreateUserIn,
user_service: Annotated[UserService, Depends(get_user_service)],
) -> UserOut:
try:
user = await user_service.create_user(
password=user_in.password,
username=user_in.username,
display_name=user_in.display_name,
)
except UserAlreadyExistsException as error:
raise ApiError(409, "conflict", str(error)) from error
return _to_user_out(user)
@router.get("/me", status_code=status.HTTP_200_OK)
async def get_me(
current_user: Annotated[UserDTO, Depends(get_current_user)],
) -> UserOut:
return _to_user_out(current_user)
+35
View File
@@ -0,0 +1,35 @@
from datetime import datetime
from uuid import UUID
from pydantic import BaseModel, ConfigDict, Field, field_validator
class CreateUserIn(BaseModel):
model_config = ConfigDict(extra="forbid")
username: str = Field(pattern=r"^[a-z0-9_]{3,32}$")
password: str = Field(min_length=12, max_length=128)
display_name: str = Field(min_length=1, max_length=100)
@field_validator("display_name", "password")
@classmethod
def required_string_must_not_be_blank(cls, value: str) -> str:
if not value.strip():
raise ValueError("Обязательная строка не может состоять только из пробелов")
return value
@field_validator("display_name")
@classmethod
def display_name_must_not_contain_nul(cls, value: str) -> str:
if "\x00" in value:
raise ValueError("display_name не может содержать NUL")
return value
class UserOut(BaseModel):
model_config = ConfigDict(extra="forbid")
id: UUID
username: str
display_name: str
created_at: datetime
+10
View File
@@ -0,0 +1,10 @@
from pydantic import BaseModel, ConfigDict, Field
from src.core.settings import settings
class PaginationQuery(BaseModel):
model_config = ConfigDict(extra="forbid")
limit: int = Field(default=50, ge=1, le=100)
cursor: str | None = Field(default=None, min_length=1, max_length=settings.cursor_max_length)
View File
+68
View File
@@ -0,0 +1,68 @@
"""Клиент Redis и необязательный кэш профилей пользователей."""
import logging
from redis.asyncio import Redis
from redis.exceptions import RedisError
from src.core.settings import settings
logger = logging.getLogger(__name__)
cache: Redis | None = None
def open_cache():
global cache
cache = Redis.from_url(
settings.redis_url.get_secret_value(),
decode_responses=True,
max_connections=settings.redis_max_connections,
socket_connect_timeout=settings.redis_connect_timeout_seconds,
socket_timeout=settings.redis_read_timeout_seconds,
retry_on_timeout=settings.redis_retry_on_timeout,
)
async def close_cache():
global cache
if cache is not None:
await cache.aclose()
cache = None
async def get(key: str) -> str | None:
if cache is None:
return None
try:
return await cache.get(key)
except UnicodeError:
logger.warning("Повреждённый UTF-8 в кэше профиля; читаем PostgreSQL")
await delete(key)
return None
except (RedisError, OSError):
logger.warning("Redis недоступен; читаем профиль из PostgreSQL")
return None
async def set(key: str, value: str):
if cache is None:
return
try:
await cache.set(key, value, ex=settings.profile_cache_ttl_seconds)
except (RedisError, OSError):
logger.warning("Redis недоступен; пропускаем запись кэша")
async def delete(key: str) -> None:
if cache is None:
return
try:
await cache.delete(key)
except (RedisError, OSError):
logger.warning("Redis недоступен; пропускаем удаление кэша профиля")
def get_client() -> Redis:
if cache is None:
raise RedisError("Клиент Redis не настроен")
return cache
+20
View File
@@ -0,0 +1,20 @@
from collections.abc import AsyncIterator
from contextlib import asynccontextmanager
from fastapi import FastAPI
from src.api.v1.routers.auth.callback import create_admin
from src.core.db import session as database
STARTUP_CALLBACKS = (create_admin,)
@asynccontextmanager
async def lifespan(app: FastAPI) -> AsyncIterator[None]:
async with database.database_lifespan(app):
session_factory = database.session_factory
if session_factory is None:
raise RuntimeError("Фабрика сессий не запущена")
for callback in STARTUP_CALLBACKS:
await callback(session_factory)
yield
View File
+71
View File
@@ -0,0 +1,71 @@
from datetime import datetime
from uuid import UUID
from sqlalchemy import (
Boolean,
CheckConstraint,
DateTime,
ForeignKey,
ForeignKeyConstraint,
Index,
String,
Text,
false,
)
from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column, relationship
class Base(DeclarativeBase):
pass
class User(Base):
__tablename__ = "users"
__table_args__ = (
CheckConstraint("username ~ '^[a-z0-9_]{3,32}$'"),
CheckConstraint("length(trim(display_name)) > 0"),
)
id: Mapped[UUID] = mapped_column(primary_key=True)
username: Mapped[str] = mapped_column(String(32), unique=True)
display_name: Mapped[str] = mapped_column(String(100))
password_hash: Mapped[str] = mapped_column(Text)
is_admin: Mapped[bool] = mapped_column(Boolean, default=False, server_default=false())
created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True))
class Chat(Base):
__tablename__ = "chats"
__table_args__ = (CheckConstraint("length(trim(title)) > 0"),)
id: Mapped[UUID] = mapped_column(primary_key=True)
title: Mapped[str] = mapped_column(String(100))
created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True))
members: Mapped[list["ChatMember"]] = relationship(order_by="ChatMember.user_id")
class ChatMember(Base):
__tablename__ = "chat_members"
__table_args__ = (Index("chat_members_user_idx", "user_id", "chat_id"),)
chat_id: Mapped[UUID] = mapped_column(
ForeignKey("chats.id", ondelete="CASCADE"), primary_key=True
)
user_id: Mapped[UUID] = mapped_column(ForeignKey("users.id"), primary_key=True)
class Message(Base):
__tablename__ = "messages"
__table_args__ = (
ForeignKeyConstraint(
["chat_id", "sender_id"], ["chat_members.chat_id", "chat_members.user_id"]
),
CheckConstraint("length(trim(text)) > 0"),
Index("messages_history_idx", "chat_id", "created_at", "id"),
)
id: Mapped[UUID] = mapped_column(primary_key=True)
chat_id: Mapped[UUID] = mapped_column(ForeignKey("chats.id"))
sender_id: Mapped[UUID] = mapped_column(ForeignKey("users.id"))
text: Mapped[str] = mapped_column(String(4000))
created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True))
View File
+16
View File
@@ -0,0 +1,16 @@
from sqlalchemy import select
from sqlalchemy.ext.asyncio import AsyncSession
from src.core.db.models import User
from src.core.db.repo.user import to_user
from src.service.dto import UserCredentialsDTO
async def fetch_user_credentials(
session: AsyncSession,
username: str,
) -> UserCredentialsDTO | None:
user = await session.scalar(select(User).where(User.username == username))
if user is None:
return None
return UserCredentialsDTO(user=to_user(user), password_hash=user.password_hash)
+59
View File
@@ -0,0 +1,59 @@
from datetime import datetime
from uuid import UUID
from sqlalchemy import select, tuple_
from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy.orm import selectinload
from src.core.db.models import Chat, ChatMember
from src.service.dto import ChatDTO
def to_chat(chat: Chat) -> ChatDTO:
return ChatDTO(
chat.id, chat.title, tuple(member.user_id for member in chat.members), chat.created_at
)
async def fetch_chat_by_id(session: AsyncSession, chat_id: UUID) -> ChatDTO | None:
chat = await session.scalar(
select(Chat).options(selectinload(Chat.members)).where(Chat.id == chat_id),
)
return to_chat(chat) if chat else None
async def fetch_chats(
session: AsyncSession,
user_id: UUID,
limit: int,
after: tuple[datetime, UUID] | None = None,
) -> list[ChatDTO]:
query = (
select(Chat)
.options(selectinload(Chat.members))
.join(ChatMember)
.where(ChatMember.user_id == user_id)
)
if after is not None:
query = query.where(tuple_(Chat.created_at, Chat.id) > after)
chats = await session.scalars(query.order_by(Chat.created_at, Chat.id).limit(limit))
return [to_chat(chat) for chat in chats]
async def create_chat(
session: AsyncSession,
chat_id: UUID,
title: str,
member_ids: list[UUID],
created_at: datetime,
) -> ChatDTO:
chat = Chat(
id=chat_id,
title=title,
created_at=created_at,
members=[ChatMember(user_id=user_id) for user_id in member_ids],
)
session.add(chat)
# ORM сохраняет чат и участников в транзакции текущего запроса.
await session.flush()
return to_chat(chat)
+47
View File
@@ -0,0 +1,47 @@
from datetime import datetime
from uuid import UUID
from sqlalchemy import select, tuple_
from sqlalchemy.ext.asyncio import AsyncSession
from src.core.db.models import Message
from src.service.dto import MessageDTO
def to_message(message: Message) -> MessageDTO:
return MessageDTO(
message.id, message.chat_id, message.sender_id, message.text, message.created_at
)
def history_query(chat_id: UUID, limit: int, after: tuple[datetime, UUID] | None = None):
query = select(Message).where(Message.chat_id == chat_id)
if after is not None:
query = query.where(tuple_(Message.created_at, Message.id) > after)
return query.order_by(Message.created_at, Message.id).limit(limit)
async def fetch_messages_by_chat_id(
session: AsyncSession,
chat_id: UUID,
limit: int,
after: tuple[datetime, UUID] | None = None,
) -> list[MessageDTO]:
messages = await session.scalars(history_query(chat_id, limit, after))
return [to_message(message) for message in messages]
async def create_message(
session: AsyncSession,
message_id: UUID,
chat_id: UUID,
sender_id: UUID,
text: str,
created_at: datetime,
) -> MessageDTO:
message = Message(
id=message_id, chat_id=chat_id, sender_id=sender_id, text=text, created_at=created_at
)
session.add(message)
await session.flush()
return to_message(message)
+116
View File
@@ -0,0 +1,116 @@
import json
import re
from dataclasses import asdict
from datetime import datetime
from uuid import UUID
from sqlalchemy import func, select
from sqlalchemy.dialects.postgresql import insert
from sqlalchemy.ext.asyncio import AsyncSession
from src.core import cache
from src.core.db.models import User
from src.service.dto import UserDTO
def to_user(user: User) -> UserDTO:
return UserDTO(user.id, user.username, user.display_name, user.created_at)
async def fetch_user_by_id(session: AsyncSession, user_id: UUID) -> UserDTO | None:
key = f"user:v1:{user_id}"
cached = await cache.get(key)
if cached is not None:
try:
data = json.loads(cached)
if (
not isinstance(data, dict)
or set(data) != {"id", "username", "display_name", "created_at"}
or not all(isinstance(value, str) for value in data.values())
):
raise ValueError
user = UserDTO(
UUID(data["id"]),
data["username"],
data["display_name"],
datetime.fromisoformat(data["created_at"]),
)
if (
user.id != user_id
or re.fullmatch(r"[a-z0-9_]{3,32}", user.username) is None
or not 1 <= len(user.display_name) <= 100
or not user.display_name.strip()
or user.created_at.tzinfo is None
):
raise ValueError
return user
except (ValueError, KeyError, TypeError):
await cache.delete(key)
model = await session.get(User, user_id)
user = to_user(model) if model else None
if user:
await cache.set(key, json.dumps(asdict(user), default=str))
return user
async def fetch_user_by_username(session: AsyncSession, username: str) -> UserDTO | None:
model = await session.scalar(select(User).where(User.username == username))
return to_user(model) if model else None
async def create_user(
session: AsyncSession,
user_id: UUID,
username: str,
display_name: str,
created_at: datetime,
password_hash: str,
) -> UserDTO:
user = User(
id=user_id,
username=username,
display_name=display_name,
created_at=created_at,
password_hash=password_hash,
)
session.add(user)
await session.flush()
return to_user(user)
async def users_exist(session: AsyncSession, user_ids: list[UUID]) -> bool:
count = await session.scalar(
select(func.count()).select_from(User).where(User.id.in_(user_ids))
)
return count == len(user_ids)
async def create_admin(
session: AsyncSession,
user_id: UUID,
username: str,
display_name: str,
password_hash: str,
created_at: datetime,
) -> UserDTO | None:
user = await session.scalar(
insert(User)
.values(
id=user_id,
username=username,
display_name=display_name,
password_hash=password_hash,
created_at=created_at,
is_admin=True,
)
.on_conflict_do_nothing(index_elements=[User.username])
.returning(User)
)
return to_user(user) if user else None
async def admin_exists(session: AsyncSession, username: str) -> bool:
user_id = await session.scalar(
select(User.id).where(User.username == username, User.is_admin.is_(True))
)
return user_id is not None
+48
View File
@@ -0,0 +1,48 @@
from contextlib import asynccontextmanager
from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
from src.core.cache import close_cache, open_cache
from src.core.settings import settings
session_factory: async_sessionmaker[AsyncSession] | None = None
def create_engine():
return create_async_engine(
settings.sqlalchemy_database_url,
pool_size=settings.database_pool_size,
max_overflow=settings.database_max_overflow,
pool_timeout=settings.database_pool_timeout_seconds,
pool_pre_ping=settings.database_pool_pre_ping,
hide_parameters=True,
connect_args={
"timeout": settings.database_connect_timeout_seconds,
"command_timeout": settings.database_command_timeout_seconds,
"server_settings": {"statement_timeout": str(settings.database_statement_timeout_ms)},
},
)
@asynccontextmanager
async def database_lifespan(app):
global session_factory
engine = create_engine()
session_factory = async_sessionmaker(engine, expire_on_commit=False)
open_cache()
try:
yield
finally:
await close_cache()
await engine.dispose()
session_factory = None
async def get_db_session():
if session_factory is None:
raise RuntimeError("Фабрика сессий не запущена")
async with session_factory() as session:
# Одна транзакция на запрос: аутентификация и бизнес-операция вместе.
# Depends(scope='function') завершает COMMIT до отправки ответа.
async with session.begin():
yield session
+29
View File
@@ -0,0 +1,29 @@
from fastapi import Request
from fastapi.responses import JSONResponse
class ApiError(Exception):
def __init__(self, status_code: int, code: str, message: str) -> None:
self.status_code = status_code
self.code = code
self.message = message
super().__init__(message)
def error_response(
request: Request,
status_code: int,
code: str,
message: str,
) -> JSONResponse:
request_id = getattr(request.state, "request_id", "неизвестен")
return JSONResponse(
status_code=status_code,
content={
"error": {
"code": code,
"message": message,
"request_id": request_id,
}
},
)
+43
View File
@@ -0,0 +1,43 @@
import base64
import json
from datetime import datetime, timezone
from uuid import UUID
from src.core.errors import ApiError
def encode_cursor(kind: str, owner_id: UUID, created_at: datetime, item_id: UUID) -> str:
payload = {
"kind": kind,
"owner_id": str(owner_id), # id чата
"created_at": created_at.isoformat(), # его время
"item_id": str(item_id), # id сообщения
}
raw = json.dumps(payload, separators=(",", ":")).encode("utf-8")
return base64.urlsafe_b64encode(raw).decode("ascii").rstrip("=")
def decode_cursor(
cursor: str, expected_kind: str, expected_owner_id: UUID
) -> tuple[datetime, UUID]:
try:
padding = "=" * (-len(cursor) % 4)
raw = base64.b64decode(cursor + padding, altchars=b"-_", validate=True)
payload = json.loads(raw.decode("utf-8"))
if (
not isinstance(payload, dict)
or set(payload) != {"kind", "owner_id", "created_at", "item_id"}
or not all(isinstance(value, str) for value in payload.values())
):
raise ValueError
if payload["kind"] != expected_kind:
raise ValueError
if UUID(payload["owner_id"]) != expected_owner_id:
raise ValueError
created_at = datetime.fromisoformat(payload["created_at"])
item_id = UUID(payload["item_id"])
if created_at.tzinfo is None:
raise ValueError
return created_at.astimezone(timezone.utc), item_id
except (KeyError, TypeError, ValueError, UnicodeError, OverflowError):
raise ApiError(400, "invalid_request", "Некорректный курсор") from None
+115
View File
@@ -0,0 +1,115 @@
"""Ограниченный приём тела до валидации FastAPI, включая chunked-запросы."""
import asyncio
import json
from anyio import CapacityLimiter, WouldBlock
from starlette.requests import Request
from starlette.types import ASGIApp, Message, Receive, Scope, Send
from src.core.errors import error_response
from src.core.settings import settings
def unique_object(pairs: list[tuple[str, object]]) -> dict[str, object]:
result = {}
for key, value in pairs:
if key in result:
raise ValueError("Повторяющийся ключ JSON")
result[key] = value
return result
def reject_constant(value: str) -> None:
raise ValueError("Недопустимое значение JSON")
class RequestLimitsMiddleware:
def __init__(self, app: ASGIApp) -> None:
self.app = app
self.limiter = CapacityLimiter(settings.http_concurrency_limit)
async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
if scope["type"] != "http" or not scope["path"].startswith("/api/v1/"):
await self.app(scope, receive, send)
return
try:
self.limiter.acquire_nowait()
except WouldBlock:
await error_response(Request(scope), 503, "unavailable", "Сервис перегружен")(
scope, receive, send
)
return
try:
await self.handle_request(scope, receive, send)
finally:
self.limiter.release()
async def handle_request(self, scope: Scope, receive: Receive, send: Send) -> None:
request = Request(scope)
content_type = request.headers.get("content-type", "").split(";", 1)[0].strip().lower()
json_body = (
request.method == "POST" and scope["path"].rstrip("/") != "/api/v1/auth/sessions"
)
if json_body and content_type != "application/json":
await error_response(
request, 415, "unsupported_media_type", "Требуется application/json"
)(scope, receive, send)
return
try:
length = int(request.headers.get("content-length", "0"))
if length < 0:
raise ValueError
except ValueError:
await error_response(request, 400, "invalid_request", "Неверная длина тела")(
scope, receive, send
)
return
body = bytearray()
too_large = length > settings.http_max_body_bytes
if not too_large:
try:
async with asyncio.timeout(settings.http_body_timeout_seconds):
while True:
message = await receive()
if message["type"] == "http.disconnect":
return
chunk = message.get("body", b"")
if len(body) + len(chunk) > settings.http_max_body_bytes:
too_large = True
break
body.extend(chunk)
if not message.get("more_body", False):
break
except TimeoutError:
await error_response(request, 408, "invalid_request", "Истекло время приёма тела")(
scope, receive, send
)
return
if too_large:
await error_response(request, 413, "payload_too_large", "Превышен размер тела запроса")(
scope, receive, send
)
return
if json_body:
try:
json.loads(
body.decode("utf-8"),
object_pairs_hook=unique_object,
parse_constant=reject_constant,
)
except (ValueError, UnicodeError, RecursionError):
await error_response(request, 400, "invalid_request", "Некорректный JSON UTF-8")(
scope, receive, send
)
return
delivered = False
async def buffered_receive() -> Message:
nonlocal delivered
if delivered:
return await receive()
delivered = True
return {"type": "http.request", "body": bytes(body), "more_body": False}
await self.app(scope, buffered_receive, send)
+42
View File
@@ -0,0 +1,42 @@
"""Пароли: Argon2id. Токены: SHA-256 от случайного секрета."""
import hashlib
from anyio import CapacityLimiter, to_thread
from argon2 import PasswordHasher, Type
from argon2.exceptions import InvalidHashError, VerificationError
from src.core.settings import settings
password_hasher = PasswordHasher(
time_cost=settings.argon2_time_cost,
memory_cost=settings.argon2_memory_cost,
parallelism=settings.argon2_parallelism,
salt_len=settings.argon2_salt_len,
hash_len=settings.argon2_hash_len,
type=Type.ID,
)
password_limiter = CapacityLimiter(settings.password_hash_concurrency)
async def hash_password_async(password: str) -> str:
return await to_thread.run_sync(hash_password, password, limiter=password_limiter)
async def verify_password_async(password: str, stored: str) -> bool:
return await to_thread.run_sync(verify_password, password, stored, limiter=password_limiter)
def hash_password(password: str) -> str:
return password_hasher.hash(password)
def verify_password(password: str, stored: str) -> bool:
try:
return password_hasher.verify(stored, password)
except (VerificationError, InvalidHashError):
return False
def hash_token(token: str) -> str:
return hashlib.sha256(token.encode("utf-8")).hexdigest()
+55
View File
@@ -0,0 +1,55 @@
"""Сессии в Redis: абсолютный срок жизни, без продления при чтении."""
import json
from dataclasses import asdict
from datetime import datetime, timezone
from uuid import UUID
from redis.exceptions import ResponseError
from src.core import cache
from src.service.dto import StoredSessionDTO
def session_key(token_hash: str) -> str:
return f"session:v1:{token_hash}"
async def create_session(token_hash: str, session: StoredSessionDTO) -> None:
await cache.get_client().set(
session_key(token_hash),
json.dumps(asdict(session), default=str),
pxat=int(session.expires_at.timestamp() * 1000),
)
async def fetch_session(token_hash: str) -> StoredSessionDTO | None:
key = session_key(token_hash)
try:
raw = await cache.get_client().get(key)
if raw is None:
return None
data = json.loads(raw)
if (
not isinstance(data, dict)
or set(data) != {"user_id", "expires_at"}
or not all(isinstance(value, str) for value in data.values())
):
raise ValueError
session = StoredSessionDTO(
UUID(data["user_id"]), datetime.fromisoformat(data["expires_at"])
)
if session.expires_at.tzinfo is None or session.expires_at <= datetime.now(timezone.utc):
raise ValueError
return session
except ResponseError as error:
if not str(error).startswith("WRONGTYPE"):
raise
except (ValueError, KeyError, TypeError, UnicodeError):
pass
await cache.get_client().delete(key)
return None
async def delete_session(token_hash: str) -> None:
await cache.get_client().delete(session_key(token_hash))
+95
View File
@@ -0,0 +1,95 @@
from typing import Literal, Self
from pydantic import Field, SecretStr, field_validator, model_validator
from pydantic_settings import BaseSettings, SettingsConfigDict
class AppSettings(BaseSettings):
model_config = SettingsConfigDict(
env_file=".env",
env_file_encoding="utf-8",
extra="ignore",
hide_input_in_errors=True,
)
app_host: str = "0.0.0.0"
app_port: int = Field(default=8080, ge=1, le=65535)
app_env: Literal["lab", "production"] = "lab"
app_workers: int = Field(default=1, ge=1)
shutdown_timeout_seconds: int = Field(default=10, gt=0)
healthcheck_timeout_seconds: float = Field(default=2, gt=0)
http_max_body_bytes: int = Field(default=65536, ge=65536)
http_body_timeout_seconds: float = Field(default=5, gt=0)
http_concurrency_limit: int = Field(default=64, gt=0)
authorization_max_length: int = Field(default=2048, ge=1024)
cursor_max_length: int = Field(default=1024, ge=512)
password_hash_concurrency: int = Field(default=2, gt=0)
database_url: SecretStr
database_pool_size: int = Field(default=10, gt=0)
database_max_overflow: int = Field(default=0, ge=0)
database_pool_timeout_seconds: float = Field(default=5, gt=0)
database_connect_timeout_seconds: float = Field(default=5, gt=0)
database_command_timeout_seconds: float = Field(default=5, gt=0)
database_statement_timeout_ms: int = Field(default=5000, gt=0)
database_pool_pre_ping: bool = True
redis_url: SecretStr
redis_max_connections: int = Field(default=10, gt=0)
redis_connect_timeout_seconds: float = Field(default=0.3, gt=0)
redis_read_timeout_seconds: float = Field(default=0.3, gt=0)
redis_retry_on_timeout: bool = False
profile_cache_ttl_seconds: int = Field(default=60, gt=0)
admin_username: str = Field(default="admin", pattern=r"^[a-z0-9_]{3,32}$")
admin_password: SecretStr = Field(
default=SecretStr("admin-password-123"),
min_length=12,
max_length=128,
)
admin_display_name: str = Field(default="Администратор", min_length=1, max_length=100)
session_ttl_seconds: int = Field(default=3600, gt=0)
session_token_bytes: int = Field(default=32, ge=32)
argon2_time_cost: int = Field(default=3, gt=0)
argon2_memory_cost: int = Field(default=65536, ge=8192)
argon2_parallelism: int = Field(default=4, gt=0)
argon2_salt_len: int = Field(default=16, ge=16)
argon2_hash_len: int = Field(default=32, ge=32)
log_level: Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"] = "INFO"
log_format: str = "%(asctime)s %(levelname)s %(name)s: %(message)s"
@field_validator("admin_password")
@classmethod
def admin_password_must_not_be_blank(cls, value: SecretStr) -> SecretStr:
if not value.get_secret_value().strip():
raise ValueError("Пароль администратора не может быть пробельным")
value.get_secret_value().encode("utf-8")
return value
@field_validator("admin_display_name")
@classmethod
def admin_display_name_must_be_valid(cls, value: str) -> str:
if not value.strip() or "\x00" in value:
raise ValueError("Некорректное имя администратора")
return value
@model_validator(mode="after")
def production_must_use_custom_password(self) -> Self:
if self.app_env == "production" and self.admin_password.get_secret_value() == (
"admin-password-123"
):
raise ValueError("Для production требуется собственный ADMIN_PASSWORD")
return self
@property
def sqlalchemy_database_url(self) -> str:
return self.database_url.get_secret_value().replace(
"postgresql://",
"postgresql+asyncpg://",
1,
)
settings = AppSettings()
+120
View File
@@ -0,0 +1,120 @@
import logging
import time
import uuid
from typing import Annotated
from fastapi import Depends, FastAPI, Request
from fastapi.exceptions import RequestValidationError
from fastapi.responses import JSONResponse
from redis.exceptions import RedisError
from sqlalchemy import select
from sqlalchemy.exc import DBAPIError
from sqlalchemy.exc import TimeoutError as DatabaseTimeoutError
from sqlalchemy.ext.asyncio import AsyncSession
from starlette.exceptions import HTTPException as StarletteHTTPException
from src.api.router import router as api_router
from src.core import cache
from src.core.callback import lifespan
from src.core.db.session import get_db_session
from src.core.errors import ApiError, error_response
from src.core.request_limits import RequestLimitsMiddleware
from src.core.settings import settings
logging.basicConfig(level=settings.log_level, format=settings.log_format)
app = FastAPI(lifespan=lifespan)
app.add_middleware(RequestLimitsMiddleware)
app.include_router(api_router)
logger = logging.getLogger(__name__)
@app.middleware("http")
async def add_request_id(request: Request, call_next):
request_id = str(uuid.uuid4())
request.state.request_id = request_id
started_at = time.perf_counter()
try:
response = await call_next(request)
except Exception:
logger.exception(
"Необработанная ошибка запроса",
extra={"request_id": request_id},
)
response = JSONResponse(
status_code=500,
content={
"error": {
"code": "internal_error",
"message": "Внутренняя ошибка сервера",
"request_id": request_id,
}
},
)
response.headers["X-Request-Id"] = request_id
if request.url.path.startswith("/api/v1/"):
response.headers["Cache-Control"] = "no-store"
response.headers["X-Content-Type-Options"] = "nosniff"
logger.info(
"ид_запроса=%s метод=%s путь=%r статус=%s длительность_мс=%.3f",
request_id,
request.method,
request.url.path,
response.status_code,
(time.perf_counter() - started_at) * 1000,
)
return response
@app.exception_handler(ApiError)
async def handle_api_error(request: Request, exc: ApiError) -> JSONResponse:
response = error_response(request, exc.status_code, exc.code, exc.message)
if exc.status_code == 401:
response.headers["WWW-Authenticate"] = (
'Basic realm="messenger", charset="UTF-8"'
if request.url.path == "/api/v1/auth/sessions"
else 'Bearer realm="messenger"'
)
return response
@app.exception_handler(RequestValidationError)
async def handle_validation_error(request: Request, exc: RequestValidationError) -> JSONResponse:
return error_response(request, 400, "invalid_request", "Некорректные параметры запроса")
@app.exception_handler(StarletteHTTPException)
async def handle_http_error(request: Request, exc: StarletteHTTPException) -> JSONResponse:
code = "not_found" if exc.status_code == 404 else "invalid_request"
message = "Объект не найден" if exc.status_code == 404 else "Некорректный запрос"
return error_response(request, exc.status_code, code, message)
@app.get("/health/live")
async def get_health():
return {
"status": "ok",
}
@app.get("/health/ready")
async def get_ready(session: Annotated[AsyncSession, Depends(get_db_session, scope="function")]):
from src.core.db.models import User
await session.scalar(select(User.id).limit(1))
await cache.get_client().ping()
return {
"status": "ok",
}
async def handle_database_error(request: Request, exc: Exception) -> JSONResponse:
logger.warning("Хранилище временно недоступно: тип_ошибки=%s", type(exc).__name__)
return error_response(request, 503, "unavailable", "Хранилище временно недоступно")
for error_type in (RedisError, DBAPIError, DatabaseTimeoutError, OSError, TimeoutError):
app.add_exception_handler(error_type, handle_database_error)
View File
+74
View File
@@ -0,0 +1,74 @@
import logging
import secrets
from datetime import datetime, timedelta, timezone
from sqlalchemy.ext.asyncio import AsyncSession
from src.core import session_store
from src.core.db.repo import auth as auth_repo
from src.core.db.repo import user as user_repo
from src.core.security import hash_password, hash_token, verify_password_async
from src.core.settings import settings
from src.service.dto import AuthSessionDTO, StoredSessionDTO, UserDTO
from src.service.exceptions import InvalidCredentialsException, InvalidSessionException
logger = logging.getLogger(__name__)
# Для неизвестного логина тоже выполняем Argon2, чтобы не отвечать заметно быстрее.
_DUMMY_PASSWORD_HASH = hash_password("dummy-password-for-timing")
class AuthService:
def __init__(
self,
db_session: AsyncSession,
*,
session_ttl_seconds: int,
) -> None:
self._db_session = db_session
self._session_ttl = timedelta(seconds=session_ttl_seconds)
async def login(self, *, username: str, password: str) -> AuthSessionDTO:
credentials = await auth_repo.fetch_user_credentials(
session=self._db_session,
username=username,
)
password_hash = credentials.password_hash if credentials else _DUMMY_PASSWORD_HASH
password_valid = await verify_password_async(password, password_hash)
if credentials is None or not password_valid:
logger.warning("Вход отклонён: неверный логин или пароль")
raise InvalidCredentialsException("Неверный логин или пароль")
user = credentials.user
token = secrets.token_urlsafe(settings.session_token_bytes)
expires_at = datetime.now(timezone.utc) + self._session_ttl
await session_store.create_session(
token_hash=hash_token(token),
session=StoredSessionDTO(user_id=user.id, expires_at=expires_at),
)
logger.info("Сессия создана: пользователь=%s", user.id)
return AuthSessionDTO(
token=token,
expires_at=expires_at,
user=user,
)
async def get_user(self, *, token: str) -> UserDTO:
session = await session_store.fetch_session(token_hash=hash_token(token))
if session is None:
logger.info("Доступ отклонён: сессия отсутствует или истекла")
raise InvalidSessionException("Нет действующей сессии")
user = await user_repo.fetch_user_by_id(
session=self._db_session,
user_id=session.user_id,
)
if user is None:
logger.warning("Доступ отклонён: пользователь сессии не найден")
raise InvalidSessionException("Нет действующей сессии")
logger.debug("Сессия подтверждена: пользователь=%s", user.id)
return user
async def logout(self, *, token: str) -> None:
await session_store.delete_session(token_hash=hash_token(token))
logger.info("Сессия завершена")
+61
View File
@@ -0,0 +1,61 @@
from datetime import datetime, timezone
from uuid import UUID, uuid4
from sqlalchemy.ext.asyncio import AsyncSession
from src.core.db.repo import chat as chat_repo
from src.core.db.repo import user as user_repo
from src.service.dto import ChatDTO
from src.service.exceptions import ChatNotFoundException, InvalidChatMembersException
class ChatService:
def __init__(self, db_session: AsyncSession) -> None:
self._db_session = db_session
async def create_chat(
self,
*,
title: str,
member_ids: list[UUID],
current_user_id: UUID,
) -> ChatDTO:
if current_user_id not in member_ids:
raise InvalidChatMembersException("Создатель должен быть в списке member_ids")
if not await user_repo.users_exist(
session=self._db_session,
user_ids=member_ids,
):
raise InvalidChatMembersException("Указан неизвестный пользователь")
return await chat_repo.create_chat(
session=self._db_session,
chat_id=uuid4(),
title=title,
member_ids=member_ids,
created_at=datetime.now(timezone.utc),
)
async def get_chat(self, *, chat_id: UUID, current_user_id: UUID) -> ChatDTO:
chat = await chat_repo.fetch_chat_by_id(
session=self._db_session,
chat_id=chat_id,
)
self._check_access(chat=chat, user_id=current_user_id)
return chat
async def get_chats(
self,
*,
current_user_id: UUID,
limit: int,
after: tuple[datetime, UUID] | None = None,
) -> list[ChatDTO]:
return await chat_repo.fetch_chats(
session=self._db_session, user_id=current_user_id, limit=limit, after=after
)
@staticmethod
def _check_access(*, chat: ChatDTO | None, user_id: UUID) -> None:
if chat is None or user_id not in chat.member_ids:
raise ChatNotFoundException("Чат не найден")
+49
View File
@@ -0,0 +1,49 @@
from dataclasses import dataclass, field
from datetime import datetime
from typing import Literal
from uuid import UUID
@dataclass(frozen=True, slots=True)
class UserDTO:
id: UUID
username: str
display_name: str
created_at: datetime
@dataclass(frozen=True, slots=True)
class ChatDTO:
id: UUID
title: str
member_ids: tuple[UUID, ...]
created_at: datetime
@dataclass(frozen=True, slots=True)
class MessageDTO:
id: UUID
chat_id: UUID
sender_id: UUID
text: str
created_at: datetime
@dataclass(frozen=True, slots=True)
class AuthSessionDTO:
token: str = field(repr=False)
expires_at: datetime
user: UserDTO
token_type: Literal["Bearer"] = "Bearer"
@dataclass(frozen=True, slots=True)
class StoredSessionDTO:
user_id: UUID
expires_at: datetime
@dataclass(frozen=True, slots=True)
class UserCredentialsDTO:
user: UserDTO
password_hash: str = field(repr=False)
+26
View File
@@ -0,0 +1,26 @@
class ServiceException(Exception):
pass
class UserAlreadyExistsException(ServiceException):
pass
class UserNotFoundException(ServiceException):
pass
class InvalidChatMembersException(ServiceException):
pass
class ChatNotFoundException(ServiceException):
pass
class InvalidCredentialsException(ServiceException):
pass
class InvalidSessionException(ServiceException):
pass
+60
View File
@@ -0,0 +1,60 @@
from datetime import datetime, timezone
from uuid import UUID, uuid4
from sqlalchemy.ext.asyncio import AsyncSession
from src.core.db.repo import chat as chat_repo
from src.core.db.repo import message as message_repo
from src.service.dto import ChatDTO, MessageDTO
from src.service.exceptions import ChatNotFoundException
class MessageService:
def __init__(self, db_session: AsyncSession) -> None:
self._db_session = db_session
async def create_message(
self,
*,
chat_id: UUID,
sender_id: UUID,
text: str,
) -> MessageDTO:
chat = await chat_repo.fetch_chat_by_id(
session=self._db_session,
chat_id=chat_id,
)
self._check_access(chat=chat, user_id=sender_id)
return await message_repo.create_message(
session=self._db_session,
message_id=uuid4(),
chat_id=chat_id,
sender_id=sender_id,
text=text,
created_at=datetime.now(timezone.utc),
)
async def get_messages(
self,
*,
chat_id: UUID,
current_user_id: UUID,
limit: int,
after: tuple[datetime, UUID] | None = None,
) -> list[MessageDTO]:
chat = await chat_repo.fetch_chat_by_id(
session=self._db_session,
chat_id=chat_id,
)
self._check_access(chat=chat, user_id=current_user_id)
return await message_repo.fetch_messages_by_chat_id(
session=self._db_session,
chat_id=chat_id,
limit=limit,
after=after,
)
@staticmethod
def _check_access(*, chat: ChatDTO | None, user_id: UUID) -> None:
if chat is None or user_id not in chat.member_ids:
raise ChatNotFoundException("Чат не найден")
+63
View File
@@ -0,0 +1,63 @@
from datetime import datetime, timezone
from uuid import UUID, uuid4
from sqlalchemy.exc import IntegrityError
from sqlalchemy.ext.asyncio import AsyncSession
from src.core.db.repo import user as user_repo
from src.core.security import hash_password_async
from src.service.dto import UserDTO
from src.service.exceptions import UserAlreadyExistsException, UserNotFoundException
class UserService:
def __init__(self, db_session: AsyncSession) -> None:
self._db_session = db_session
async def create_user(self, *, username: str, display_name: str, password: str) -> UserDTO:
password_hash = await hash_password_async(password)
try:
return await user_repo.create_user(
session=self._db_session,
user_id=uuid4(),
username=username,
display_name=display_name,
created_at=datetime.now(timezone.utc),
password_hash=password_hash,
)
except IntegrityError as error:
if getattr(error.orig, "sqlstate", None) != "23505":
raise
raise UserAlreadyExistsException("Пользователь с таким именем уже существует") from None
async def create_admin(
self,
*,
username: str,
display_name: str,
password: str,
) -> UserDTO | None:
password_hash = await hash_password_async(password)
user = await user_repo.create_admin(
session=self._db_session,
user_id=uuid4(),
username=username,
display_name=display_name,
password_hash=password_hash,
created_at=datetime.now(timezone.utc),
)
if user is None and not await user_repo.admin_exists(
session=self._db_session,
username=username,
):
raise UserAlreadyExistsException("Имя администратора занято обычным пользователем")
return user
async def get_user_by_id(self, *, user_id: UUID) -> UserDTO:
user = await user_repo.fetch_user_by_id(
session=self._db_session,
user_id=user_id,
)
if user is None:
raise UserNotFoundException("Пользователь не найден")
return user