From 76b34fca4b0221ca05fd3a63d700a419f140a6d6 Mon Sep 17 00:00:00 2001 From: gytall Date: Sun, 25 Oct 2026 02:14:56 +0300 Subject: [PATCH] added a session storage policy in Redis --- .env.example | 13 +++++- app/core/config.py | 12 +++++- app/core/redis.py | 38 +++++++++++++++++ app/core/security.py | 77 +++++++++++++++-------------------- app/domain/auth.py | 48 +++++----------------- app/endpoints/auth.py | 11 +++-- app/endpoints/dependencies.py | 23 +++++------ app/endpoints/health.py | 3 ++ app/errors/handlers.py | 23 +++++------ app/main.py | 8 +++- app/models/__init__.py | 6 +-- app/models/base.py | 5 +-- app/models/chat.py | 32 ++++++++++----- app/models/chat_member.py | 30 ++++++++------ app/models/message.py | 32 +++++++++------ app/models/session.py | 23 ----------- app/models/user.py | 30 +++++++++----- app/schemas/base.py | 2 - app/storage/sessions.py | 69 +++++++++---------------------- compose.yaml | 30 +++++++++++++- requirements.txt | 3 +- 21 files changed, 271 insertions(+), 247 deletions(-) create mode 100644 app/core/redis.py delete mode 100644 app/models/session.py diff --git a/.env.example b/.env.example index 8da2e15a..a5b2f45e 100644 --- a/.env.example +++ b/.env.example @@ -7,13 +7,22 @@ MAX_MESSAGES=100000 MAX_IN_FLIGHT=16 SESSION_TTL_SECONDS=3600 -SESSION_STORE=postgres +SESSION_STORE=redis + +REDIS_HOST=redis +REDIS_PORT=6379 +REDIS_DB=0 +REDIS_PASSWORD=change-me +REDIS_MAX_CONNECTIONS=20 +REDIS_POOL_TIMEOUT_SECONDS=1 +REDIS_CONNECT_TIMEOUT_SECONDS=1 +REDIS_SOCKET_TIMEOUT_SECONDS=0.5 DB_HOST=postgres DB_PORT=5432 DB_NAME=messenger DB_USER=messenger -DB_PASSWORD_FILE=/run/secrets/postgres_password +DB_PASSWORD=change-me DB_POOL_SIZE=5 DB_MAX_OVERFLOW=10 diff --git a/app/core/config.py b/app/core/config.py index c9d7a168..60980fa9 100644 --- a/app/core/config.py +++ b/app/core/config.py @@ -26,7 +26,17 @@ class Settings(BaseSettings): max_in_flight: int = Field(ge=1) session_ttl_seconds: int = Field(default=3600, ge=1) - session_store: Literal["postgres"] = "postgres" + session_store: Literal["redis"] = "redis" + + redis_host: str = "localhost" + redis_port: int = Field(default=6379, ge=1, le=65535) + redis_db: int = Field(default=0, ge=0) + redis_password: SecretStr | None = None + + redis_max_connections: int = Field(default=20, ge=1) + redis_pool_timeout_seconds: float = Field(default=1.0, gt=0) + redis_connect_timeout_seconds: float = Field(default=1.0, gt=0) + redis_socket_timeout_seconds: float = Field(default=0.5, gt=0) database_url: SecretStr | None = None db_host: str | None = None diff --git a/app/core/redis.py b/app/core/redis.py new file mode 100644 index 00000000..921d4d12 --- /dev/null +++ b/app/core/redis.py @@ -0,0 +1,38 @@ +import logging + +from redis.asyncio import BlockingConnectionPool, Redis +from redis.asyncio.retry import Retry +from redis.backoff import NoBackoff +from redis.exceptions import RedisError + +from app.core.config import Settings + +logger = logging.getLogger(__name__) + + +def create_redis_client(settings: Settings) -> Redis: + password = ( + settings.redis_password.get_secret_value() if settings.redis_password else None + ) + pool = BlockingConnectionPool( + host=settings.redis_host, + port=settings.redis_port, + db=settings.redis_db, + password=password, + max_connections=settings.redis_max_connections, + timeout=settings.redis_pool_timeout_seconds, + socket_connect_timeout=settings.redis_connect_timeout_seconds, + socket_timeout=settings.redis_socket_timeout_seconds, + retry=Retry(NoBackoff(), retries=1), + decode_responses=True, + ) + return Redis.from_pool(pool) + + +async def check_redis(client: Redis) -> bool: + try: + await client.ping() + except (RedisError, OSError): + logger.warning("redis readiness check failed", exc_info=True) + return False + return True diff --git a/app/core/security.py b/app/core/security.py index 184fc146..4cb2b28f 100644 --- a/app/core/security.py +++ b/app/core/security.py @@ -1,69 +1,56 @@ -"""Пароли и токены сессий. ВСЁ ЗДЕСЬ — ЗАГЛУШКИ ДЛЯ САМОСТОЯТЕЛЬНОЙ РЕАЛИЗАЦИИ. +"""Хеширование паролей (Argon2id) и выпуск непрозрачных токенов сессий.""" -Вопрос защиты: «Почему hash пароля и быстрый checksum имеют разные задачи?» - * пароль имеет низкую энтропию -> нужен медленный KDF с солью (Argon2id); - * токен — 256 бит случайности -> брутфорс невозможен, хватает SHA-256, - а в БД храним только хеш токена (утечка БД не даёт рабочих токенов). +import asyncio +import hashlib +import os +import secrets +from concurrent.futures import ThreadPoolExecutor -Async: Argon2 — CPU-bound и занимает десятки миллисекунд. Вызов прямо из -`async def` блокирует event loop на всё это время, и ВСЕ остальные запросы -стоят. Поэтому hash/verify оборачиваются в `asyncio.to_thread`. -generate_token и hash_token — микросекунды, остаются обычными функциями. -""" +from argon2 import PasswordHasher +from argon2.exceptions import InvalidHashError, VerificationError + +TOKEN_BYTES = 32 + +_hasher = PasswordHasher() +_executor = ThreadPoolExecutor( + max_workers=os.cpu_count() or 1, thread_name_prefix="argon2" +) def _hash_password_sync(password: str) -> str: - """Синхронный Argon2id-хеш. Вызывается только через asyncio.to_thread. - - Алгоритм: - 1. hasher = модульный PasswordHasher() (создать один раз на модуль) - 2. return hasher.hash(password) # "$argon2id$..." с солью и параметрами - """ - raise NotImplementedError("TODO") + return _hasher.hash(password) def _verify_password_sync(password: str, password_hash: str) -> bool: - """Синхронная проверка. Вызывается только через asyncio.to_thread. + try: + return _hasher.verify(password_hash, password) + except (VerificationError, InvalidHashError): + return False - Алгоритм: - 1. try: hasher.verify(password_hash, password); return True - 2. except VerifyMismatchError / VerificationError / InvalidHashError: return False - """ - raise NotImplementedError("TODO") + +_DUMMY_HASH = _hash_password_sync(secrets.token_urlsafe(TOKEN_BYTES)) async def hash_password(password: str) -> str: - """Алгоритм: return await asyncio.to_thread(_hash_password_sync, password).""" - raise NotImplementedError("TODO") + loop = asyncio.get_running_loop() + return await loop.run_in_executor(_executor, _hash_password_sync, password) async def verify_password(password: str, password_hash: str) -> bool: - """Алгоритм: return await asyncio.to_thread(_verify_password_sync, password, password_hash).""" - raise NotImplementedError("TODO") + loop = asyncio.get_running_loop() + return await loop.run_in_executor( + _executor, _verify_password_sync, password, password_hash + ) async def dummy_verify_password(password: str) -> None: - """Проверка «вхолостую» для несуществующего пользователя. - - Нужна, чтобы время ответа на неверный username и на неверный пароль - не различалось (иначе по таймингу можно перебирать username). - - Алгоритм: - 1. DUMMY_HASH = hash от случайной строки, посчитан один раз при импорте модуля - (через _hash_password_sync, не через await — на уровне модуля await нельзя) - 2. await verify_password(password, DUMMY_HASH); результат игнорировать - """ - raise NotImplementedError("TODO") + """Выравнивает время ответа для несуществующего пользователя.""" + await verify_password(password, _DUMMY_HASH) def generate_token() -> str: - """Opaque-токен минимум на 256 бит энтропии. Алгоритм: secrets.token_urlsafe(32).""" - raise NotImplementedError("TODO") + return secrets.token_urlsafe(TOKEN_BYTES) def hash_token(token: str) -> str: - """Детерминированный хеш токена для хранения/поиска в БД. - - Алгоритм: hashlib.sha256(token.encode()).hexdigest() - """ - raise NotImplementedError("TODO") + return hashlib.sha256(token.encode()).hexdigest() diff --git a/app/domain/auth.py b/app/domain/auth.py index 0231fbe2..b1904786 100644 --- a/app/domain/auth.py +++ b/app/domain/auth.py @@ -1,3 +1,4 @@ +from redis.asyncio import Redis from sqlalchemy.ext.asyncio import AsyncSession from app.schemas.session import AuthSession @@ -6,49 +7,20 @@ from app.schemas.user import User async def create_session( session: AsyncSession, + redis: Redis, username: str, password: str, ttl_seconds: int, ) -> AuthSession: - """POST /auth/sessions (username/password уже извлечены из Basic в endpoints). - - Алгоритм: - 1. user = await storage.users.get_user_by_username(session, username) - 2. если user is None: - await security.dummy_verify_password(password) - raise unauthorized_basic() - 3. если not await security.verify_password(password, user.password_hash): - raise unauthorized_basic() (тот же ответ, что и в п.2) - 4. token = security.generate_token(); token_hash = security.hash_token(token) - 5. expires_at = datetime.now(UTC) + timedelta(seconds=ttl_seconds) - 6. await storage.sessions.create_session(session, user_id=user.id, token_hash=..., expires_at=...) - await session.commit() - 7. return AuthSession(token=token, expires_at=expires_at, user=to_user_schema(user)) - (токен показывается клиенту ровно один раз) - """ - raise NotImplementedError("TODO") + """Проверяет учётные данные и выдаёт новый Bearer-токен.""" + raise NotImplementedError -async def authenticate_token(session: AsyncSession, token: str) -> User: - """Bearer-токен -> текущий пользователь (dependency на всех бизнес-endpoint). - - Алгоритм: - 1. user = await storage.sessions.get_user_by_active_token_hash( - session, security.hash_token(token), datetime.now(UTC)) - 2. user is None (неизвестен/истёк/отозван) -> raise unauthorized_bearer() - 3. return to_user_schema(user) - Это AUTHENTICATION («кто ты»). «Можно ли тебе в этот чат» (AUTHORIZATION) — - отдельная проверка членства в domain.chats; посторонний получает 404, не 403. - """ - raise NotImplementedError("TODO") +async def authenticate_token(session: AsyncSession, redis: Redis, token: str) -> User: + """Возвращает владельца действующей сессии или бросает 401.""" + raise NotImplementedError -async def revoke_session(session: AsyncSession, token: str) -> None: - """DELETE /auth/sessions/current. - - Алгоритм: - 1. revoked = await storage.sessions.revoke_session(session, security.hash_token(token), datetime.now(UTC)) - 2. not revoked -> raise unauthorized_bearer() (повторный logout = 401) - 3. await session.commit() - """ - raise NotImplementedError("TODO") +async def revoke_session(redis: Redis, token: str) -> None: + """Отзывает текущую сессию; повторный отзыв даёт 401.""" + raise NotImplementedError diff --git a/app/endpoints/auth.py b/app/endpoints/auth.py index 40b3f371..aa8131ab 100644 --- a/app/endpoints/auth.py +++ b/app/endpoints/auth.py @@ -1,4 +1,5 @@ from fastapi import APIRouter, Depends, Response +from redis.asyncio import Redis from sqlalchemy.ext.asyncio import AsyncSession from app.core.config import Settings @@ -7,6 +8,7 @@ from app.endpoints.dependencies import ( get_basic_credentials, get_bearer_token, get_db, + get_redis, get_settings, ) from app.schemas.session import AuthSession @@ -18,16 +20,19 @@ router = APIRouter(prefix="/api/v1/auth", tags=["auth"]) async def login( credentials: tuple[str, str] = Depends(get_basic_credentials), session: AsyncSession = Depends(get_db), + redis: Redis = Depends(get_redis), settings: Settings = Depends(get_settings), ) -> AuthSession: username, password = credentials - return await create_session(session, username, password, settings.session_ttl_seconds) + return await create_session( + session, redis, username, password, settings.session_ttl_seconds + ) @router.delete("/sessions/current", status_code=204) async def logout( token: str = Depends(get_bearer_token), - session: AsyncSession = Depends(get_db), + redis: Redis = Depends(get_redis), ) -> Response: - await revoke_session(session, token) + await revoke_session(redis, token) return Response(status_code=204) diff --git a/app/endpoints/dependencies.py b/app/endpoints/dependencies.py index 1ff1e43d..b48d1906 100644 --- a/app/endpoints/dependencies.py +++ b/app/endpoints/dependencies.py @@ -3,6 +3,7 @@ import binascii from collections.abc import AsyncIterator from fastapi import Depends, Header, Request +from redis.asyncio import Redis from sqlalchemy.ext.asyncio import AsyncSession from app.core.config import Settings @@ -17,18 +18,17 @@ async def get_settings(request: Request) -> Settings: async def get_db(request: Request) -> AsyncIterator[AsyncSession]: - """Одна AsyncSession на HTTP-запрос. - - Если domain не вызвал commit, при выходе из `async with` транзакция - откатывается. FastAPI кэширует зависимость в рамках запроса, поэтому - get_current_user и endpoint получают одну и ту же сессию. - Одну сессию нельзя использовать в параллельных задачах (asyncio.gather). - """ + """Одна AsyncSession на HTTP-запрос; незакоммиченная транзакция откатывается.""" session_factory = request.app.state.session_factory async with session_factory() as session: yield session +async def get_redis(request: Request) -> Redis: + redis: Redis = request.app.state.redis + return redis + + def _split_authorization(authorization: str | None) -> tuple[str, str] | None: if authorization is None: return None @@ -48,11 +48,7 @@ async def get_bearer_token(authorization: str | None = Header(default=None)) -> async def get_basic_credentials( authorization: str | None = Header(default=None), ) -> tuple[str, str]: - """(username, password) из `Authorization: Basic base64(username:password)`. - - Делим только по первому ':' (пароль может содержать двоеточие). - Любая ошибка разбора даёт тот же 401, что и неверные учётные данные. - """ + """(username, password) из `Authorization: Basic`; пароль может содержать ':'.""" parts = _split_authorization(authorization) if parts is None or parts[0] != "basic": raise unauthorized_basic() @@ -71,5 +67,6 @@ async def get_basic_credentials( async def get_current_user( token: str = Depends(get_bearer_token), session: AsyncSession = Depends(get_db), + redis: Redis = Depends(get_redis), ) -> User: - return await authenticate_token(session, token) + return await authenticate_token(session, redis, token) diff --git a/app/endpoints/health.py b/app/endpoints/health.py index be6a62c8..d0e1a3f3 100644 --- a/app/endpoints/health.py +++ b/app/endpoints/health.py @@ -1,6 +1,7 @@ from fastapi import APIRouter, Request from app.core.database import check_database +from app.core.redis import check_redis from app.errors.exceptions import unavailable from app.schemas.base import Health @@ -16,4 +17,6 @@ async def liveness() -> Health: async def readiness(request: Request) -> Health: if not await check_database(request.app.state.engine): raise unavailable() + if not await check_redis(request.app.state.redis): + raise unavailable() return Health(status="ok") diff --git a/app/errors/handlers.py b/app/errors/handlers.py index 5788337e..9e53e44e 100644 --- a/app/errors/handlers.py +++ b/app/errors/handlers.py @@ -5,6 +5,8 @@ from uuid import uuid4 from fastapi import FastAPI, Request from fastapi.exceptions import RequestValidationError from fastapi.responses import JSONResponse +from redis.exceptions import ConnectionError as RedisConnectionError +from redis.exceptions import TimeoutError as RedisTimeoutError from sqlalchemy.exc import InterfaceError, OperationalError from sqlalchemy.exc import TimeoutError as PoolTimeoutError from starlette.exceptions import HTTPException as StarletteHTTPException @@ -113,19 +115,14 @@ async def validation_error_handler( ) -async def database_unavailable_handler( +async def dependency_unavailable_handler( request: Request, exc: Exception, ) -> JSONResponse: - """БД недоступна, оборвалась или исчерпан пул -> ограниченный 503. - - asyncpg при недоступной БД бросает «сырые» OSError/ConnectionError/TimeoutError, - SQLAlchemy их не оборачивает, поэтому обработчик зарегистрирован и на OSError. - Детали (хост, SQL, credentials) пишем только в лог, клиенту — общий текст. - """ + """PostgreSQL или Redis недоступны либо исчерпан пул: 503 без внутренних деталей.""" request_id = _get_request_id(request) logger.error( - "Database unavailable request_id=%s: %s", + "Dependency unavailable request_id=%s: %s", request_id, type(exc).__name__, exc_info=exc, @@ -167,8 +164,10 @@ def register_exception_handlers(app: FastAPI) -> None: app.add_exception_handler(ApiError, api_error_handler) app.add_exception_handler(StarletteHTTPException, routing_error_handler) app.add_exception_handler(RequestValidationError, validation_error_handler) - app.add_exception_handler(OperationalError, database_unavailable_handler) - app.add_exception_handler(InterfaceError, database_unavailable_handler) - app.add_exception_handler(PoolTimeoutError, database_unavailable_handler) - app.add_exception_handler(OSError, database_unavailable_handler) + app.add_exception_handler(OperationalError, dependency_unavailable_handler) + app.add_exception_handler(InterfaceError, dependency_unavailable_handler) + app.add_exception_handler(PoolTimeoutError, dependency_unavailable_handler) + app.add_exception_handler(RedisConnectionError, dependency_unavailable_handler) + app.add_exception_handler(RedisTimeoutError, dependency_unavailable_handler) + app.add_exception_handler(OSError, dependency_unavailable_handler) app.add_exception_handler(Exception, unhandled_error_handler) diff --git a/app/main.py b/app/main.py index 77719965..bce48d3f 100644 --- a/app/main.py +++ b/app/main.py @@ -1,5 +1,5 @@ import logging -from collections.abc import AsyncIterator +from collections.abc import AsyncGenerator from contextlib import asynccontextmanager import uvicorn @@ -7,6 +7,7 @@ from fastapi import Depends, FastAPI from app.core.config import Settings from app.core.database import create_db_engine, create_session_factory +from app.core.redis import create_redis_client from app.core.request_capacity import acquire_request_slot, create_request_capacity from app.core.request_id import RequestIdMiddleware from app.endpoints.auth import router as auth_router @@ -29,10 +30,12 @@ def create_app(settings: Settings | None = None) -> FastAPI: configure_logging(settings) engine = create_db_engine(settings) + redis = create_redis_client(settings) @asynccontextmanager - async def lifespan(_: FastAPI) -> AsyncIterator[None]: + async def lifespan(_: FastAPI) -> AsyncGenerator[None]: yield + await redis.aclose() await engine.dispose() application = FastAPI(title="Messenger", version="1.3.0", lifespan=lifespan) @@ -40,6 +43,7 @@ def create_app(settings: Settings | None = None) -> FastAPI: application.state.settings = settings application.state.engine = engine application.state.session_factory = create_session_factory(engine) + application.state.redis = redis application.state.request_capacity = create_request_capacity(settings.max_in_flight) application.add_middleware(RequestIdMiddleware) diff --git a/app/models/__init__.py b/app/models/__init__.py index 342d675e..3a3e380d 100644 --- a/app/models/__init__.py +++ b/app/models/__init__.py @@ -1,11 +1,7 @@ -"""Импорт всех моделей нужен, чтобы Base.metadata знала обо всех таблицах -(create_all в тестах, autogenerate в Alembic).""" - from app.models.base import Base from app.models.chat import Chat from app.models.chat_member import ChatMember from app.models.message import Message -from app.models.session import UserSession from app.models.user import User -__all__ = ["Base", "User", "Chat", "ChatMember", "Message", "UserSession"] +__all__ = ["Base", "User", "Chat", "ChatMember", "Message"] diff --git a/app/models/base.py b/app/models/base.py index 0f19ee8e..c902adec 100644 --- a/app/models/base.py +++ b/app/models/base.py @@ -15,12 +15,11 @@ NAMING_CONVENTION = { class Base(DeclarativeBase): - """Общий базовый класс всех ORM-моделей.""" + """Базовый класс ORM-моделей.""" metadata = MetaData(naming_convention=NAMING_CONVENTION) - # Python-типы в Mapped[...] -> типы PostgreSQL. type_annotation_map = { uuid.UUID: PG_UUID(as_uuid=True), - datetime: DateTime(timezone=True), # всегда timestamptz, время в UTC + datetime: DateTime(timezone=True), } diff --git a/app/models/chat.py b/app/models/chat.py index b7346592..ffff7ec2 100644 --- a/app/models/chat.py +++ b/app/models/chat.py @@ -1,22 +1,32 @@ import uuid +from datetime import datetime +from typing import TYPE_CHECKING -from sqlalchemy.orm import Mapped, mapped_column +from sqlalchemy import String, func +from sqlalchemy.orm import Mapped, mapped_column, relationship from app.models.base import Base +if TYPE_CHECKING: + from app.models.chat_member import ChatMember + from app.models.message import Message + class Chat(Base): - """Таблица chats. - - TODO: - * title: str(100), NOT NULL - * created_at: datetime(timezone), NOT NULL, server_default=now() - * relationship members -> ChatMember (cascade="all, delete-orphan"), - lazy="selectin": ОБЯЗАТЕЛЬНО в async (ленивой загрузки нет -> MissingGreenlet) - * индекс для GET /chats: см. storage.chats.list_chats_for_user - (подумайте, по каким колонкам идёт сортировка и фильтр по участнику) - """ + """Чат с фиксированным составом участников.""" __tablename__ = "chats" id: Mapped[uuid.UUID] = mapped_column(primary_key=True, default=uuid.uuid4) + title: Mapped[str] = mapped_column(String(100)) + created_at: Mapped[datetime] = mapped_column(server_default=func.now()) + + members: Mapped[list["ChatMember"]] = relationship( + back_populates="chat", + cascade="all, delete-orphan", + passive_deletes=True, + lazy="selectin", + ) + messages: Mapped[list["Message"]] = relationship( + back_populates="chat", lazy="raise" + ) diff --git a/app/models/chat_member.py b/app/models/chat_member.py index 0453219e..dcacdfe5 100644 --- a/app/models/chat_member.py +++ b/app/models/chat_member.py @@ -1,22 +1,28 @@ import uuid +from typing import TYPE_CHECKING -from sqlalchemy.orm import Mapped, mapped_column +from sqlalchemy import ForeignKey, Index +from sqlalchemy.orm import Mapped, mapped_column, relationship from app.models.base import Base +if TYPE_CHECKING: + from app.models.chat import Chat + from app.models.user import User + class ChatMember(Base): - """Таблица chat_members — членство пользователя в чате (many-to-many). - - TODO: - * chat_id: ForeignKey("chats.id", ondelete="CASCADE") - * user_id: ForeignKey("users.id") - * составной PRIMARY KEY (chat_id, user_id) — он же гарантирует отсутствие дублей - * индекс по user_id: нужен для «все чаты пользователя» - (PK (chat_id, user_id) этот запрос не ускоряет — объясните почему) - """ + """Членство пользователя в чате.""" __tablename__ = "chat_members" + __table_args__ = (Index("ix_chat_members_user_id_chat_id", "user_id", "chat_id"),) - chat_id: Mapped[uuid.UUID] = mapped_column(primary_key=True) - user_id: Mapped[uuid.UUID] = mapped_column(primary_key=True) + chat_id: Mapped[uuid.UUID] = mapped_column( + ForeignKey("chats.id", ondelete="CASCADE"), primary_key=True + ) + user_id: Mapped[uuid.UUID] = mapped_column( + ForeignKey("users.id"), primary_key=True + ) + + chat: Mapped["Chat"] = relationship(back_populates="members", lazy="raise") + user: Mapped["User"] = relationship(back_populates="memberships", lazy="raise") diff --git a/app/models/message.py b/app/models/message.py index 98fb3407..25dc8cf3 100644 --- a/app/models/message.py +++ b/app/models/message.py @@ -1,24 +1,30 @@ import uuid +from datetime import datetime +from typing import TYPE_CHECKING -from sqlalchemy.orm import Mapped, mapped_column +from sqlalchemy import ForeignKey, Index, Text, func +from sqlalchemy.orm import Mapped, mapped_column, relationship from app.models.base import Base +if TYPE_CHECKING: + from app.models.chat import Chat + from app.models.user import User + class Message(Base): - """Таблица messages. - - TODO: - * chat_id: ForeignKey("chats.id"), NOT NULL - * sender_id: ForeignKey("users.id"), NOT NULL - * text: Text, NOT NULL, CHECK (char_length(text) BETWEEN 1 AND 4000) - * created_at: datetime(timezone), NOT NULL, server_default=clock_timestamp() - (now() внутри одной транзакции постоянен — выберите осознанно) - * ИНДЕКС ИСТОРИИ: (chat_id, created_at, id) — ровно под keyset-запрос - WHERE chat_id = :c AND (created_at, id) > (:t, :i) ORDER BY created_at, id LIMIT :n - Для уровня 4 потребуется EXPLAIN (ANALYZE, BUFFERS) на >= 10 000 сообщений. - """ + """Сообщение в чате.""" __tablename__ = "messages" + __table_args__ = ( + Index("ix_messages_chat_id_created_at_id", "chat_id", "created_at", "id"), + ) id: Mapped[uuid.UUID] = mapped_column(primary_key=True, default=uuid.uuid4) + chat_id: Mapped[uuid.UUID] = mapped_column(ForeignKey("chats.id")) + sender_id: Mapped[uuid.UUID] = mapped_column(ForeignKey("users.id")) + text: Mapped[str] = mapped_column(Text) + created_at: Mapped[datetime] = mapped_column(server_default=func.clock_timestamp()) + + chat: Mapped["Chat"] = relationship(back_populates="messages", lazy="raise") + sender: Mapped["User"] = relationship(back_populates="messages", lazy="raise") diff --git a/app/models/session.py b/app/models/session.py deleted file mode 100644 index 6a6338f9..00000000 --- a/app/models/session.py +++ /dev/null @@ -1,23 +0,0 @@ -import uuid - -from sqlalchemy.orm import Mapped, mapped_column - -from app.models.base import Base - - -class UserSession(Base): - """Таблица sessions (класс назван UserSession, чтобы не путать с sqlalchemy Session). - - TODO: - * token_hash: str(64), NOT NULL, UNIQUE — sha256(token); сам токен не хранится - * user_id: ForeignKey("users.id", ondelete="CASCADE"), NOT NULL - * created_at: datetime(timezone), NOT NULL, server_default=now() - * expires_at: datetime(timezone), NOT NULL - * revoked_at: datetime(timezone), NULL — заполняется при logout - * индекс по expires_at — для фоновой очистки просроченных сессий - Сессия «действует», если revoked_at IS NULL AND expires_at > now(). - """ - - __tablename__ = "sessions" - - id: Mapped[uuid.UUID] = mapped_column(primary_key=True, default=uuid.uuid4) diff --git a/app/models/user.py b/app/models/user.py index e52e7918..74b690e6 100644 --- a/app/models/user.py +++ b/app/models/user.py @@ -1,21 +1,31 @@ import uuid +from datetime import datetime +from typing import TYPE_CHECKING -from sqlalchemy.orm import Mapped, mapped_column +from sqlalchemy import String, func +from sqlalchemy.orm import Mapped, mapped_column, relationship from app.models.base import Base +if TYPE_CHECKING: + from app.models.chat_member import ChatMember + from app.models.message import Message + class User(Base): - """Таблица users. - - TODO (колонки и ограничения — ваша работа, до написания запросов): - * username: str, UNIQUE, NOT NULL; CHECK по regex ^[a-z0-9_]{3,32}$ (по желанию) - * display_name: str(100), NOT NULL - * password_hash: str, NOT NULL (PHC-строка Argon2id; в API никогда не отдаётся) - * created_at: datetime(timezone), NOT NULL, server_default=now() - Отношения (relationship) добавляйте по необходимости. - """ + """Пользователь и его учётные данные.""" __tablename__ = "users" id: Mapped[uuid.UUID] = mapped_column(primary_key=True, default=uuid.uuid4) + username: Mapped[str] = mapped_column(String(32), unique=True) + display_name: Mapped[str] = mapped_column(String(100)) + password_hash: Mapped[str] = mapped_column(String(255)) + created_at: Mapped[datetime] = mapped_column(server_default=func.now()) + + memberships: Mapped[list["ChatMember"]] = relationship( + back_populates="user", lazy="raise" + ) + messages: Mapped[list["Message"]] = relationship( + back_populates="sender", lazy="raise" + ) diff --git a/app/schemas/base.py b/app/schemas/base.py index 4f86f81d..de59fc3b 100644 --- a/app/schemas/base.py +++ b/app/schemas/base.py @@ -5,7 +5,6 @@ from pydantic import BaseModel, ConfigDict, ValidationInfo, field_validator class Base(BaseModel): - # from_attributes: схемы можно собирать прямо из ORM-объектов. model_config = ConfigDict(extra="forbid", from_attributes=True) id: UUID @@ -20,7 +19,6 @@ class Health(BaseModel): class BaseCreate(BaseModel): model_config = ConfigDict(extra="forbid") - # Поля, где пробелы допустимы: пароль состоит из любых 12-128 code points. blank_allowed_fields: ClassVar[frozenset[str]] = frozenset({"password"}) @field_validator("*", mode="before") diff --git a/app/storage/sessions.py b/app/storage/sessions.py index d00f4de6..f5444585 100644 --- a/app/storage/sessions.py +++ b/app/storage/sessions.py @@ -1,66 +1,35 @@ from datetime import datetime from uuid import UUID -from sqlalchemy.ext.asyncio import AsyncSession +from redis.asyncio import Redis -from app.models.session import UserSession -from app.models.user import User +SESSION_KEY_PREFIX = "session:" + + +def session_key(token_hash: str) -> str: + return f"{SESSION_KEY_PREFIX}{token_hash}" async def create_session( - session: AsyncSession, + redis: Redis, *, - user_id: UUID, token_hash: str, + user_id: UUID, expires_at: datetime, -) -> UserSession: - """INSERT сессии (хранится только хеш токена) и flush. - - Алгоритм: - 1. row = UserSession(user_id=..., token_hash=..., expires_at=...) - 2. session.add(row); await session.flush(); return row - """ - raise NotImplementedError("TODO") +) -> None: + """Сохраняет сессию под хешем токена с абсолютным временем истечения.""" + raise NotImplementedError -async def get_user_by_active_token_hash( - session: AsyncSession, +async def get_session_user_id( + redis: Redis, token_hash: str, now: datetime, -) -> User | None: - """Пользователь по хешу токена, если сессия действует. - - Алгоритм: - 1. stmt = select(User).join(UserSession, UserSession.user_id == User.id) - .where(UserSession.token_hash == token_hash, - UserSession.revoked_at.is_(None), - UserSession.expires_at > now) - 2. result = await session.execute(stmt); return result.scalar_one_or_none() - Истёкший, отозванный и неизвестный токен неразличимы для вызывающего (None). - `now` передаётся параметром (а не SQL now()), чтобы тесты управляли временем. - """ - raise NotImplementedError("TODO") +) -> UUID | None: + """ID владельца действующей сессии; None для неизвестной или истёкшей.""" + raise NotImplementedError -async def revoke_session(session: AsyncSession, token_hash: str, now: datetime) -> bool: - """Помечает действующую сессию отозванной. - - Алгоритм: - 1. stmt = update(UserSession) - .where(UserSession.token_hash == token_hash, - UserSession.revoked_at.is_(None), - UserSession.expires_at > now) - .values(revoked_at=now) - 2. result = await session.execute(stmt) - 3. return result.rowcount == 1 - Один атомарный UPDATE: два параллельных logout не отзовут сессию дважды. - """ - raise NotImplementedError("TODO") - - -async def delete_expired_sessions(session: AsyncSession, now: datetime) -> int: - """(Необязательно) удаляет просроченные сессии, возвращает их число. - - Алгоритм: delete(UserSession).where(UserSession.expires_at <= now) -> rowcount. - """ - raise NotImplementedError("TODO") +async def delete_session(redis: Redis, token_hash: str) -> bool: + """Удаляет сессию; True, если она существовала.""" + raise NotImplementedError diff --git a/compose.yaml b/compose.yaml index 40bae0b0..5c74bde3 100644 --- a/compose.yaml +++ b/compose.yaml @@ -16,6 +16,31 @@ services: timeout: 3s retries: 10 + redis: + image: redis:7.4.2-bookworm + restart: unless-stopped + environment: + REDIS_PASSWORD: ${REDIS_PASSWORD} + command: + - sh + - -c + - >- + exec redis-server + --appendonly yes + --appendfsync always + --maxmemory 256mb + --maxmemory-policy noeviction + --requirepass "$$REDIS_PASSWORD" + volumes: + - redisdata:/data + ports: + - "127.0.0.1:6379:6379" + healthcheck: + test: ["CMD-SHELL", "redis-cli -a \"$$REDIS_PASSWORD\" --no-auth-warning ping | grep -q PONG"] + interval: 5s + timeout: 3s + retries: 10 + migrate: build: . image: mtusi-messenger:lab2 @@ -36,8 +61,11 @@ services: depends_on: postgres: condition: service_healthy + redis: + condition: service_healthy migrate: condition: service_completed_successfully volumes: - pgdata: \ No newline at end of file + pgdata: + redisdata: \ No newline at end of file diff --git a/requirements.txt b/requirements.txt index c677d4d3..291f2ada 100644 --- a/requirements.txt +++ b/requirements.txt @@ -42,7 +42,8 @@ typing_extensions==4.16.0 urllib3==2.8.0 uvicorn==0.54.0 asyncpg -argon2-cffi +argon2-cffi==25.1.0 +redis==8.1.0 greenlet pydantic-settings pytest-asyncio