diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md index 8ceefa1..173de31 100644 --- a/.github/pull_request_template.md +++ b/.github/pull_request_template.md @@ -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 описывает мою реализацию. diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000..3146321 --- /dev/null +++ b/Dockerfile @@ -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"] diff --git a/REPORT.md b/REPORT.md index e42f2b0..e99f0bd 100644 --- a/REPORT.md +++ b/REPORT.md @@ -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. diff --git a/alembic.ini b/alembic.ini new file mode 100644 index 0000000..d3b7004 --- /dev/null +++ b/alembic.ini @@ -0,0 +1,3 @@ +[alembic] +script_location = %(here)s/migrations +prepend_sys_path = . diff --git a/compose.env.example b/compose.env.example new file mode 100644 index 0000000..498dbf0 --- /dev/null +++ b/compose.env.example @@ -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 diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 0000000..4185de8 --- /dev/null +++ b/compose.yaml @@ -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: diff --git a/evidence/lab2-alembic.txt b/evidence/lab2-alembic.txt new file mode 100644 index 0000000..e336a4c --- /dev/null +++ b/evidence/lab2-alembic.txt @@ -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; временная БД удалена. diff --git a/evidence/lab2-checks.txt b/evidence/lab2-checks.txt new file mode 100644 index 0000000..e323a75 --- /dev/null +++ b/evidence/lab2-checks.txt @@ -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. diff --git a/evidence/lab2-database.txt b/evidence/lab2-database.txt new file mode 100644 index 0000000..5237498 --- /dev/null +++ b/evidence/lab2-database.txt @@ -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 сообщений diff --git a/evidence/lab2-negative.txt b/evidence/lab2-negative.txt new file mode 100644 index 0000000..08a339d --- /dev/null +++ b/evidence/lab2-negative.txt @@ -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 diff --git a/evidence/lab2-persistence.txt b/evidence/lab2-persistence.txt new file mode 100644 index 0000000..52a1666 --- /dev/null +++ b/evidence/lab2-persistence.txt @@ -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; прежний токен и данные сохранены diff --git a/evidence/lab2-verification.txt b/evidence/lab2-verification.txt new file mode 100644 index 0000000..791e052 --- /dev/null +++ b/evidence/lab2-verification.txt @@ -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; прежний токен и данные сохранены diff --git a/migrations/env.py b/migrations/env.py new file mode 100644 index 0000000..16eaf7e --- /dev/null +++ b/migrations/env.py @@ -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()) diff --git a/migrations/script.py.mako b/migrations/script.py.mako new file mode 100644 index 0000000..5449f62 --- /dev/null +++ b/migrations/script.py.mako @@ -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"} diff --git a/migrations/versions/001_initial.py b/migrations/versions/001_initial.py new file mode 100644 index 0000000..b8cef40 --- /dev/null +++ b/migrations/versions/001_initial.py @@ -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') diff --git a/migrations/versions/002_redis_sessions.py b/migrations/versions/002_redis_sessions.py new file mode 100644 index 0000000..109638b --- /dev/null +++ b/migrations/versions/002_redis_sessions.py @@ -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']) diff --git a/migrations/versions/003_admin.py b/migrations/versions/003_admin.py new file mode 100644 index 0000000..7b57ee8 --- /dev/null +++ b/migrations/versions/003_admin.py @@ -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') diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..284bbcf --- /dev/null +++ b/requirements.txt @@ -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 diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100755 index 0000000..18fb6ab --- /dev/null +++ b/scripts/restart.sh @@ -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 diff --git a/src/__init__.py b/src/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/__main__.py b/src/__main__.py new file mode 100644 index 0000000..da5d2b9 --- /dev/null +++ b/src/__main__.py @@ -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, + ) diff --git a/src/api/__init__.py b/src/api/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/api/dependencies.py b/src/api/dependencies.py new file mode 100644 index 0000000..d04ea93 --- /dev/null +++ b/src/api/dependencies.py @@ -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 diff --git a/src/api/router.py b/src/api/router.py new file mode 100644 index 0000000..553eedc --- /dev/null +++ b/src/api/router.py @@ -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) diff --git a/src/api/v1/__init__.py b/src/api/v1/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/api/v1/routers/__init__.py b/src/api/v1/routers/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/api/v1/routers/auth/__init__.py b/src/api/v1/routers/auth/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/api/v1/routers/auth/callback.py b/src/api/v1/routers/auth/callback.py new file mode 100644 index 0000000..45334b8 --- /dev/null +++ b/src/api/v1/routers/auth/callback.py @@ -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) diff --git a/src/api/v1/routers/auth/router.py b/src/api/v1/routers/auth/router.py new file mode 100644 index 0000000..49076ec --- /dev/null +++ b/src/api/v1/routers/auth/router.py @@ -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) diff --git a/src/api/v1/routers/auth/schemas.py b/src/api/v1/routers/auth/schemas.py new file mode 100644 index 0000000..cdeff56 --- /dev/null +++ b/src/api/v1/routers/auth/schemas.py @@ -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 diff --git a/src/api/v1/routers/chats/__init__.py b/src/api/v1/routers/chats/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/api/v1/routers/chats/router.py b/src/api/v1/routers/chats/router.py new file mode 100644 index 0000000..d071839 --- /dev/null +++ b/src/api/v1/routers/chats/router.py @@ -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) diff --git a/src/api/v1/routers/chats/schemas.py b/src/api/v1/routers/chats/schemas.py new file mode 100644 index 0000000..b4151df --- /dev/null +++ b/src/api/v1/routers/chats/schemas.py @@ -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 diff --git a/src/api/v1/routers/messages/__init__.py b/src/api/v1/routers/messages/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/api/v1/routers/messages/router.py b/src/api/v1/routers/messages/router.py new file mode 100644 index 0000000..07f755f --- /dev/null +++ b/src/api/v1/routers/messages/router.py @@ -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, + ) diff --git a/src/api/v1/routers/messages/schemas.py b/src/api/v1/routers/messages/schemas.py new file mode 100644 index 0000000..4e3adf6 --- /dev/null +++ b/src/api/v1/routers/messages/schemas.py @@ -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 diff --git a/src/api/v1/routers/users/__init__.py b/src/api/v1/routers/users/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/api/v1/routers/users/router.py b/src/api/v1/routers/users/router.py new file mode 100644 index 0000000..cbe3726 --- /dev/null +++ b/src/api/v1/routers/users/router.py @@ -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) diff --git a/src/api/v1/routers/users/schemas.py b/src/api/v1/routers/users/schemas.py new file mode 100644 index 0000000..4f26199 --- /dev/null +++ b/src/api/v1/routers/users/schemas.py @@ -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 diff --git a/src/api/v1/schemas.py b/src/api/v1/schemas.py new file mode 100644 index 0000000..5a6de21 --- /dev/null +++ b/src/api/v1/schemas.py @@ -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) diff --git a/src/core/__init__.py b/src/core/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/core/cache.py b/src/core/cache.py new file mode 100644 index 0000000..19444bf --- /dev/null +++ b/src/core/cache.py @@ -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 diff --git a/src/core/callback.py b/src/core/callback.py new file mode 100644 index 0000000..7b31ddc --- /dev/null +++ b/src/core/callback.py @@ -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 diff --git a/src/core/db/__init__.py b/src/core/db/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/core/db/models.py b/src/core/db/models.py new file mode 100644 index 0000000..4bce4e6 --- /dev/null +++ b/src/core/db/models.py @@ -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)) diff --git a/src/core/db/repo/__init__.py b/src/core/db/repo/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/core/db/repo/auth.py b/src/core/db/repo/auth.py new file mode 100644 index 0000000..2497013 --- /dev/null +++ b/src/core/db/repo/auth.py @@ -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) diff --git a/src/core/db/repo/chat.py b/src/core/db/repo/chat.py new file mode 100644 index 0000000..aa88770 --- /dev/null +++ b/src/core/db/repo/chat.py @@ -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) diff --git a/src/core/db/repo/message.py b/src/core/db/repo/message.py new file mode 100644 index 0000000..d3c26c6 --- /dev/null +++ b/src/core/db/repo/message.py @@ -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) diff --git a/src/core/db/repo/user.py b/src/core/db/repo/user.py new file mode 100644 index 0000000..b348545 --- /dev/null +++ b/src/core/db/repo/user.py @@ -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 diff --git a/src/core/db/session.py b/src/core/db/session.py new file mode 100644 index 0000000..e4aaeb0 --- /dev/null +++ b/src/core/db/session.py @@ -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 diff --git a/src/core/errors.py b/src/core/errors.py new file mode 100644 index 0000000..70a62c9 --- /dev/null +++ b/src/core/errors.py @@ -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, + } + }, + ) diff --git a/src/core/pagination.py b/src/core/pagination.py new file mode 100644 index 0000000..d49e7b7 --- /dev/null +++ b/src/core/pagination.py @@ -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 diff --git a/src/core/request_limits.py b/src/core/request_limits.py new file mode 100644 index 0000000..3049114 --- /dev/null +++ b/src/core/request_limits.py @@ -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) diff --git a/src/core/security.py b/src/core/security.py new file mode 100644 index 0000000..210710c --- /dev/null +++ b/src/core/security.py @@ -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() diff --git a/src/core/session_store.py b/src/core/session_store.py new file mode 100644 index 0000000..1d7083f --- /dev/null +++ b/src/core/session_store.py @@ -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)) diff --git a/src/core/settings.py b/src/core/settings.py new file mode 100644 index 0000000..ad47ea6 --- /dev/null +++ b/src/core/settings.py @@ -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() diff --git a/src/main.py b/src/main.py new file mode 100644 index 0000000..2886771 --- /dev/null +++ b/src/main.py @@ -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) diff --git a/src/service/__init__.py b/src/service/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/service/auth.py b/src/service/auth.py new file mode 100644 index 0000000..425f285 --- /dev/null +++ b/src/service/auth.py @@ -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("Сессия завершена") diff --git a/src/service/chat.py b/src/service/chat.py new file mode 100644 index 0000000..97ce519 --- /dev/null +++ b/src/service/chat.py @@ -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("Чат не найден") diff --git a/src/service/dto.py b/src/service/dto.py new file mode 100644 index 0000000..1d6b028 --- /dev/null +++ b/src/service/dto.py @@ -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) diff --git a/src/service/exceptions.py b/src/service/exceptions.py new file mode 100644 index 0000000..62318ee --- /dev/null +++ b/src/service/exceptions.py @@ -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 diff --git a/src/service/message.py b/src/service/message.py new file mode 100644 index 0000000..9696858 --- /dev/null +++ b/src/service/message.py @@ -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("Чат не найден") diff --git a/src/service/user.py b/src/service/user.py new file mode 100644 index 0000000..05b6882 --- /dev/null +++ b/src/service/user.py @@ -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