From e167118875084709ac7716dec2163a4fa24f02c8 Mon Sep 17 00:00:00 2001 From: lolochka132 Date: Fri, 2 Oct 2026 16:44:12 +0300 Subject: [PATCH] lab2 --- .gitignore | 48 +++---- Dockerfile | 28 ++++ REPORT.md | 91 ++++++++++--- alembic.ini | 39 ++++++ alembic/env.py | 60 +++++++++ alembic/script.py.mako | 25 ++++ alembic/versions/71c939ad8254_init_tables.py | 67 ++++++++++ compose.yaml | 54 ++++++++ requirements.txt | 10 ++ scripts/restart.bat | 24 ++++ scripts/restart.sh | 18 +++ src/__init__.py | 0 src/api/auth.py | 131 +++++++++++++++++++ src/api/chats.py | 107 +++++++++++++++ src/api/deps.py | 54 ++++++++ src/api/health.py | 26 ++++ src/api/messages.py | 82 ++++++++++++ src/api/users.py | 58 ++++++++ src/core/__init__.py | 0 src/core/config.py | 39 ++++++ src/core/middleware.py | 16 +++ src/core/redis.py | 16 +++ src/core/security.py | 28 ++++ src/db/__init__.py | 0 src/db/base.py | 6 + src/db/session.py | 34 +++++ src/main.py | 93 +++++++++++++ src/models/__init__.py | 0 src/models/models.py | 104 +++++++++++++++ src/schemas/__init__.py | 0 src/schemas/schemas.py | 105 +++++++++++++++ src/services/__init__.py | 0 src/services/chats.py | 124 ++++++++++++++++++ src/services/messages.py | 76 +++++++++++ src/services/sessions.py | 50 +++++++ src/services/users.py | 51 ++++++++ student-tests/test_race_registration.py | 56 ++++++++ student-tests/test_redis_down.py | 65 +++++++++ student-tests/test_session_expiry.py | 69 ++++++++++ 39 files changed, 1810 insertions(+), 44 deletions(-) create mode 100644 Dockerfile create mode 100644 alembic.ini create mode 100644 alembic/env.py create mode 100644 alembic/script.py.mako create mode 100644 alembic/versions/71c939ad8254_init_tables.py create mode 100644 compose.yaml create mode 100644 requirements.txt create mode 100644 scripts/restart.bat create mode 100644 scripts/restart.sh create mode 100644 src/__init__.py create mode 100644 src/api/auth.py create mode 100644 src/api/chats.py create mode 100644 src/api/deps.py create mode 100644 src/api/health.py create mode 100644 src/api/messages.py create mode 100644 src/api/users.py create mode 100644 src/core/__init__.py create mode 100644 src/core/config.py create mode 100644 src/core/middleware.py create mode 100644 src/core/redis.py create mode 100644 src/core/security.py create mode 100644 src/db/__init__.py create mode 100644 src/db/base.py create mode 100644 src/db/session.py create mode 100644 src/main.py create mode 100644 src/models/__init__.py create mode 100644 src/models/models.py create mode 100644 src/schemas/__init__.py create mode 100644 src/schemas/schemas.py create mode 100644 src/services/__init__.py create mode 100644 src/services/chats.py create mode 100644 src/services/messages.py create mode 100644 src/services/sessions.py create mode 100644 src/services/users.py create mode 100644 student-tests/test_race_registration.py create mode 100644 student-tests/test_redis_down.py create mode 100644 student-tests/test_session_expiry.py diff --git a/.gitignore b/.gitignore index b5a7189..9549bbc 100644 --- a/.gitignore +++ b/.gitignore @@ -1,32 +1,24 @@ -# Local/private state +# Секреты .env -.env.* -!.env.example -secrets/ -certs/private/ -*.key -*.p12 -*.pfx -*.jks -*.pem -*.tfstate* -volumes/ -data/ -backups/ -# Runtime/build artifacts -.venv/ + +# Python __pycache__/ -*.py[cod] -node_modules/ -dist/ -build/ -target/ -bin/ -obj/ -coverage/ +*.pyc +*.pyo + +# Виртуальное окружение +.venv/ +venv/ + +# Тесты +.pytest_cache/ + +# Логи и результаты *.log +student-tests/evidence/ + +# Прочее .DS_Store -.idea/ -.vscode/ -# Keep small, sanitized evidence summaries in evidence/ under version control. -# Inspect git diff --cached: ignore rules are not a secret scanner. + +# Local editor +.cursor/ \ No newline at end of file diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000..f4f8dbc --- /dev/null +++ b/Dockerfile @@ -0,0 +1,28 @@ +FROM python:3.11-slim + +ENV PYTHONDONTWRITEBYTECODE=1 \ + PYTHONUNBUFFERED=1 \ + PIP_NO_CACHE_DIR=1 + +WORKDIR /app + +RUN apt-get update \ + && apt-get install -y --no-install-recommends build-essential libpq-dev curl \ + && rm -rf /var/lib/apt/lists/* + +COPY requirements.txt . +RUN pip install --no-cache-dir -r requirements.txt + +COPY alembic.ini . +COPY alembic ./alembic +COPY src ./src + +RUN useradd -m -u 1000 app && chown -R app:app /app +USER app + +EXPOSE 8080 + +HEALTHCHECK --interval=10s --timeout=3s --start-period=15s --retries=5 \ + CMD curl -fsS http://127.0.0.1:8080/health/live || exit 1 + +CMD ["uvicorn", "src.main:app", "--host", "0.0.0.0", "--port", "8080"] \ No newline at end of file diff --git a/REPORT.md b/REPORT.md index e42f2b0..431896e 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,96 @@ # Отчёт — лабораторная 2 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO +- Автор, группа: Алексеева Мария, БПИ2304 +- Целевая оценка: 4 - Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +- Использованные источники, библиотеки и помощь ИИ: официальная документация FastAPI, SQLAlchemy 2.0, Alembic, PostgreSQL, Redis. Код написан с использованием DeepSeek. ## Запуск из чистого clone -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +Требуется Docker 29+ и Docker Compose v2. Python 3.9+ нужен только для запуска публичных тестов с хоста. + +```sh +cp .env.example .env +# в .env задать POSTGRES_PASSWORD, остальное можно оставить по умолчанию + +docker compose --env-file .env up -d --build +docker compose ps # все три сервиса должны быть healthy + +docker compose exec api alembic upgrade head +curl.exe http://localhost:8080/health/live # {"status":"ok"} + +python tests/smoke.py --base-url http://localhost:8080 +python tests/resilience.py --mode persistence --action-script scripts/restart.bat --base-url http://localhost:8080 +Остановка: docker compose down (volumes сохраняются). Полный сброс учебных данных: docker compose down -v. + +.env содержит только локальные учебные значения и находится в .gitignore ## Архитектура и решения -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +Клиент → FastAPI (uvicorn) → PostgreSQL (источник истины) → Redis (сессии, TTL) + +PostgreSQL — источник истины. Все пользователи, чаты, участники и сообщения хранятся здесь. Создание чата и его участников выполняется в одной транзакции. + +Redis — сессии с TTL (SESSION_TTL_SECONDS, по умолчанию 3600). Persistence включён (--appendonly yes), сессии переживают рестарт. + +Пароли хешируются Argon2id (passlib). + +Изменено: X-User-Id заменён на Bearer-сессии с opaque-токенами, состояние перенесено в PostgreSQL, добавлены миграции Alembic, пароли хешируются KDF. + +Переменные .env.example: SESSION_TTL_SECONDS используется для TTL сессий; POSTGRES_* и REDIS_* формируют соответствующие URL подключения; APP_HOST и APP_PORT зарезервированы (uvicorn запускается с фиксированными значениями). ## Доказательства критериев -| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | -| --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | +|Критерий| Команда |Результат| +|Публичный smoke| python tests/smoke.py --base-url http://localhost:8080| PASS: lab2 public API scenario + +|Таблицы и индексы в PostgreSQL|docker compose exec postgres psql -U messenger -d messenger -c "\dt"| 4 таблицы + alembic_version, UNIQUE ix_users_username, индекс idx_messages_chat_created_id + +|Basic только на /auth/sessions|curl.exe -i http://localhost:8080/api/v1/users/me -H "Authorization: Basic ..."| 401, WWW-Authenticate: Bearer + +|Bearer на защищённых endpoint| curl.exe -i http://localhost:8080/api/v1/users/me| 401, WWW-Authenticate: Bearer realm="messenger" + +|Хеширование пароля| SELECT LEFT(password_hash, 30) FROM users| $argon2id$v=19$m=65536,t=2,p=2 + +|Persistence| python tests/resilience.py --mode persistence ... |PASS: persistence preserved confirmed data and existing session + +|Гонка регистрации| python student-tests/test_race_registration.py| [201, 409] — ровно одна победа + +|Expiry сессии| python student-tests/test_session_expiry.py при SESSION_TTL_SECONDS=2| PASS: session expiry works +|Недоступность Redis| python student-tests/test_redis_down.py |аноним — 401, Bearer — 503 +План запроса истории| EXPLAIN (ANALYZE, BUFFERS) на 10 000 сообщений |Index Scan, ×36 по времени к Seq Scan | -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. ## Эксперименты и отказы -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +Гипотеза: составной индекс (chat_id, created_at, id) устранит Seq Scan и Sort при чтении истории чата. + +Условия: учебный ноутбук (Windows 11, Docker Desktop, 4 vCPU, 8 GiB RAM). В messages 10 000 записей в одном чате. + +С индексом (idx_messages_chat_created_id): + +Index Scan, Buffers: shared hit=4, Execution Time: 0.046 ms. + +Без индекса (enable_indexscan=off, enable_bitmapscan=off): + +Seq Scan + top-N heapsort, Buffers: shared hit=130, Execution Time: 1.652 ms. + +Итог: ускорение ×36 по времени и ×32 по I/O. | Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | -| --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | + +| Рестарт api, postgres, redis (volumes сохранены)| данные и сессия живы |PASS в resilience.py| ~10 с, потерь нет + +|Остановка Redis| аноним 401, Bearer 503 |так и есть |~2 с после docker compose start redis + +|Гонка регистрации |одна 201, одна 409 |так и есть во всех запусках |— + +|Expiry при TTL=2 |токен истекает |401 после ожидания |— ## Ограничения и следующие шаги -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +Выдерживается: рестарт API/PostgreSQL/Redis, истечение сессий, недоступность Redis, гонка регистрации. + +Не выдерживается: потеря единственного Docker-host, падение PostgreSQL (API вернёт 5xx), сетевые разделения. + +Учебные упрощения: HTTP без TLS (нужен в lab7), параметры Argon2id ниже продакшн-рекомендаций, один экземпляр API без балансировщика (lab3), connection pool 10. \ No newline at end of file diff --git a/alembic.ini b/alembic.ini new file mode 100644 index 0000000..79b0c46 --- /dev/null +++ b/alembic.ini @@ -0,0 +1,39 @@ +[alembic] +script_location = alembic +prepend_sys_path = . +version_path_separator = os +sqlalchemy.url = + +[loggers] +keys = root,sqlalchemy,alembic + +[handlers] +keys = console + +[formatters] +keys = generic + +[logger_root] +level = WARN +handlers = console +qualname = + +[logger_sqlalchemy] +level = WARN +handlers = +qualname = sqlalchemy.engine + +[logger_alembic] +level = INFO +handlers = +qualname = alembic + +[handler_console] +class = StreamHandler +args = (sys.stderr,) +level = NOTSET +formatter = generic + +[formatter_generic] +format = %(levelname)-5.5s [%(name)s] %(message)s +datefmt = %H:%M:%S \ No newline at end of file diff --git a/alembic/env.py b/alembic/env.py new file mode 100644 index 0000000..493e1d8 --- /dev/null +++ b/alembic/env.py @@ -0,0 +1,60 @@ +import asyncio +from logging.config import fileConfig + +from sqlalchemy import pool +from sqlalchemy.engine import Connection +from sqlalchemy.ext.asyncio import async_engine_from_config + +from alembic import context + +from src.core.config import settings +from src.db.base import Base +from src.models import models # noqa: F401 — регистрируем модели в Base.metadata + +config = context.config +config.set_main_option("sqlalchemy.url", settings.database_url) + +if config.config_file_name is not None: + fileConfig(config.config_file_name) + +target_metadata = Base.metadata + + +def run_migrations_offline() -> None: + url = config.get_main_option("sqlalchemy.url") + context.configure( + url=url, + target_metadata=target_metadata, + literal_binds=True, + dialect_opts={"paramstyle": "named"}, + compare_type=True, + ) + with context.begin_transaction(): + context.run_migrations() + + +def do_run_migrations(connection: Connection) -> None: + context.configure( + connection=connection, + target_metadata=target_metadata, + compare_type=True, + ) + with context.begin_transaction(): + context.run_migrations() + + +async def run_migrations_online() -> None: + connectable = async_engine_from_config( + config.get_section(config.config_ini_section, {}), + prefix="sqlalchemy.", + poolclass=pool.NullPool, + ) + async with connectable.connect() as connection: + await connection.run_sync(do_run_migrations) + await connectable.dispose() + + +if context.is_offline_mode(): + run_migrations_offline() +else: + asyncio.run(run_migrations_online()) \ No newline at end of file diff --git a/alembic/script.py.mako b/alembic/script.py.mako new file mode 100644 index 0000000..2b1f3ac --- /dev/null +++ b/alembic/script.py.mako @@ -0,0 +1,25 @@ +"""${message} + +Revision ID: ${up_revision} +Revises: ${down_revision | comma,n} +Create Date: ${create_date} + +""" +from typing import Sequence, Union + +from alembic import op +import sqlalchemy as sa +${imports if imports else ""} + +revision: str = ${repr(up_revision)} +down_revision: Union[str, None] = ${repr(down_revision)} +branch_labels: Union[str, Sequence[str], None] = ${repr(branch_labels)} +depends_on: Union[str, Sequence[str], None] = ${repr(depends_on)} + + +def upgrade() -> None: + ${upgrades if upgrades else "pass"} + + +def downgrade() -> None: + ${downgrades if downgrades else "pass"} \ No newline at end of file diff --git a/alembic/versions/71c939ad8254_init_tables.py b/alembic/versions/71c939ad8254_init_tables.py new file mode 100644 index 0000000..1fe2ea3 --- /dev/null +++ b/alembic/versions/71c939ad8254_init_tables.py @@ -0,0 +1,67 @@ +"""init tables + +Revision ID: 71c939ad8254 +Revises: +Create Date: 2026-10-02 12:04:30.713963 + +""" +from typing import Sequence, Union + +from alembic import op +import sqlalchemy as sa + + +revision: str = '71c939ad8254' +down_revision: Union[str, None] = None +branch_labels: Union[str, Sequence[str], None] = None +depends_on: Union[str, Sequence[str], None] = None + + +def upgrade() -> None: + # ### commands auto generated by Alembic - please adjust! ### + op.create_table('chats', + sa.Column('id', sa.UUID(), nullable=False), + sa.Column('title', sa.String(length=100), nullable=False), + sa.Column('created_at', sa.DateTime(timezone=True), server_default=sa.text('now()'), nullable=False), + sa.PrimaryKeyConstraint('id') + ) + op.create_table('users', + sa.Column('id', sa.UUID(), nullable=False), + sa.Column('username', sa.String(length=32), nullable=False), + sa.Column('display_name', sa.String(length=100), nullable=False), + sa.Column('password_hash', sa.Text(), nullable=False), + sa.Column('created_at', sa.DateTime(timezone=True), server_default=sa.text('now()'), nullable=False), + sa.CheckConstraint("username ~ '^[a-z0-9_]{3,32}$'", name='ck_users_username_format'), + sa.PrimaryKeyConstraint('id') + ) + op.create_index(op.f('ix_users_username'), 'users', ['username'], unique=True) + op.create_table('chat_members', + sa.Column('chat_id', sa.UUID(), nullable=False), + sa.Column('user_id', sa.UUID(), nullable=False), + sa.ForeignKeyConstraint(['chat_id'], ['chats.id'], ondelete='CASCADE'), + sa.ForeignKeyConstraint(['user_id'], ['users.id'], ondelete='CASCADE'), + sa.PrimaryKeyConstraint('chat_id', 'user_id') + ) + op.create_table('messages', + sa.Column('id', sa.UUID(), nullable=False), + sa.Column('chat_id', sa.UUID(), nullable=False), + sa.Column('sender_id', sa.UUID(), nullable=False), + sa.Column('text', sa.Text(), nullable=False), + sa.Column('created_at', sa.DateTime(timezone=True), server_default=sa.text('now()'), nullable=False), + sa.ForeignKeyConstraint(['chat_id'], ['chats.id'], ondelete='CASCADE'), + sa.ForeignKeyConstraint(['sender_id'], ['users.id'], ondelete='CASCADE'), + sa.PrimaryKeyConstraint('id') + ) + op.create_index('idx_messages_chat_created_id', 'messages', ['chat_id', 'created_at', 'id'], unique=False) + # ### end Alembic commands ### + + +def downgrade() -> None: + # ### commands auto generated by Alembic - please adjust! ### + op.drop_index('idx_messages_chat_created_id', table_name='messages') + op.drop_table('messages') + op.drop_table('chat_members') + op.drop_index(op.f('ix_users_username'), table_name='users') + op.drop_table('users') + op.drop_table('chats') + # ### end Alembic commands ### \ No newline at end of file diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 0000000..952936b --- /dev/null +++ b/compose.yaml @@ -0,0 +1,54 @@ +services: + postgres: + image: postgres:16.4-alpine + environment: + POSTGRES_USER: ${POSTGRES_USER} + POSTGRES_PASSWORD: ${POSTGRES_PASSWORD} + POSTGRES_DB: ${POSTGRES_DB} + volumes: + - pgdata:/var/lib/postgresql/data + healthcheck: + test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER} -d ${POSTGRES_DB}"] + interval: 5s + timeout: 3s + retries: 10 + networks: [backend] + + redis: + image: redis:7.4-alpine + command: ["redis-server", "--appendonly", "yes"] + volumes: + - redisdata:/data + healthcheck: + test: ["CMD", "redis-cli", "ping"] + interval: 5s + timeout: 3s + retries: 10 + networks: [backend] + + api: + build: . + env_file: .env + environment: + POSTGRES_HOST: postgres + REDIS_HOST: redis + depends_on: + postgres: + condition: service_healthy + redis: + condition: service_healthy + ports: + - "8080:8080" + volumes: + - ./src:/app/src + - ./alembic:/app/alembic + - ./alembic.ini:/app/alembic.ini + networks: [backend] + +volumes: + pgdata: + redisdata: + +networks: + backend: + driver: bridge \ No newline at end of file diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..a2202fd --- /dev/null +++ b/requirements.txt @@ -0,0 +1,10 @@ +fastapi==0.115.0 +uvicorn[standard]==0.32.0 +sqlalchemy[asyncio]==2.0.36 +asyncpg==0.30.0 +alembic==1.13.3 +pydantic==2.9.2 +pydantic-settings==2.5.2 +passlib[argon2]==1.7.4 +argon2-cffi==23.1.0 +redis==5.1.1 \ No newline at end of file diff --git a/scripts/restart.bat b/scripts/restart.bat new file mode 100644 index 0000000..dc2aede --- /dev/null +++ b/scripts/restart.bat @@ -0,0 +1,24 @@ +@echo off +setlocal + +cd /d "%~dp0\.." + +echo [restart] restarting api, postgres, redis (volumes preserved)... +docker compose --env-file .env restart api postgres redis +if errorlevel 1 ( + echo [restart] docker compose restart failed + exit /b 1 +) + +echo [restart] waiting for api to become healthy... +setlocal enabledelayedexpansion +for /L %%i in (1,1,60) do ( + for /f "delims=" %%s in ('docker inspect --format="{{.State.Health.Status}}" mtusi2026lab2-api-1 2^>nul') do set STATUS=%%s + if "!STATUS!"=="healthy" ( + echo [restart] api is healthy after %%is + exit /b 0 + ) + timeout /t 1 /nobreak >nul +) +echo [restart] api did not become healthy within 60s +exit /b 1 \ No newline at end of file diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100644 index 0000000..8fdc47a --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,18 @@ +#!/usr/bin/env bash +set -euo pipefail + +cd "$(dirname "$0")/.." + +docker compose --env-file .env restart api postgres redis + +for i in $(seq 1 60); do + status=$(docker inspect --format='{{.State.Health.Status}}' mtusi2026lab2-api-1 2>/dev/null || echo "unknown") + if [ "$status" = "healthy" ]; then + echo "api is healthy after ${i}s" + exit 0 + fi + sleep 1 +done + +echo "api did not become healthy within 60s" >&2 +exit 1 \ No newline at end of file diff --git a/src/__init__.py b/src/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/api/auth.py b/src/api/auth.py new file mode 100644 index 0000000..4c82b6e --- /dev/null +++ b/src/api/auth.py @@ -0,0 +1,131 @@ +import base64 +import binascii +import uuid +from datetime import datetime, timedelta, timezone + +import redis.asyncio as aioredis +from fastapi import APIRouter, Depends, Header, Request +from fastapi.responses import JSONResponse +from sqlalchemy.ext.asyncio import AsyncSession + +from src.api.deps import get_current_user +from src.core.config import settings +from src.core.redis import get_redis +from src.core.security import verify_password +from src.db.session import get_db +from src.models.models import User +from src.schemas.schemas import SessionResponse, UserResponse +from src.services import sessions as sessions_service +from src.services import users as users_service + + +router = APIRouter(prefix="/api/v1/auth/sessions", tags=["auth"]) + + +def _rid(request: Request) -> str: + return getattr(request.state, "request_id", None) or str(uuid.uuid4()) + + +def _error( + status_code: int, + code: str, + message: str, + request: Request, + challenge: str | None = None, +) -> JSONResponse: + rid = _rid(request) + headers = {"X-Request-Id": rid} + if challenge: + headers["WWW-Authenticate"] = challenge + return JSONResponse( + status_code=status_code, + content={ + "error": { + "code": code, + "message": message, + "request_id": rid, + } + }, + headers=headers, + ) + + +def _parse_basic(authorization: str | None) -> tuple[str, str] | None: + if not authorization or not authorization.lower().startswith("basic "): + return None + encoded = authorization.split(" ", 1)[1].strip() + try: + decoded = base64.b64decode(encoded, validate=True).decode("utf-8") + except (binascii.Error, UnicodeDecodeError): + return None + if ":" not in decoded: + return None + username, password = decoded.split(":", 1) + return username, password + + +@router.post("", status_code=201) +async def create_session( + request: Request, + authorization: str | None = Header(default=None), + db: AsyncSession = Depends(get_db), + redis: aioredis.Redis = Depends(get_redis), +): + credentials = _parse_basic(authorization) + if credentials is None: + return _error( + 401, "unauthorized", "invalid credentials", request, + challenge='Basic realm="messenger", charset="UTF-8"', + ) + + username, password = credentials + user = await users_service.get_user_by_username(db, username) + if user is None or not verify_password(password, user.password_hash): + return _error( + 401, "unauthorized", "invalid credentials", request, + challenge='Basic realm="messenger", charset="UTF-8"', + ) + + try: + token = await sessions_service.create_session(redis, user.id) + except (aioredis.RedisError, ConnectionError, OSError): + return _error( + 503, "unavailable", "session store unavailable", request, + ) + + expires_at = datetime.now(timezone.utc) + timedelta( + seconds=settings.session_ttl_seconds + ) + + payload = SessionResponse( + token=token, + token_type="Bearer", + expires_at=expires_at, + user=UserResponse.model_validate(user), + ) + return JSONResponse( + status_code=201, + content=payload.model_dump(mode="json"), + headers={"X-Request-Id": _rid(request)}, + ) + + +@router.delete("/current", status_code=204) +async def revoke_current_session( + request: Request, + authorization: str | None = Header(default=None), + current_user: User = Depends(get_current_user), + redis: aioredis.Redis = Depends(get_redis), +): + token = authorization.split(" ", 1)[1].strip() + try: + await sessions_service.revoke_session(redis, token) + except (aioredis.RedisError, ConnectionError, OSError): + return _error( + 503, "unavailable", "session store unavailable", request, + ) + return JSONResponse( + status_code=204, + content=None, + headers={"X-Request-Id": _rid(request)}, + ) \ No newline at end of file diff --git a/src/api/chats.py b/src/api/chats.py new file mode 100644 index 0000000..39e1fbe --- /dev/null +++ b/src/api/chats.py @@ -0,0 +1,107 @@ +import uuid + +from fastapi import APIRouter, Depends, Query, Request +from fastapi.responses import JSONResponse +from sqlalchemy.ext.asyncio import AsyncSession + +from src.api.deps import get_current_user +from src.db.session import get_db +from src.models.models import User +from src.schemas.schemas import ( + ChatPage, + ChatResponse, + CreateChatRequest, +) +from src.services import chats as chats_service + + +router = APIRouter(prefix="/api/v1/chats", tags=["chats"]) + + +def _error(status_code: int, code: str, message: str, request: Request) -> JSONResponse: + rid = getattr(request.state, "request_id", None) or str(uuid.uuid4()) + return JSONResponse( + status_code=status_code, + content={ + "error": { + "code": code, + "message": message, + "request_id": rid, + } + }, + headers={"X-Request-Id": rid}, + ) + + +async def _build_chat_response( + db: AsyncSession, + chat, +) -> ChatResponse: + member_ids = await chats_service.get_member_ids(db, chat.id) + return ChatResponse( + id=chat.id, + title=chat.title, + member_ids=member_ids, + created_at=chat.created_at, + ) + + +@router.post("", status_code=201, response_model=ChatResponse) +async def create_chat( + payload: CreateChatRequest, + request: Request, + current_user: User = Depends(get_current_user), + db: AsyncSession = Depends(get_db), +): + try: + chat = await chats_service.create_chat( + db=db, + title=payload.title, + member_ids=payload.member_ids, + caller_id=current_user.id, + ) + except chats_service.CallerNotInMembersError: + return _error( + 400, "invalid_request", "caller must be in member_ids", request + ) + except chats_service.UnknownMemberError: + return _error( + 400, "invalid_request", "unknown member_id", request + ) + + return await _build_chat_response(db, chat) + + +@router.get("", response_model=ChatPage) +async def list_chats( + request: Request, + limit: int = Query(default=50, ge=1, le=100), + cursor: str | None = Query(default=None), + current_user: User = Depends(get_current_user), + db: AsyncSession = Depends(get_db), +): + try: + rows, next_cursor = await chats_service.list_chats_for_user( + db=db, + user_id=current_user.id, + limit=limit, + cursor=cursor, + ) + except ValueError: + return _error(400, "invalid_request", "invalid cursor", request) + + items = [await _build_chat_response(db, chat) for chat in rows] + return ChatPage(items=items, next_cursor=next_cursor) + + +@router.get("/{chat_id}", response_model=ChatResponse) +async def get_chat( + chat_id: uuid.UUID, + request: Request, + current_user: User = Depends(get_current_user), + db: AsyncSession = Depends(get_db), +): + chat = await chats_service.get_chat_for_user(db, chat_id, current_user.id) + if chat is None: + return _error(404, "not_found", "chat not found", request) + return await _build_chat_response(db, chat) \ No newline at end of file diff --git a/src/api/deps.py b/src/api/deps.py new file mode 100644 index 0000000..85711e9 --- /dev/null +++ b/src/api/deps.py @@ -0,0 +1,54 @@ +import uuid + +import redis.asyncio as aioredis +from fastapi import Depends, Header, HTTPException, status +from sqlalchemy.ext.asyncio import AsyncSession + +from src.core.redis import get_redis +from src.db.session import get_db +from src.models.models import User +from src.services import sessions as sessions_service +from src.services import users as users_service + + +async def get_current_user( + authorization: str | None = Header(default=None), + db: AsyncSession = Depends(get_db), + redis: aioredis.Redis = Depends(get_redis), +) -> User: + if not authorization or not authorization.lower().startswith("bearer "): + raise HTTPException( + status_code=status.HTTP_401_UNAUTHORIZED, + detail="unauthorized", + ) + + token = authorization.split(" ", 1)[1].strip() + if not token: + raise HTTPException( + status_code=status.HTTP_401_UNAUTHORIZED, + detail="unauthorized", + ) + + try: + user_id = await sessions_service.get_session_user_id(redis, token) + except (aioredis.RedisError, ConnectionError, OSError): + # Redis недоступен → не пропускаем запрос, отдаём 503. + raise HTTPException( + status_code=status.HTTP_503_SERVICE_UNAVAILABLE, + detail="session store unavailable", + ) + + if user_id is None: + raise HTTPException( + status_code=status.HTTP_401_UNAUTHORIZED, + detail="unauthorized", + ) + + user = await users_service.get_user_by_id(db, user_id) + if user is None: + raise HTTPException( + status_code=status.HTTP_401_UNAUTHORIZED, + detail="unauthorized", + ) + + return user \ No newline at end of file diff --git a/src/api/health.py b/src/api/health.py new file mode 100644 index 0000000..008ca5e --- /dev/null +++ b/src/api/health.py @@ -0,0 +1,26 @@ +import uuid + +from fastapi import APIRouter, Request +from fastapi.responses import JSONResponse + +router = APIRouter() + + +@router.get("/health/live") +async def live(request: Request): + rid = request.headers.get("X-Request-Id") or str(uuid.uuid4()) + return JSONResponse( + {"status": "ok"}, + headers={"X-Request-Id": rid}, + ) + + +@router.get("/health/ready") +async def ready(request: Request): + rid = request.headers.get("X-Request-Id") or str(uuid.uuid4()) + # Пока зависимостей нет — всегда говорим ok. + # Позже здесь будем проверять доступность PostgreSQL и Redis. + return JSONResponse( + {"status": "ok"}, + headers={"X-Request-Id": rid}, + ) \ No newline at end of file diff --git a/src/api/messages.py b/src/api/messages.py new file mode 100644 index 0000000..b520e89 --- /dev/null +++ b/src/api/messages.py @@ -0,0 +1,82 @@ +import uuid + +from fastapi import APIRouter, Depends, Query, Request +from fastapi.responses import JSONResponse +from sqlalchemy.ext.asyncio import AsyncSession + +from src.api.deps import get_current_user +from src.db.session import get_db +from src.models.models import User +from src.schemas.schemas import ( + CreateMessageRequest, + MessagePage, + MessageResponse, +) +from src.services import chats as chats_service +from src.services import messages as messages_service + + +router = APIRouter(prefix="/api/v1/chats", tags=["messages"]) + + +def _error(status_code: int, code: str, message: str, request: Request) -> JSONResponse: + rid = getattr(request.state, "request_id", None) or str(uuid.uuid4()) + return JSONResponse( + status_code=status_code, + content={ + "error": { + "code": code, + "message": message, + "request_id": rid, + } + }, + headers={"X-Request-Id": rid}, + ) + + +@router.post("/{chat_id}/messages", status_code=201, response_model=MessageResponse) +async def create_message( + chat_id: uuid.UUID, + payload: CreateMessageRequest, + request: Request, + current_user: User = Depends(get_current_user), + db: AsyncSession = Depends(get_db), +): + chat = await chats_service.get_chat_for_user(db, chat_id, current_user.id) + if chat is None: + return _error(404, "not_found", "chat not found", request) + + message = await messages_service.create_message( + db=db, + chat_id=chat.id, + sender_id=current_user.id, + text=payload.text, + ) + return MessageResponse.model_validate(message) + + +@router.get("/{chat_id}/messages", response_model=MessagePage) +async def list_messages( + chat_id: uuid.UUID, + request: Request, + limit: int = Query(default=50, ge=1, le=100), + cursor: str | None = Query(default=None), + current_user: User = Depends(get_current_user), + db: AsyncSession = Depends(get_db), +): + chat = await chats_service.get_chat_for_user(db, chat_id, current_user.id) + if chat is None: + return _error(404, "not_found", "chat not found", request) + + try: + rows, next_cursor = await messages_service.list_messages( + db=db, + chat_id=chat.id, + limit=limit, + cursor=cursor, + ) + except ValueError: + return _error(400, "invalid_request", "invalid cursor", request) + + items = [MessageResponse.model_validate(m) for m in rows] + return MessagePage(items=items, next_cursor=next_cursor) \ No newline at end of file diff --git a/src/api/users.py b/src/api/users.py new file mode 100644 index 0000000..cdc6cf9 --- /dev/null +++ b/src/api/users.py @@ -0,0 +1,58 @@ +import uuid + +from fastapi import APIRouter, Depends, Request +from fastapi.responses import JSONResponse +from sqlalchemy.ext.asyncio import AsyncSession + +from src.api.deps import get_current_user +from src.db.session import get_db +from src.models.models import User +from src.schemas.schemas import ( + CreateUserRequest, + UserResponse, +) +from src.services import users as users_service + + +router = APIRouter(prefix="/api/v1/users", tags=["users"]) + + +def _error(status_code: int, code: str, message: str, request: Request) -> JSONResponse: + rid = getattr(request.state, "request_id", None) or str(uuid.uuid4()) + return JSONResponse( + status_code=status_code, + content={ + "error": { + "code": code, + "message": message, + "request_id": rid, + } + }, + headers={"X-Request-Id": rid}, + ) + + +@router.post("", status_code=201, response_model=UserResponse) +async def register_user( + payload: CreateUserRequest, + request: Request, + db: AsyncSession = Depends(get_db), +): + try: + user = await users_service.create_user( + db=db, + username=payload.username, + display_name=payload.display_name, + password=payload.password, + ) + except users_service.UsernameTakenError: + return _error(409, "conflict", "username already taken", request) + + return UserResponse.model_validate(user) + + +@router.get("/me", response_model=UserResponse) +async def get_me( + current_user: User = Depends(get_current_user), +): + return UserResponse.model_validate(current_user) \ No newline at end of file diff --git a/src/core/__init__.py b/src/core/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/core/config.py b/src/core/config.py new file mode 100644 index 0000000..292b5e7 --- /dev/null +++ b/src/core/config.py @@ -0,0 +1,39 @@ +from pydantic_settings import BaseSettings, SettingsConfigDict + + +class Settings(BaseSettings): + model_config = SettingsConfigDict( + env_file=".env", + env_file_encoding="utf-8", + extra="ignore", + ) + + app_host: str = "0.0.0.0" + app_port: int = 8080 + app_env: str = "lab" + + session_ttl_seconds: int = 3600 + + postgres_user: str + postgres_password: str + postgres_db: str + postgres_host: str = "postgres" + postgres_port: int = 5432 + + redis_host: str = "redis" + redis_port: int = 6379 + redis_db: int = 0 + + @property + def database_url(self) -> str: + return ( + f"postgresql+asyncpg://{self.postgres_user}:{self.postgres_password}" + f"@{self.postgres_host}:{self.postgres_port}/{self.postgres_db}" + ) + + @property + def redis_url(self) -> str: + return f"redis://{self.redis_host}:{self.redis_port}/{self.redis_db}" + + +settings = Settings() \ No newline at end of file diff --git a/src/core/middleware.py b/src/core/middleware.py new file mode 100644 index 0000000..4d45a57 --- /dev/null +++ b/src/core/middleware.py @@ -0,0 +1,16 @@ +import uuid + +from starlette.middleware.base import BaseHTTPMiddleware +from starlette.requests import Request + + +class RequestIdMiddleware(BaseHTTPMiddleware): + """Гарантирует, что каждый ответ содержит X-Request-Id.""" + + async def dispatch(self, request: Request, call_next): + rid = request.headers.get("X-Request-Id") or str(uuid.uuid4()) + request.state.request_id = rid + + response = await call_next(request) + response.headers["X-Request-Id"] = rid + return response \ No newline at end of file diff --git a/src/core/redis.py b/src/core/redis.py new file mode 100644 index 0000000..915b935 --- /dev/null +++ b/src/core/redis.py @@ -0,0 +1,16 @@ +from collections.abc import AsyncGenerator + +import redis.asyncio as aioredis + +from src.core.config import settings + +redis_client: aioredis.Redis = aioredis.from_url( + settings.redis_url, + encoding="utf-8", + decode_responses=True, + max_connections=50, +) + + +async def get_redis() -> AsyncGenerator[aioredis.Redis, None]: + yield redis_client \ No newline at end of file diff --git a/src/core/security.py b/src/core/security.py new file mode 100644 index 0000000..5e0de06 --- /dev/null +++ b/src/core/security.py @@ -0,0 +1,28 @@ +import secrets + +from passlib.context import CryptContext + +_pwd_context = CryptContext( + schemes=["argon2"], + deprecated="auto", + argon2__time_cost=2, + argon2__memory_cost=65536, # 64 MiB + argon2__parallelism=2, + argon2__type="ID", # Argon2id +) + + +def hash_password(password: str) -> str: + return _pwd_context.hash(password) + + +def verify_password(password: str, password_hash: str) -> bool: + try: + return _pwd_context.verify(password, password_hash) + except ValueError: + return False + + +def generate_session_token() -> str: + # 32 байта = 256 бит энтропии, hex = 64 символа + return secrets.token_urlsafe(48) \ No newline at end of file diff --git a/src/db/__init__.py b/src/db/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/db/base.py b/src/db/base.py new file mode 100644 index 0000000..edd0f7e --- /dev/null +++ b/src/db/base.py @@ -0,0 +1,6 @@ +from sqlalchemy.orm import DeclarativeBase + + +class Base(DeclarativeBase): + """Общий базовый класс для всех ORM-моделей.""" + pass \ No newline at end of file diff --git a/src/db/session.py b/src/db/session.py new file mode 100644 index 0000000..d5efb2e --- /dev/null +++ b/src/db/session.py @@ -0,0 +1,34 @@ +from collections.abc import AsyncGenerator + +from sqlalchemy.ext.asyncio import ( + AsyncSession, + async_sessionmaker, + create_async_engine, +) + +from src.core.config import settings + +engine = create_async_engine( + settings.database_url, + echo=False, + pool_size=10, + max_overflow=20, + pool_pre_ping=True, + pool_recycle=1800, +) + +async_session_factory = async_sessionmaker( + engine, + class_=AsyncSession, + expire_on_commit=False, + autoflush=False, +) + + +async def get_db() -> AsyncGenerator[AsyncSession, None]: + async with async_session_factory() as session: + try: + yield session + except Exception: + await session.rollback() + raise \ No newline at end of file diff --git a/src/main.py b/src/main.py new file mode 100644 index 0000000..86758d1 --- /dev/null +++ b/src/main.py @@ -0,0 +1,93 @@ +import uuid + +from fastapi import FastAPI, HTTPException, Request +from fastapi.exceptions import RequestValidationError +from fastapi.responses import JSONResponse + +from src.api import auth, chats, health, messages, users +from src.core.middleware import RequestIdMiddleware + +app = FastAPI( + title="MTUSI Messenger — lab2", + version="1.2.0", +) + +app.add_middleware(RequestIdMiddleware) + +app.include_router(health.router) +app.include_router(users.router) +app.include_router(auth.router) +app.include_router(chats.router) +app.include_router(messages.router) + + +def _rid(request: Request) -> str: + return getattr(request.state, "request_id", None) or str(uuid.uuid4()) + + +def _code_for(status_code: int) -> str: + return { + 400: "invalid_request", + 401: "unauthorized", + 404: "not_found", + 409: "conflict", + 413: "payload_too_large", + 415: "unsupported_media_type", + 429: "rate_limited", + 503: "unavailable", + 500: "internal_error", + }.get(status_code, "internal_error") + + +@app.exception_handler(HTTPException) +async def http_exception_with_request_id(request: Request, exc: HTTPException): + rid = _rid(request) + response = JSONResponse( + status_code=exc.status_code, + content={ + "error": { + "code": _code_for(exc.status_code), + "message": exc.detail if isinstance(exc.detail, str) else "error", + "request_id": rid, + } + }, + headers={"X-Request-Id": rid}, + ) + if exc.status_code == 401: + response.headers["WWW-Authenticate"] = 'Bearer realm="messenger"' + if exc.headers: + for k, v in exc.headers.items(): + response.headers.setdefault(k, v) + return response + + +@app.exception_handler(RequestValidationError) +async def validation_exception_handler(request: Request, exc: RequestValidationError): + rid = _rid(request) + return JSONResponse( + status_code=400, + content={ + "error": { + "code": "invalid_request", + "message": "invalid request", + "request_id": rid, + } + }, + headers={"X-Request-Id": rid}, + ) + + +@app.exception_handler(Exception) +async def unhandled_exception_handler(request: Request, exc): + rid = _rid(request) + return JSONResponse( + status_code=500, + content={ + "error": { + "code": "internal_error", + "message": "internal error", + "request_id": rid, + } + }, + headers={"X-Request-Id": rid}, + ) \ No newline at end of file diff --git a/src/models/__init__.py b/src/models/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/models/models.py b/src/models/models.py new file mode 100644 index 0000000..28aa8a5 --- /dev/null +++ b/src/models/models.py @@ -0,0 +1,104 @@ +import uuid +from datetime import datetime + +from sqlalchemy import ( + CheckConstraint, + DateTime, + ForeignKey, + Index, + String, + Text, + func, +) +from sqlalchemy.dialects.postgresql import UUID +from sqlalchemy.orm import Mapped, mapped_column, relationship + +from src.db.base import Base + + +class User(Base): + __tablename__ = "users" + + id: Mapped[uuid.UUID] = mapped_column( + UUID(as_uuid=True), primary_key=True, default=uuid.uuid4 + ) + username: Mapped[str] = mapped_column( + String(32), unique=True, nullable=False, index=True + ) + display_name: Mapped[str] = mapped_column(String(100), nullable=False) + password_hash: Mapped[str] = mapped_column(Text, nullable=False) + created_at: Mapped[datetime] = mapped_column( + DateTime(timezone=True), server_default=func.now(), nullable=False + ) + + __table_args__ = ( + CheckConstraint( + "username ~ '^[a-z0-9_]{3,32}$'", + name="ck_users_username_format", + ), + ) + + +class Chat(Base): + __tablename__ = "chats" + + id: Mapped[uuid.UUID] = mapped_column( + UUID(as_uuid=True), primary_key=True, default=uuid.uuid4 + ) + title: Mapped[str] = mapped_column(String(100), nullable=False) + created_at: Mapped[datetime] = mapped_column( + DateTime(timezone=True), server_default=func.now(), nullable=False + ) + + members: Mapped[list["ChatMember"]] = relationship( + back_populates="chat", cascade="all, delete-orphan" + ) + + +class ChatMember(Base): + __tablename__ = "chat_members" + + chat_id: Mapped[uuid.UUID] = mapped_column( + UUID(as_uuid=True), + ForeignKey("chats.id", ondelete="CASCADE"), + primary_key=True, + ) + user_id: Mapped[uuid.UUID] = mapped_column( + UUID(as_uuid=True), + ForeignKey("users.id", ondelete="CASCADE"), + primary_key=True, + ) + + chat: Mapped["Chat"] = relationship(back_populates="members") + + +class Message(Base): + __tablename__ = "messages" + + id: Mapped[uuid.UUID] = mapped_column( + UUID(as_uuid=True), primary_key=True, default=uuid.uuid4 + ) + chat_id: Mapped[uuid.UUID] = mapped_column( + UUID(as_uuid=True), + ForeignKey("chats.id", ondelete="CASCADE"), + nullable=False, + ) + sender_id: Mapped[uuid.UUID] = mapped_column( + UUID(as_uuid=True), + ForeignKey("users.id", ondelete="CASCADE"), + nullable=False, + ) + text: Mapped[str] = mapped_column(Text, nullable=False) + created_at: Mapped[datetime] = mapped_column( + DateTime(timezone=True), server_default=func.now(), nullable=False + ) + + __table_args__ = ( + # Ключевой индекс для пагинации истории (оценка 4). + Index( + "idx_messages_chat_created_id", + "chat_id", + "created_at", + "id", + ), + ) \ No newline at end of file diff --git a/src/schemas/__init__.py b/src/schemas/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/schemas/schemas.py b/src/schemas/schemas.py new file mode 100644 index 0000000..a4bba1d --- /dev/null +++ b/src/schemas/schemas.py @@ -0,0 +1,105 @@ +import uuid +from datetime import datetime + +from pydantic import BaseModel, ConfigDict, Field + + +# ---------- Health ---------- + +class HealthResponse(BaseModel): + status: str = "ok" + + +# ---------- Errors ---------- + +class ErrorBody(BaseModel): + code: str + message: str + request_id: str + + +class ErrorResponse(BaseModel): + error: ErrorBody + + +# ---------- Users ---------- + +USERNAME_PATTERN = r"^[a-z0-9_]{3,32}$" + + +class CreateUserRequest(BaseModel): + model_config = ConfigDict(extra="forbid", str_strip_whitespace=True) + + username: str = Field(pattern=USERNAME_PATTERN) + display_name: str = Field(min_length=1, max_length=100) + password: str = Field(min_length=12, max_length=128) + + +class UserResponse(BaseModel): + model_config = ConfigDict(from_attributes=True, extra="forbid") + + id: uuid.UUID + username: str + display_name: str + created_at: datetime + + +# ---------- Sessions ---------- + +class SessionResponse(BaseModel): + model_config = ConfigDict(extra="forbid") + + token: str + token_type: str = "Bearer" + expires_at: datetime + user: UserResponse + + +# ---------- Chats ---------- + +class CreateChatRequest(BaseModel): + model_config = ConfigDict(extra="forbid", str_strip_whitespace=True) + + title: str = Field(min_length=1, max_length=100) + member_ids: list[uuid.UUID] = Field(min_length=1, max_length=100) + + +class ChatResponse(BaseModel): + model_config = ConfigDict(extra="forbid") + + id: uuid.UUID + title: str + member_ids: list[uuid.UUID] + created_at: datetime + + +class ChatPage(BaseModel): + model_config = ConfigDict(extra="forbid") + + items: list[ChatResponse] + next_cursor: str | None + + +# ---------- Messages ---------- + +class CreateMessageRequest(BaseModel): + model_config = ConfigDict(extra="forbid", str_strip_whitespace=True) + + text: str = Field(min_length=1, max_length=4000) + + +class MessageResponse(BaseModel): + model_config = ConfigDict(from_attributes=True, extra="forbid") + + id: uuid.UUID + chat_id: uuid.UUID + sender_id: uuid.UUID + text: str + created_at: datetime + + +class MessagePage(BaseModel): + model_config = ConfigDict(extra="forbid") + + items: list[MessageResponse] + next_cursor: str | None \ No newline at end of file diff --git a/src/services/__init__.py b/src/services/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/services/chats.py b/src/services/chats.py new file mode 100644 index 0000000..d36404d --- /dev/null +++ b/src/services/chats.py @@ -0,0 +1,124 @@ +import base64 +import uuid +from datetime import datetime + +from sqlalchemy import and_, or_, select +from sqlalchemy.ext.asyncio import AsyncSession + +from src.models.models import Chat, ChatMember, Message + + +class UnknownMemberError(Exception): + """Хотя бы один member_id не существует в users.""" + + +class CallerNotInMembersError(Exception): + """Вызывающий не входит в member_ids.""" + + +class ChatNotFoundError(Exception): + """Чат не существует или недоступен.""" + + +async def create_chat( + db: AsyncSession, + title: str, + member_ids: list[uuid.UUID], + caller_id: uuid.UUID, +) -> Chat: + unique_ids = set(member_ids) + if caller_id not in unique_ids: + raise CallerNotInMembersError() + + # Проверяем, что все users существуют + from src.models.models import User + result = await db.execute(select(User.id).where(User.id.in_(unique_ids))) + existing = {row[0] for row in result.all()} + missing = unique_ids - existing + if missing: + raise UnknownMemberError() + + chat = Chat(title=title) + db.add(chat) + await db.flush() # получаем chat.id + + for uid in unique_ids: + db.add(ChatMember(chat_id=chat.id, user_id=uid)) + + await db.commit() + await db.refresh(chat) + return chat + + +async def get_chat_for_user( + db: AsyncSession, + chat_id: uuid.UUID, + user_id: uuid.UUID, +) -> Chat | None: + stmt = ( + select(Chat) + .join(ChatMember, ChatMember.chat_id == Chat.id) + .where(Chat.id == chat_id, ChatMember.user_id == user_id) + ) + result = await db.execute(stmt) + return result.scalar_one_or_none() + + +async def get_member_ids( + db: AsyncSession, + chat_id: uuid.UUID, +) -> list[uuid.UUID]: + stmt = select(ChatMember.user_id).where(ChatMember.chat_id == chat_id) + result = await db.execute(stmt) + return [row[0] for row in result.all()] + + +# ---------- Пагинация списка чатов ---------- + +def encode_cursor(created_at: datetime, chat_id: uuid.UUID) -> str: + raw = f"{created_at.isoformat()}|{chat_id}" + return base64.urlsafe_b64encode(raw.encode()).decode() + + +def decode_cursor(cursor: str) -> tuple[datetime, uuid.UUID]: + try: + raw = base64.urlsafe_b64decode(cursor.encode()).decode() + ts_str, id_str = raw.split("|", 1) + return datetime.fromisoformat(ts_str), uuid.UUID(id_str) + except (ValueError, UnicodeDecodeError) as exc: + raise ValueError("invalid cursor") from exc + + +async def list_chats_for_user( + db: AsyncSession, + user_id: uuid.UUID, + limit: int, + cursor: str | None, +) -> tuple[list[Chat], str | None]: + stmt = ( + select(Chat) + .join(ChatMember, ChatMember.chat_id == Chat.id) + .where(ChatMember.user_id == user_id) + .order_by(Chat.created_at.asc(), Chat.id.asc()) + .limit(limit + 1) + ) + + if cursor: + cursor_ts, cursor_id = decode_cursor(cursor) + stmt = stmt.where( + or_( + Chat.created_at > cursor_ts, + and_(Chat.created_at == cursor_ts, Chat.id > cursor_id), + ) + ) + + result = await db.execute(stmt) + rows = list(result.scalars().all()) + + next_cursor: str | None = None + if len(rows) > limit: + last = rows[limit - 1] + next_cursor = encode_cursor(last.created_at, last.id) + rows = rows[:limit] + + return rows, next_cursor \ No newline at end of file diff --git a/src/services/messages.py b/src/services/messages.py new file mode 100644 index 0000000..541b771 --- /dev/null +++ b/src/services/messages.py @@ -0,0 +1,76 @@ +import base64 +import uuid +from datetime import datetime + +from sqlalchemy import and_, or_, select +from sqlalchemy.ext.asyncio import AsyncSession + +from src.models.models import Message + + +def encode_cursor(created_at: datetime, message_id: uuid.UUID) -> str: + raw = f"{created_at.isoformat()}|{message_id}" + return base64.urlsafe_b64encode(raw.encode()).decode() + + +def decode_cursor(cursor: str) -> tuple[datetime, uuid.UUID]: + try: + raw = base64.urlsafe_b64decode(cursor.encode()).decode() + ts_str, id_str = raw.split("|", 1) + return datetime.fromisoformat(ts_str), uuid.UUID(id_str) + except (ValueError, UnicodeDecodeError) as exc: + raise ValueError("invalid cursor") from exc + + +async def create_message( + db: AsyncSession, + chat_id: uuid.UUID, + sender_id: uuid.UUID, + text: str, +) -> Message: + message = Message( + chat_id=chat_id, + sender_id=sender_id, + text=text, + ) + db.add(message) + await db.commit() + await db.refresh(message) + return message + + +async def list_messages( + db: AsyncSession, + chat_id: uuid.UUID, + limit: int, + cursor: str | None, +) -> tuple[list[Message], str | None]: + stmt = ( + select(Message) + .where(Message.chat_id == chat_id) + .order_by(Message.created_at.asc(), Message.id.asc()) + .limit(limit + 1) + ) + + if cursor: + cursor_ts, cursor_id = decode_cursor(cursor) + stmt = stmt.where( + or_( + Message.created_at > cursor_ts, + and_( + Message.created_at == cursor_ts, + Message.id > cursor_id, + ), + ) + ) + + result = await db.execute(stmt) + rows = list(result.scalars().all()) + + next_cursor: str | None = None + if len(rows) > limit: + last = rows[limit - 1] + next_cursor = encode_cursor(last.created_at, last.id) + rows = rows[:limit] + + return rows, next_cursor \ No newline at end of file diff --git a/src/services/sessions.py b/src/services/sessions.py new file mode 100644 index 0000000..86a6a66 --- /dev/null +++ b/src/services/sessions.py @@ -0,0 +1,50 @@ +import uuid + +import redis.asyncio as aioredis + +from src.core.config import settings +from src.core.security import generate_session_token + +KEY_PREFIX = "session:" + + +def _key(token: str) -> str: + return KEY_PREFIX + token + + +async def create_session( + redis: aioredis.Redis, + user_id: uuid.UUID, + ttl_seconds: int | None = None, +) -> str: + token = generate_session_token() + ttl = ttl_seconds if ttl_seconds is not None else settings.session_ttl_seconds + await redis.set(_key(token), str(user_id), ex=ttl) + return token + + +async def get_session_user_id( + redis: aioredis.Redis, + token: str, +) -> uuid.UUID | None: + value = await redis.get(_key(token)) + if value is None: + return None + try: + return uuid.UUID(value) + except ValueError: + return None + + +async def revoke_session(redis: aioredis.Redis, token: str) -> None: + await redis.delete(_key(token)) + + +async def touch_session( + redis: aioredis.Redis, + token: str, + ttl_seconds: int | None = None, +) -> None: + """Продлить TTL сессии (опционально).""" + ttl = ttl_seconds if ttl_seconds is not None else settings.session_ttl_seconds + await redis.expire(_key(token), ttl) \ No newline at end of file diff --git a/src/services/users.py b/src/services/users.py new file mode 100644 index 0000000..0d2bd69 --- /dev/null +++ b/src/services/users.py @@ -0,0 +1,51 @@ +import uuid + +from sqlalchemy import select +from sqlalchemy.exc import IntegrityError +from sqlalchemy.ext.asyncio import AsyncSession + +from src.core.security import hash_password +from src.models.models import User + + +class UsernameTakenError(Exception): + """Username уже занят.""" + + +async def create_user( + db: AsyncSession, + username: str, + display_name: str, + password: str, +) -> User: + user = User( + username=username, + display_name=display_name, + password_hash=hash_password(password), + ) + db.add(user) + try: + await db.commit() + except IntegrityError as exc: + await db.rollback() + raise UsernameTakenError(username) from exc + await db.refresh(user) + return user + + +async def get_user_by_username( + db: AsyncSession, + username: str, +) -> User | None: + stmt = select(User).where(User.username == username) + result = await db.execute(stmt) + return result.scalar_one_or_none() + + +async def get_user_by_id( + db: AsyncSession, + user_id: uuid.UUID, +) -> User | None: + stmt = select(User).where(User.id == user_id) + result = await db.execute(stmt) + return result.scalar_one_or_none() \ No newline at end of file diff --git a/student-tests/test_race_registration.py b/student-tests/test_race_registration.py new file mode 100644 index 0000000..00617d7 --- /dev/null +++ b/student-tests/test_race_registration.py @@ -0,0 +1,56 @@ +"""Test: concurrent registration of the same username must produce exactly one 201 and one 409.""" +import base64 +import json +import threading +import urllib.error +import urllib.request +import uuid + + +BASE = "http://localhost:8080" + + +def post_user(username: str, password: str): + body = json.dumps({ + "username": username, + "display_name": "Race Test", + "password": password, + }).encode() + req = urllib.request.Request( + BASE + "/api/v1/users", + data=body, + headers={"Content-Type": "application/json"}, + method="POST", + ) + try: + with urllib.request.urlopen(req, timeout=10) as resp: + return resp.status, resp.read().decode() + except urllib.error.HTTPError as e: + return e.code, e.read().decode() + + +def main(): + username = "race_" + uuid.uuid4().hex[:8] + password = "RaceTestPassword123" + results = [] + lock = threading.Lock() + + def worker(): + status, body = post_user(username, password) + with lock: + results.append((status, body)) + + threads = [threading.Thread(target=worker) for _ in range(2)] + for t in threads: + t.start() + for t in threads: + t.join() + + statuses = [s for s, _ in results] + print("Statuses:", statuses) + assert sorted(statuses) == [201, 409], f"expected [201, 409], got {statuses}" + print("PASS: race registration — one 201, one 409") + + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/student-tests/test_redis_down.py b/student-tests/test_redis_down.py new file mode 100644 index 0000000..6ff85d8 --- /dev/null +++ b/student-tests/test_redis_down.py @@ -0,0 +1,65 @@ +"""Test: when Redis is down, protected endpoints return 503, not 500.""" +import subprocess +import time +import urllib.error +import urllib.request +import uuid + + +BASE = "http://localhost:8080" + + +def call(method, path, headers=None): + h = {"Accept": "application/json"} + h.update(headers or {}) + req = urllib.request.Request(BASE + path, headers=h, method=method) + try: + with urllib.request.urlopen(req, timeout=10) as resp: + return resp.status, resp.read().decode() + except urllib.error.HTTPError as e: + return e.code, e.read().decode() + + +def stop_redis(): + subprocess.run(["docker", "compose", "stop", "redis"], check=True, capture_output=True) + + +def start_redis(): + subprocess.run(["docker", "compose", "start", "redis"], check=True, capture_output=True) + # Ждём, пока Redis станет healthy + for _ in range(30): + p = subprocess.run( + ["docker", "inspect", "--format={{.State.Health.Status}}", "mtusi2026lab2-redis-1"], + capture_output=True, text=True, + ) + if p.stdout.strip() == "healthy": + return + time.sleep(1) + raise RuntimeError("redis did not become healthy") + + +def main(): + # Проверяем, что без токена всё ещё 401 (не 500) + try: + stop_redis() + time.sleep(2) + + # 1. Аноним не должен пройти (401, не 503 — токена нет) + status, body = call("GET", "/api/v1/users/me") + assert status == 401, f"anonymous request without token should be 401, got {status} {body}" + print("Anonymous without token: 401 (correct)") + + # 2. С фиктивным токеном — 503 (Redis недоступен), не 500 + status, body = call("GET", "/api/v1/users/me", headers={ + "Authorization": "Bearer faketoken12345", + }) + assert status == 503, f"with fake token and Redis down should be 503, got {status} {body}" + print("With token, Redis down: 503 (correct)") + print("PASS: Redis unavailability handled correctly") + finally: + start_redis() + print("Redis restarted") + + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/student-tests/test_session_expiry.py b/student-tests/test_session_expiry.py new file mode 100644 index 0000000..ec76f43 --- /dev/null +++ b/student-tests/test_session_expiry.py @@ -0,0 +1,69 @@ +"""Test: session expires after SESSION_TTL_SECONDS.""" +import base64 +import json +import time +import urllib.error +import urllib.request +import uuid + + +BASE = "http://localhost:8080" +EXPECTED_TTL = 2 # секунды + + +def call(method, path, body=None, headers=None): + h = {"Accept": "application/json"} + h.update(headers or {}) + data = None + if body is not None: + data = json.dumps(body).encode() + h["Content-Type"] = "application/json" + req = urllib.request.Request(BASE + path, data=data, headers=h, method=method) + try: + with urllib.request.urlopen(req, timeout=10) as resp: + return resp.status, json.loads(resp.read().decode() or "{}") + except urllib.error.HTTPError as e: + return e.code, json.loads(e.read().decode() or "{}") + + +def main(): + # 1. Регистрируем пользователя + username = "exp_" + uuid.uuid4().hex[:8] + password = "ExpiryTestPass123" + status, user = call("POST", "/api/v1/users", { + "username": username, + "display_name": "Expiry Test", + "password": password, + }) + assert status == 201, f"register failed: {status} {user}" + + # 2. Логинимся + cred = base64.b64encode(f"{username}:{password}".encode()).decode() + status, session = call("POST", "/api/v1/auth/sessions", headers={ + "Authorization": "Basic " + cred, + }) + assert status == 201, f"login failed: {status} {session}" + token = session["token"] + print(f"Got token; waiting {EXPECTED_TTL + 2}s for expiry...") + + # 3. Проверяем, что токен сразу работает + status, _ = call("GET", "/api/v1/users/me", headers={ + "Authorization": "Bearer " + token, + }) + assert status == 200, f"token should work immediately, got {status}" + print("Token works immediately: OK") + + # 4. Ждём больше TTL + time.sleep(EXPECTED_TTL + 2) + + # 5. Проверяем, что токен больше не работает + status, body = call("GET", "/api/v1/users/me", headers={ + "Authorization": "Bearer " + token, + }) + assert status == 401, f"expired token should give 401, got {status} {body}" + print("Token rejected after TTL: OK") + print("PASS: session expiry works") + + +if __name__ == "__main__": + main() \ No newline at end of file