added a session storage policy in Redis

This commit is contained in:
2026-10-25 02:14:56 +03:00
parent 7b7ca1b888
commit 76b34fca4b
21 changed files with 271 additions and 247 deletions
+11 -2
View File
@@ -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
+11 -1
View File
@@ -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
+38
View File
@@ -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
+32 -45
View File
@@ -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()
+10 -38
View File
@@ -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
+8 -3
View File
@@ -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)
+10 -13
View File
@@ -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)
+3
View File
@@ -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")
+11 -12
View File
@@ -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)
+6 -2
View File
@@ -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)
+1 -5
View File
@@ -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"]
+2 -3
View File
@@ -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),
}
+21 -11
View File
@@ -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"
)
+18 -12
View File
@@ -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")
+19 -13
View File
@@ -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")
-23
View File
@@ -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)
+20 -10
View File
@@ -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"
)
-2
View File
@@ -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")
+19 -50
View File
@@ -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
+29 -1
View File
@@ -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:
pgdata:
redisdata:
+2 -1
View File
@@ -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