Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
4ca90b0c47 |
@@ -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
@@ -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"]
|
||||
@@ -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.
|
||||
|
||||
@@ -0,0 +1,3 @@
|
||||
[alembic]
|
||||
script_location = %(here)s/migrations
|
||||
prepend_sys_path = .
|
||||
@@ -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
|
||||
@@ -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:
|
||||
@@ -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; временная БД удалена.
|
||||
@@ -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.
|
||||
@@ -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 сообщений
|
||||
@@ -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
|
||||
@@ -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; прежний токен и данные сохранены
|
||||
@@ -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; прежний токен и данные сохранены
|
||||
@@ -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())
|
||||
@@ -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"}
|
||||
@@ -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')
|
||||
@@ -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'])
|
||||
@@ -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')
|
||||
@@ -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
|
||||
Executable
+6
@@ -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
|
||||
@@ -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,
|
||||
)
|
||||
@@ -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
|
||||
@@ -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)
|
||||
@@ -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)
|
||||
@@ -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)
|
||||
@@ -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
|
||||
@@ -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)
|
||||
@@ -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
|
||||
@@ -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,
|
||||
)
|
||||
@@ -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
|
||||
@@ -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)
|
||||
@@ -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
|
||||
@@ -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)
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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))
|
||||
@@ -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)
|
||||
@@ -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)
|
||||
@@ -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)
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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,
|
||||
}
|
||||
},
|
||||
)
|
||||
@@ -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
|
||||
@@ -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)
|
||||
@@ -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()
|
||||
@@ -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))
|
||||
@@ -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
@@ -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)
|
||||
@@ -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("Сессия завершена")
|
||||
@@ -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("Чат не найден")
|
||||
@@ -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)
|
||||
@@ -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
|
||||
@@ -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("Чат не найден")
|
||||
@@ -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
|
||||
Reference in New Issue
Block a user