ЛР 2 - БПИ2302 - Максимова - на 5 #9

Closed
kleprer wants to merge 15 commits from kleprer/mtusi2026lab2:solution/БПИ2302-Максимова into master
39 changed files with 2116 additions and 29 deletions
+12 -4
View File
@@ -1,11 +1,19 @@
# Copy to .env for your LOCAL synthetic test environment; never commit .env.
# These are logical interface suggestions; map actual framework names in REPORT.md.
APP_HOST=0.0.0.0
APP_PORT=8080
APP_ENV=lab
SESSION_TTL_SECONDS=3600
# Choose credentials locally. File paths contain no secret values.
DATABASE_URL_FILE=/run/secrets/database_url
# Optional on 3, required use on 4 in lab2; Redis OR Valkey:
# Storage / session backend
SESSION_STORE=postgres
CACHE_URL_FILE=/run/secrets/cache_url
# PostgreSQL (used by both postgres service and api)
POSTGRES_USER=messenger
POSTGRES_PASSWORD=replace-with-local-password
POSTGRES_DB=messenger
# Connection URLs for api service
DATABASE_URL=postgresql+asyncpg://messenger:replace-with-local-password@postgres:5432/messenger
REDIS_URL=redis://redis:6379/0
+2 -2
View File
@@ -28,5 +28,5 @@ coverage/
.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.
evidence/track1.json
evidence/track1_run.log
+27
View File
@@ -0,0 +1,27 @@
# syntax=docker/dockerfile:1.7
FROM python:3.11.9-slim AS builder
WORKDIR /build
COPY requirements.txt .
RUN pip install --no-cache-dir --user -r requirements.txt
FROM python:3.11.9-slim
RUN useradd -m -u 10001 appuser
WORKDIR /app
COPY --from=builder /root/.local /home/appuser/.local
COPY app ./app
COPY migrations ./migrations
COPY alembic.ini .
ENV PATH=/home/appuser/.local/bin:$PATH \
PYTHONUNBUFFERED=1 \
PYTHONDONTWRITEBYTECODE=1
RUN chown -R appuser:appuser /app
USER appuser
EXPOSE 8080
HEALTHCHECK --interval=30s --timeout=3s --start-period=20s --retries=5 \
CMD python -c "import urllib.request,sys; sys.exit(0 if urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=2).status==200 else 1)"
CMD ["sh", "-c", "alembic upgrade head && python -m app.main"]
+170 -23
View File
@@ -1,37 +1,184 @@
# Отчёт — лабораторная 2
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- Автор, группа: Максимова Снежана, БПИ2302
- Целевая оценка: 5, трек A (согласованность кэша)
- Commit/PR:
- Источники и ИИ: FastAPI 0.110.0, SQLAlchemy 2.0.29 (async), asyncpg 0.29.0,
Alembic 1.13.1, bcrypt 4.1.2, redis-py 5.0.3, Pydantic 2.6.4. ИИ использовался
для черновика кода, финальный код проверен вручную.
## Запуск из чистого clone
## 1. Что изменилось относительно lab1
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
В lab1 сервер держал всё состояние в памяти процесса и терял его при
перезапуске. В lab2 задача — сделать данные и сессии долговечными, а также
заменить учебный `X-User-Id` на настоящую аутентификацию.
## Архитектура и решения
Конкретные переходы API между лабами (объявлены в `COURSE.md`):
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
| Что | Lab1 | Lab2 |
|---------------|-------------------------|----------------------------------------|
| Хранилище | `dict` в памяти | PostgreSQL |
| Идентификация | `X-User-Id: <uuid>` | `Authorization: Bearer <token>` |
| Регистрация | `username, display_name`| `+ password` (12–128 символов) |
| Логин | нет | `POST /auth/sessions` (Basic → Bearer) |
| Logout | нет | `DELETE /auth/sessions/current` |
| Сессии | нет | TTL через `SESSION_TTL_SECONDS` |
## Доказательства критериев
Код приложения перенесён из lab1 и переработан: `main.py` переписан под
PostgreSQL, `storage.py` удалён, добавлены `db/`, `repositories/`, `auth.py`.
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
## 2. Архитектура
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
Клиент → API (FastAPI + uvicorn) → PostgreSQL + Redis.
## Эксперименты и отказы
- **PostgreSQL** — пользователи, чаты, членство, сообщения.
- **Redis** — быстрый слой для сессий (с TTL) и кэша первой страницы истории.
- **Alembic** — версионируемые миграции схемы.
- **Docker Compose** — единый локальный запуск: `postgres`, `redis`, `api`.
- API работает под непривилегированным пользователем `appuser` (UID 10001),
слушает `0.0.0.0:8080`, PID 1 — uvicorn.
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
## 3. Схема БД
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
| Таблица | Поля | Ключи | Индекс |
|---------------|-------------------------------------------------------|----------------------------------|-----------------------------|
| `users` | id, username, display_name, password_hash, created_at | username UNIQUE | `idx_users_username` |
| `chats` | id, title, created_at | — | `idx_chats_created_id` |
| `chat_members`| chat_id, user_id | PK(chat_id, user_id), FK CASCADE | `idx_chat_members_user` |
| `messages` | id, chat_id, sender_id, text, created_at | FK CASCADE |`idx_messages_chat_created_id`|
| `sessions` | id, user_id, token_hash, expires_at, created_at | token_hash UNIQUE | `idx_sessions_token`, |
| | | `idx_sessions_expires` |
## Ограничения и следующие шаги
**Почему такие индексы:**
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
- `idx_messages_chat_created_id(chat_id, created_at, id)` — ключевой для пагинации. Запрос истории всегда фильтрует по `chat_id` и
сортирует по `(created_at, id)`. Составной индекс покрывает обе операции.
- `idx_chat_members_user` — для «списка чатов пользователя».
- `idx_chats_created_id` — для keyset-пагинации в `GET /chats`.
- `idx_sessions_token` — поиск сессии на каждом защищённом запросе.
**Транзакционные границы:**
- **Регистрация** — одна транзакция. От гонки на одинаковый username защищает
UNIQUE-constraint: второй параллельный запрос получает `IntegrityError`,
который превращается в 409.
- **Создание чата с участниками** — одна транзакция: сначала проверяем, что все
`member_ids` существуют, затем `INSERT` чата, потом `INSERT` участников. Если
хотя бы один участник не существует — `rollback`, ничего не создаётся.
- **Отправка сообщения** — одна транзакция.
## 4. Идентификация и сессии
- **Регистрация** принимает `password` (12–128 code points). Пароль хешируется
через **bcrypt(SHA-256(password))**. Предварительное SHA-256 снимает
ограничение bcrypt в 72 байта и проблему NUL-байт в дайджесте.
- **Basic** применяется только на `POST /auth/sessions`. Неверные credentials —
401 с `WWW-Authenticate: Basic realm="messenger", charset="UTF-8"`.
- **Bearer** — все остальные endpoint. Токен — opaque, 32 байта энтропии
(`secrets.token_urlsafe(32)`). В Redis хранится `session:<sha256(token)>` →
`user_id` с TTL = `SESSION_TTL_SECONDS`.
- **Logout** удаляет ключ из Redis. Повторный вызов с тем же токеном — 401.
- **`X-User-Id` игнорируется** — он не даёт доступ к бизнес-эндпоинтам.
## 5. Доказательства критериев
| Критерий | Команда | Результат |
|----------------------|-------------------------------------------------|---------------------------|
| Публичный smoke | `python tests\smoke.py` | PASS |
| Persistence | `python tests\resilience.py --mode persistence` | PASS |
| Concurrent (100/100) | `python student-tests\concurrent_test.py` | PASS |
| Rollback и race | `pytest student-tests/` | 3 passed |
| Non-root | `docker inspect Config.User` | `10001` |
| SIGTERM ≤ 10 c | `docker stop` | ~1 c |
| Healthcheck | `docker ps` | `Up (healthy)` |
| EXPLAIN с индексом | `EXPLAIN (ANALYZE, BUFFERS)` | Index Scan, 0.069 ms |
| EXPLAIN без индекса | `enable_indexscan=off` | Seq Scan + Sort, 1.398 ms |
| Session expiry | `SESSION_TTL_SECONDS=2` | 401 после TTL |
| Трек A | `scripts\track_a_bench.py` | SQL 301 → 1 |
## 6. Эксперименты
### 6.1. Обоснование индекса истории
**Зачем измеряли.** README lab2 требует: «Индекс истории обоснован запросом и
EXPLAIN (ANALYZE, BUFFERS) на ≥10 000 сообщениях; пагинация не использует
полный scan всей истории на каждую страницу.» Мы засеяли чат 8 837 сообщений
через `scripts/seed_10k.py` и сняли план для запроса истории.
**Результаты:**
| План | Buffers | Execution Time | Что делает |
|-----------------------------------------------------|---------|----------------|-------------------------------------|
| **Index Scan** using `idx_messages_chat_created_id` | **3** | **0.069 ms** | идёт напрямую по индексу |
| Seq Scan + Sort (индекс выключен) | 116 | 1.398 ms | читает всю таблицу, потом сортирует |
**Вывод:** составной индекс `(chat_id, created_at, id)` делает чтение страницы
`O(limit)`, а не `O(n log n)`. Разница по чтению страниц — **~38×**, по времени
— **~20×**. С ростом объёма разрыв увеличивается линейно.
### 6.2. Session expiry
README требует «автоматическая проверка expiry при коротком
SESSION_TTL_SECONDS».
**Методика.** `SESSION_TTL_SECONDS=2`, пересоздали api, создали сессию,
сразу же проверили `GET /users/me` (200), подождали 4 секунды, снова проверили
с тем же токеном.
**Результат:**
| Момент | Ответ |
|--------------------|------------------------------------------------|
| сразу после логина | 200 |
| через 4 секунды | 401 `{"error": {"code": "unauthorized", ...}}` |
Это подтверждает: TTL работает, истёкший токен отвергается.
### 6.3. Трек A — кэш первой страницы истории
**Гипотеза.** Если кэшировать первую страницу истории в Redis, повторные
чтения не будут обращаться к БД. Инвалидация при вставке нового сообщения
(`create_and_invalidate`) гарантирует, что следующий GET после POST видит
новое сообщение (read-after-write).
**Методика.** `scripts/track_a_bench.py` засеивает чат N сообщениями, затем
делает M последовательных GET первой страницы. Число SQL-запросов к `messages`
считается через `pg_stat_statements` (`pg_stat_statements_reset()` до замера,
чтение счётчика после). Два прогона: с `list_page` (без кэша) и с
`list_page_cached` + `create_and_invalidate`.
**Результаты (N=1000, M=300):**
| Метрика | До кэша | После кэша | Изменение |
|---------------------------|---------|------------|---------------|
| SQL-запросов к `messages` | **301** | **1** | ×301 меньше |
| p50, ms | 30.15 | 30.88 | без изменений |
| p95, ms | 34.92 | 33.55 | −4% |
| RPS | 40.65 | 35.39 | −13% |
**Что это значит.**
- Кэш **сократил обращения к БД в 301 раз**: 300 GET → 1 SELECT
- **Latency и RPS не улучшились**, потому что на этом профиле SQL-запрос уже
занимает 0.07 ms (по EXPLAIN), а Redis-roundtrip + JSON-сериализация
сравнимы или превышают сэкономленное время. Снижение RPS на 13% — прямое
следствие этого: кэш добавляет работу, которую SQL-запрос не оправдывает.
- **Кэш первой страницы — оптимизация нагрузки на БД, не скорости клиента.**
Эффект по latency проявился бы при росте датасета до 100k+, отсутствии
индекса, либо при конкуренции, упирающейся в connection pool Postgres.
На текущем профиле главная польза — разгрузка БД.
## 7. Что пришлось чинить в процессе
- **`async with db.begin()` конфликтует с неявной транзакцией.** В async
SQLAlchemy любой `await db.execute(...)` уже открывает транзакцию. Если
до этого сработал `Depends(get_current_user)` с SELECT, `db.begin()`
падает с `InvalidRequestError`. Решение: явный `try: commit / except: rollback`
без `db.begin()`.
- **bcrypt и NUL-байты.** `sha256(...).digest()` иногда содержит `\x00`,
и bcrypt отказывается с этим работать. Решение: `hexdigest()` — только
`[0-9a-f]`, 64 безопасных символа.
- **httpx через docker-proxy на Windows.** Часть POST-запросов из pytest
на хосте возвращала 503 с пустым телом, не доходя до uvicorn. `urllib`
и запуск тестов изнутри контейнера работают стабильно. Решение: собственные
тесты переведены на `urllib` — это описано в `student-tests/test_rollback.py`.
+114
View File
@@ -0,0 +1,114 @@
# A generic, single database configuration.
[alembic]
# path to migration scripts
script_location = migrations
# template used to generate migration file names; The default value is %%(rev)s_%%(slug)s
# Uncomment the line below if you want the files to be prepended with date and time
# file_template = %%(year)d_%%(month).2d_%%(day).2d_%%(hour).2d%%(minute).2d-%%(rev)s_%%(slug)s
# sys.path path, will be prepended to sys.path if present.
# defaults to the current working directory.
prepend_sys_path = .
# timezone to use when rendering the date within the migration file
# as well as the filename.
# If specified, requires the python>=3.9 or backports.zoneinfo library.
# Any required deps can installed by adding `alembic[tz]` to the pip requirements
# string value is passed to ZoneInfo()
# leave blank for localtime
# timezone =
# max length of characters to apply to the
# "slug" field
# truncate_slug_length = 40
# set to 'true' to run the environment during
# the 'revision' command, regardless of autogenerate
# revision_environment = false
# set to 'true' to allow .pyc and .pyo files without
# a source .py file to be detected as revisions in the
# versions/ directory
# sourceless = false
# version location specification; This defaults
# to migrations/versions. When using multiple version
# directories, initial revisions must be specified with --version-path.
# The path separator used here should be the separator specified by "version_path_separator" below.
# version_locations = %(here)s/bar:%(here)s/bat:migrations/versions
# version path separator; As mentioned above, this is the character used to split
# version_locations. The default within new alembic.ini files is "os", which uses os.pathsep.
# If this key is omitted entirely, it falls back to the legacy behavior of splitting on spaces and/or commas.
# Valid values for version_path_separator are:
#
# version_path_separator = :
# version_path_separator = ;
# version_path_separator = space
version_path_separator = os # Use os.pathsep. Default configuration used for new projects.
# set to 'true' to search source files recursively
# in each "version_locations" directory
# new in Alembic version 1.10
# recursive_version_locations = false
# the output encoding used when revision files
# are written from script.py.mako
# output_encoding = utf-8
sqlalchemy.url = driver://user:pass@localhost/dbname
[post_write_hooks]
# post_write_hooks defines scripts or Python functions that are run
# on newly generated revision scripts. See the documentation for further
# detail and examples
# format using "black" - use the console_scripts runner, against the "black" entrypoint
# hooks = black
# black.type = console_scripts
# black.entrypoint = black
# black.options = -l 79 REVISION_SCRIPT_FILENAME
# lint with attempts to fix using "ruff" - use the exec runner, execute a binary
# hooks = ruff
# ruff.type = exec
# ruff.executable = %(here)s/.venv/bin/ruff
# ruff.options = --fix REVISION_SCRIPT_FILENAME
# Logging configuration
[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
View File
+85
View File
@@ -0,0 +1,85 @@
import hashlib
import os
import secrets
from datetime import datetime, timezone
from uuid import UUID
import bcrypt
from fastapi import Depends, Header, HTTPException
from sqlalchemy import delete, select
from sqlalchemy.ext.asyncio import AsyncSession
from .db.models import SessionRow, User
from .db.session import get_db
import redis.asyncio as redis
redis_client = redis.from_url(os.getenv("REDIS_URL", "redis://redis:6379/0"))
SESSION_TTL = int(os.getenv("SESSION_TTL_SECONDS", "3600"))
def _prehash(password: str) -> bytes:
# bcrypt работает с ≤72 байт, SHA-256 даёт 32 байта и снимает ограничение
return hashlib.sha256(password.encode("utf-8")).hexdigest().encode("ascii")
def hash_password(password: str) -> str:
return bcrypt.hashpw(_prehash(password), bcrypt.gensalt(rounds=12)).decode("ascii")
def verify_password(password: str, password_hash: str) -> bool:
try:
return bcrypt.checkpw(_prehash(password), password_hash.encode("ascii"))
except ValueError:
return False
def generate_token() -> str:
return secrets.token_urlsafe(32)
def hash_token(token: str) -> str:
return hashlib.sha256(token.encode("ascii")).hexdigest()
def _unauthorized_bearer() -> HTTPException:
return HTTPException(
status_code=401,
detail="Unauthorized",
headers={"WWW-Authenticate": 'Bearer realm="messenger"'},
)
async def create_session(user_id: str) -> str:
token = generate_token()
await redis_client.setex(
f"session:{hash_token(token)}", SESSION_TTL, str(user_id)
)
return token
async def get_current_user(
authorization: str | None = Header(None, alias="Authorization"),
db: AsyncSession = Depends(get_db),
) -> User:
if not authorization or not authorization.startswith("Bearer "):
raise _unauthorized_bearer()
token = authorization[7:]
token_hash = hash_token(token)
user_id_raw = await redis_client.get(f"session:{token_hash}")
if user_id_raw is None:
raise _unauthorized_bearer()
user = await db.get(User, UUID(user_id_raw.decode()))
if user is None:
raise _unauthorized_bearer()
return user
async def revoke_current_session(authorization: str, db: AsyncSession) -> None:
if not authorization or not authorization.startswith("Bearer "):
raise _unauthorized_bearer()
token = authorization[7:]
deleted = await redis_client.delete(f"session:{hash_token(token)}")
if deleted == 0:
raise _unauthorized_bearer()
View File
+5
View File
@@ -0,0 +1,5 @@
from sqlalchemy.orm import DeclarativeBase
class Base(DeclarativeBase):
pass
+100
View File
@@ -0,0 +1,100 @@
from datetime import datetime, timezone
from uuid import UUID, uuid4
from sqlalchemy import DateTime, ForeignKey, Index, String, Text
from sqlalchemy.dialects.postgresql import UUID as PG_UUID
from sqlalchemy.orm import Mapped, mapped_column
from .base import Base
def _now() -> datetime:
return datetime.now(timezone.utc)
class User(Base):
__tablename__ = "users"
id: Mapped[UUID] = mapped_column(
PG_UUID(as_uuid=True), primary_key=True, default=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), default=_now, nullable=False
)
class Chat(Base):
__tablename__ = "chats"
id: Mapped[UUID] = mapped_column(
PG_UUID(as_uuid=True), primary_key=True, default=uuid4
)
title: Mapped[str] = mapped_column(String(100), nullable=False)
created_at: Mapped[datetime] = mapped_column(
DateTime(timezone=True), default=_now, nullable=False
)
__table_args__ = (Index("idx_chats_created_id", "created_at", "id"),)
class ChatMember(Base):
__tablename__ = "chat_members"
chat_id: Mapped[UUID] = mapped_column(
PG_UUID(as_uuid=True),
ForeignKey("chats.id", ondelete="CASCADE"),
primary_key=True,
)
user_id: Mapped[UUID] = mapped_column(
PG_UUID(as_uuid=True),
ForeignKey("users.id", ondelete="CASCADE"),
primary_key=True,
)
__table_args__ = (Index("idx_chat_members_user", "user_id", "chat_id"),)
class Message(Base):
__tablename__ = "messages"
id: Mapped[UUID] = mapped_column(
PG_UUID(as_uuid=True), primary_key=True, default=uuid4
)
chat_id: Mapped[UUID] = mapped_column(
PG_UUID(as_uuid=True),
ForeignKey("chats.id", ondelete="CASCADE"),
nullable=False,
)
sender_id: Mapped[UUID] = mapped_column(
PG_UUID(as_uuid=True), ForeignKey("users.id"), nullable=False
)
text: Mapped[str] = mapped_column(Text, nullable=False)
created_at: Mapped[datetime] = mapped_column(
DateTime(timezone=True), default=_now, nullable=False
)
__table_args__ = (
Index("idx_messages_chat_created_id", "chat_id", "created_at", "id"),
)
class SessionRow(Base):
__tablename__ = "sessions"
id: Mapped[UUID] = mapped_column(
PG_UUID(as_uuid=True), primary_key=True, default=uuid4
)
user_id: Mapped[UUID] = mapped_column(
PG_UUID(as_uuid=True),
ForeignKey("users.id", ondelete="CASCADE"),
nullable=False,
)
token_hash: Mapped[str] = mapped_column(
String(64), unique=True, nullable=False, index=True
)
expires_at: Mapped[datetime] = mapped_column(
DateTime(timezone=True), nullable=False, index=True
)
created_at: Mapped[datetime] = mapped_column(
DateTime(timezone=True), default=_now, nullable=False
)
+31
View File
@@ -0,0 +1,31 @@
import os
from sqlalchemy.ext.asyncio import (
AsyncSession,
async_sessionmaker,
create_async_engine,
)
DATABASE_URL = os.getenv(
"DATABASE_URL",
"postgresql+asyncpg://messenger:strongpassword@localhost:5432/messenger",
)
engine = create_async_engine(
DATABASE_URL,
pool_size=10,
max_overflow=20,
pool_timeout=5,
pool_recycle=1800,
pool_pre_ping=True,
connect_args={"timeout": 5, "command_timeout": 10},
)
async_session = async_sessionmaker(
engine, class_=AsyncSession, expire_on_commit=False
)
async def get_db() -> AsyncSession:
async with async_session() as session:
yield session
+290
View File
@@ -0,0 +1,290 @@
import os
import uuid
from contextvars import ContextVar
from datetime import datetime, timedelta, timezone
from typing import Optional
from uuid import UUID
from fastapi import Depends, FastAPI, Header, HTTPException, Query, Request
from fastapi.exceptions import RequestValidationError
from fastapi.responses import JSONResponse
from fastapi.security import HTTPBasic, HTTPBasicCredentials
from sqlalchemy import text
from sqlalchemy.ext.asyncio import AsyncSession
from starlette.middleware.base import BaseHTTPMiddleware
from .auth import (
SESSION_TTL,
create_session,
generate_token,
get_current_user,
hash_password,
hash_token,
revoke_current_session,
verify_password,
)
from .db.models import SessionRow, User
from .db.session import get_db
from .models import CreateChat, CreateMessage, CreateUser
from .repositories import chats as chats_repo
from .repositories import messages as messages_repo
from .repositories import users as users_repo
request_id_var: ContextVar[str] = ContextVar("request_id", default="")
_HTTP_CODES = {
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",
}
def err_json(status: int, code: str, message: str) -> JSONResponse:
return JSONResponse(
status_code=status,
content={
"error": {
"code": code,
"message": message,
"request_id": request_id_var.get(),
}
},
)
class RequestIdMiddleware(BaseHTTPMiddleware):
async def dispatch(self, request: Request, call_next):
rid = request.headers.get("X-Request-Id") or uuid.uuid4().hex
request_id_var.set(rid)
response = await call_next(request)
response.headers["X-Request-Id"] = rid
return response
app = FastAPI(title="MTUSI Messenger — lab2")
app.add_middleware(RequestIdMiddleware)
security = HTTPBasic(auto_error=False)
@app.exception_handler(RequestValidationError)
async def _validation(request: Request, exc: RequestValidationError):
return err_json(400, "invalid_request", "Validation error")
@app.exception_handler(HTTPException)
async def _http(request: Request, exc: HTTPException):
code = _HTTP_CODES.get(exc.status_code, "internal_error")
detail = exc.detail if isinstance(exc.detail, str) else "Error"
resp = err_json(exc.status_code, code, detail)
if exc.headers:
for k, v in exc.headers.items():
resp.headers[k] = v
return resp
@app.exception_handler(Exception)
async def _generic(request: Request, exc: Exception):
return err_json(500, "internal_error", "Internal server error")
def _iso_z(dt: datetime) -> str:
return dt.isoformat().replace("+00:00", "Z")
def _user_json(u: User) -> dict:
return {
"id": str(u.id),
"username": u.username,
"display_name": u.display_name,
"created_at": _iso_z(u.created_at),
}
def _chat_json(chat, member_ids: list[str]) -> dict:
return {
"id": str(chat.id),
"title": chat.title,
"member_ids": member_ids,
"created_at": _iso_z(chat.created_at),
}
def _msg_json(m) -> dict:
return {
"id": str(m.id),
"chat_id": str(m.chat_id),
"sender_id": str(m.sender_id),
"text": m.text,
"created_at": _iso_z(m.created_at),
}
# ---------- health ----------
@app.get("/health/live")
def live():
return {"status": "ok"}
@app.get("/health/ready")
async def ready(db: AsyncSession = Depends(get_db)):
try:
await db.execute(text("SELECT 1"))
except Exception:
return err_json(503, "unavailable", "Database unavailable")
return {"status": "ok"}
# ---------- users ----------
@app.post("/api/v1/users", status_code=201)
async def register(body: CreateUser, db: AsyncSession = Depends(get_db)):
existing = await users_repo.get_by_username(db, body.username)
if existing is not None:
raise HTTPException(409, "Username already exists")
try:
user = await users_repo.create(
db, body.username, body.display_name, hash_password(body.password)
)
except Exception:
raise HTTPException(409, "Username already exists")
return _user_json(user)
# ---------- sessions ----------
@app.post("/api/v1/auth/sessions", status_code=201)
async def login(
creds: Optional[HTTPBasicCredentials] = Depends(security),
db: AsyncSession = Depends(get_db),
):
basic_challenge = 'Basic realm="messenger", charset="UTF-8"'
if creds is None:
raise HTTPException(
status_code=401, detail="Unauthorized", headers={"WWW-Authenticate": basic_challenge}
)
user = await users_repo.get_by_username(db, creds.username)
if user is None or not verify_password(creds.password, user.password_hash):
raise HTTPException(
status_code=401, detail="Unauthorized", headers={"WWW-Authenticate": basic_challenge}
)
expires = datetime.now(timezone.utc) + timedelta(seconds=SESSION_TTL)
token = await create_session(str(user.id))
return {
"token": token,
"token_type": "Bearer",
"expires_at": _iso_z(expires),
"user": _user_json(user),
}
@app.delete("/api/v1/auth/sessions/current", status_code=204)
async def logout(authorization: str = Header(...), db: AsyncSession = Depends(get_db)):
await revoke_current_session(authorization, db)
@app.get("/api/v1/users/me")
async def me(user: User = Depends(get_current_user)):
return _user_json(user)
# ---------- chats ----------
@app.post("/api/v1/chats", status_code=201)
async def create_chat(
body: CreateChat,
user: User = Depends(get_current_user),
db: AsyncSession = Depends(get_db),
):
if user.id not in body.member_ids:
raise HTTPException(400, "Caller must be in member_ids")
try:
chat = await chats_repo.create_atomic(db, body.title, body.member_ids)
except ValueError:
raise HTTPException(404, "Member not found")
return _chat_json(chat, [str(x) for x in body.member_ids])
@app.get("/api/v1/chats")
async def list_chats(
user: User = Depends(get_current_user),
limit: int = Query(50, ge=1, le=100),
cursor: Optional[str] = Query(None, min_length=1),
db: AsyncSession = Depends(get_db),
):
parsed = None
if cursor is not None:
try:
c_created, c_id = cursor.split("|", 1)
parsed = (datetime.fromisoformat(c_created), UUID(c_id))
except Exception:
raise HTTPException(400, "Invalid cursor")
rows, next_cursor = await chats_repo.list_for_user(db, user.id, limit, parsed)
items = []
for chat in rows:
members = await chats_repo.list_member_ids(db, chat.id)
items.append(_chat_json(chat, [str(m) for m in members]))
nxt = f"{next_cursor[0].isoformat()}|{next_cursor[1]}" if next_cursor else None
return {"items": items, "next_cursor": nxt}
@app.get("/api/v1/chats/{chat_id}")
async def get_chat(
chat_id: UUID,
user: User = Depends(get_current_user),
db: AsyncSession = Depends(get_db),
):
chat = await chats_repo.get_if_member(db, chat_id, user.id)
if chat is None:
raise HTTPException(404, "Chat not found")
members = await chats_repo.list_member_ids(db, chat.id)
return _chat_json(chat, [str(m) for m in members])
# ---------- messages ----------
@app.post("/api/v1/chats/{chat_id}/messages", status_code=201)
async def post_message(
chat_id: UUID,
body: CreateMessage,
user: User = Depends(get_current_user),
db: AsyncSession = Depends(get_db),
):
chat = await chats_repo.get_if_member(db, chat_id, user.id)
if chat is None:
raise HTTPException(404, "Chat not found")
msg = await messages_repo.create(db, chat_id, user.id, body.text)
return _msg_json(msg)
@app.get("/api/v1/chats/{chat_id}/messages")
async def list_messages(
chat_id: UUID,
user: User = Depends(get_current_user),
limit: int = Query(50, ge=1, le=100),
cursor: Optional[str] = Query(None, min_length=1),
db: AsyncSession = Depends(get_db),
):
chat = await chats_repo.get_if_member(db, chat_id, user.id)
if chat is None:
raise HTTPException(404, "Chat not found")
parsed = None
if cursor is not None:
try:
c_created, c_id = cursor.split("|", 1)
parsed = (datetime.fromisoformat(c_created), UUID(c_id))
except Exception:
raise HTTPException(400, "Invalid cursor")
rows, next_cursor = await messages_repo.list_page(db, chat_id, limit, parsed)
nxt = f"{next_cursor[0].isoformat()}|{next_cursor[1]}" if next_cursor else None
return {"items": [_msg_json(m) for m in rows], "next_cursor": nxt}
if __name__ == "__main__":
import uvicorn
uvicorn.run(app, host="0.0.0.0", port=int(os.getenv("APP_PORT", "8080")))
+56
View File
@@ -0,0 +1,56 @@
from uuid import UUID
from pydantic import BaseModel, ConfigDict, Field, field_validator
class CreateUser(BaseModel):
model_config = ConfigDict(extra="forbid")
username: str = Field(pattern=r"^[a-z0-9_]{3,32}$")
display_name: str = Field(min_length=1, max_length=100)
password: str = Field(min_length=12, max_length=128)
@field_validator("display_name", "password")
@classmethod
def _not_blank(cls, v: str) -> str:
if not v.strip():
raise ValueError("must not be blank")
return v
class CreateChat(BaseModel):
model_config = ConfigDict(extra="forbid")
title: str = Field(min_length=1, max_length=100)
member_ids: list[UUID] = Field(min_length=1, max_length=100)
@field_validator("title")
@classmethod
def _title_not_blank(cls, v: str) -> str:
if not v.strip():
raise ValueError("title must not be blank")
return v
@field_validator("member_ids")
@classmethod
def _unique_members(cls, v: list[UUID]) -> list[UUID]:
if len(set(v)) != len(v):
raise ValueError("duplicate member_ids")
return v
class CreateMessage(BaseModel):
model_config = ConfigDict(extra="forbid")
text: str = Field(min_length=1, max_length=4000)
@field_validator("text")
@classmethod
def _text_not_blank(cls, v: str) -> str:
if not v.strip():
raise ValueError("text must not be blank")
return v
class SessionResponse(BaseModel):
token: str
token_type: str = "Bearer"
expires_at: str
user: dict
View File
+80
View File
@@ -0,0 +1,80 @@
from datetime import datetime
from uuid import UUID
from sqlalchemy import select
from sqlalchemy.ext.asyncio import AsyncSession
from ..db.models import Chat, ChatMember, User
async def create_atomic(
db: AsyncSession, title: str, member_ids: list[UUID]
) -> Chat:
found = (
(await db.execute(select(User.id).where(User.id.in_(member_ids))))
.scalars()
.all()
)
if len(set(found)) != len(set(member_ids)):
await db.rollback()
raise ValueError("member_not_found")
chat = Chat(title=title)
db.add(chat)
await db.flush()
for uid in member_ids:
db.add(ChatMember(chat_id=chat.id, user_id=uid))
try:
await db.commit()
except Exception:
await db.rollback()
raise
await db.refresh(chat)
return chat
async def get_if_member(
db: AsyncSession, chat_id: UUID, user_id: UUID
) -> Chat | None:
stmt = (
select(Chat)
.join(ChatMember, ChatMember.chat_id == Chat.id)
.where(Chat.id == chat_id, ChatMember.user_id == user_id)
)
return (await db.execute(stmt)).scalar_one_or_none()
async def list_member_ids(db: AsyncSession, chat_id: UUID) -> list[UUID]:
stmt = select(ChatMember.user_id).where(ChatMember.chat_id == chat_id)
return list((await db.execute(stmt)).scalars().all())
async def list_for_user(
db: AsyncSession,
user_id: UUID,
limit: int,
cursor: tuple[datetime, UUID] | None,
) -> tuple[list[Chat], tuple[datetime, UUID] | 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 is not None:
c_created, c_id = cursor
stmt = stmt.where(
(Chat.created_at > c_created)
| ((Chat.created_at == c_created) & (Chat.id > c_id))
)
rows = list((await db.execute(stmt)).scalars().all())
next_cursor = None
if len(rows) > limit:
rows = rows[:limit]
last = rows[-1]
next_cursor = (last.created_at, last.id)
return rows, next_cursor
+124
View File
@@ -0,0 +1,124 @@
import json
import os
from datetime import datetime
from types import SimpleNamespace
from uuid import UUID
import redis.asyncio as redis
from sqlalchemy import select
from sqlalchemy.ext.asyncio import AsyncSession
from ..db.models import Message
redis_client = redis.from_url(os.getenv("REDIS_URL", "redis://redis:6379/0"))
CACHE_TTL = 30
def _serialize(rows: list[Message], next_cursor):
return {
"items": [
{
"id": str(m.id),
"chat_id": str(m.chat_id),
"sender_id": str(m.sender_id),
"text": m.text,
"created_at": m.created_at.isoformat(),
}
for m in rows
],
"next_cursor": (
[next_cursor[0].isoformat(), str(next_cursor[1])] if next_cursor else None
),
}
def _deserialize(data: dict):
items = [
SimpleNamespace(
id=UUID(row["id"]),
chat_id=UUID(row["chat_id"]),
sender_id=UUID(row["sender_id"]),
text=row["text"],
created_at=datetime.fromisoformat(row["created_at"]),
)
for row in data["items"]
]
nc = data.get("next_cursor")
next_cursor = (datetime.fromisoformat(nc[0]), UUID(nc[1])) if nc else None
return items, next_cursor
async def create(
db: AsyncSession, chat_id: UUID, sender_id: UUID, text: str
) -> Message:
msg = Message(chat_id=chat_id, sender_id=sender_id, text=text)
db.add(msg)
await db.commit()
await db.refresh(msg)
return msg
async def create_and_invalidate(
db: AsyncSession, chat_id: UUID, sender_id: UUID, text: str
) -> Message:
msg = await create(db, chat_id, sender_id, text)
keys = [f"chat:{chat_id}:first_page:{n}" for n in (10, 20, 50)]
await redis_client.delete(*keys)
return msg
async def list_page(
db: AsyncSession,
chat_id: UUID,
limit: int,
cursor: tuple[datetime, UUID] | None,
) -> tuple[list[Message], tuple[datetime, UUID] | None]:
stmt = (
select(Message)
.where(Message.chat_id == chat_id)
.order_by(Message.created_at.asc(), Message.id.asc())
.limit(limit + 1)
)
if cursor is not None:
c_created, c_id = cursor
stmt = stmt.where(
(Message.created_at > c_created)
| ((Message.created_at == c_created) & (Message.id > c_id))
)
rows = list((await db.execute(stmt)).scalars().all())
next_cursor = None
if len(rows) > limit:
rows = rows[:limit]
last = rows[-1]
next_cursor = (last.created_at, last.id)
return rows, next_cursor
async def list_page_cached(
db: AsyncSession,
chat_id: UUID,
limit: int,
cursor: tuple[datetime, UUID] | None,
) -> tuple[list, tuple[datetime, UUID] | None, bool]:
"""Возвращает (rows, next_cursor, cached)."""
use_cache = cursor is None and limit <= 50
key = f"chat:{chat_id}:first_page:{limit}"
if use_cache:
raw = await redis_client.get(key)
if raw is not None:
try:
rows, next_cursor = _deserialize(json.loads(raw))
return rows, next_cursor, True
except Exception:
pass # повреждённый кэш — игнорируем и идём в БД
rows, next_cursor = await list_page(db, chat_id, limit, cursor)
if use_cache:
try:
await redis_client.setex(key, CACHE_TTL, json.dumps(_serialize(rows, next_cursor)))
except Exception:
pass # Redis недоступен — не падаем, просто без кэша
return rows, next_cursor, False
+28
View File
@@ -0,0 +1,28 @@
from uuid import UUID
from sqlalchemy import select
from sqlalchemy.ext.asyncio import AsyncSession
from ..db.models import User
async def get_by_username(db: AsyncSession, username: str) -> User | None:
return (
await db.execute(select(User).where(User.username == username))
).scalar_one_or_none()
async def get_by_id(db: AsyncSession, user_id: UUID) -> User | None:
return await db.get(User, user_id)
async def create(
db: AsyncSession, username: str, display_name: str, password_hash: str
) -> User:
user = User(
username=username, display_name=display_name, password_hash=password_hash
)
db.add(user)
await db.commit()
await db.refresh(user)
return user
+55
View File
@@ -0,0 +1,55 @@
services:
postgres:
image: postgres:16.2-alpine
command: ["postgres", "-c", "shared_preload_libraries=pg_stat_statements"]
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: 5s
retries: 10
ports:
- "127.0.0.1:5432:5432"
redis:
image: redis:7.2-alpine
command: ["redis-server", "--appendonly", "yes"]
volumes:
- redisdata:/data
healthcheck:
test: ["CMD", "redis-cli", "ping"]
interval: 5s
timeout: 5s
retries: 10
ports:
- "127.0.0.1:6379:6379"
api:
build: .
ports:
- "127.0.0.1:8080:8080"
env_file: .env
depends_on:
postgres:
condition: service_healthy
redis:
condition: service_healthy
healthcheck:
test:
- "CMD"
- "python"
- "-c"
- "import urllib.request,sys; sys.exit(0 if urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=2).status==200 else 1)"
interval: 10s
timeout: 5s
retries: 10
start_period: 20s
volumes:
pgdata:
redisdata:
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
+28
View File
@@ -0,0 +1,28 @@
{
"requests": 300,
"successful": 300,
"errors": 0,
"elapsed_s": 7.643,
"rps": 39.25,
"latency_ms": {
"p50": 30.019,
"p95": 35.281,
"p99": 38.614,
"min": 4.795,
"max": 41.083,
"mean": 25.476
},
"pg_stat": {
"total_calls_to_messages": 1,
"details": [
{
"calls": 1,
"rows": 51,
"total_ms": 0.043902000000000004,
"mean_ms": 0.043902000000000004
}
]
},
"history": 1000,
"chat_id": "0e5fb96c-b17d-4a31-b2cf-dc234db24711"
}
+28
View File
@@ -0,0 +1,28 @@
{
"requests": 300,
"successful": 300,
"errors": 0,
"elapsed_s": 7.83,
"rps": 38.31,
"latency_ms": {
"p50": 30.395,
"p95": 33.586,
"p99": 36.868,
"min": 5.165,
"max": 50.705,
"mean": 26.099
},
"pg_stat": {
"total_calls_to_messages": 301,
"details": [
{
"calls": 301,
"rows": 15351,
"total_ms": 18.329712000000015,
"mean_ms": 0.060896053156146185
}
]
},
"history": 1000,
"chat_id": "e339b648-9722-47fa-871e-15c99a00fc5b"
}
+1
View File
@@ -0,0 +1 @@
Generic single-database configuration with an async dbapi.
+99
View File
@@ -0,0 +1,99 @@
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
import os
from app.db import models # noqa: F401 — регистрирует таблицы
from app.db.base import Base
# this is the Alembic Config object, which provides
# access to the values within the .ini file in use.
config = context.config
# Interpret the config file for Python logging.
# This line sets up loggers basically.
if config.config_file_name is not None:
fileConfig(config.config_file_name)
# add your model's MetaData object here
# for 'autogenerate' support
# from myapp import mymodel
# target_metadata = mymodel.Base.metadata
target_metadata = Base.metadata
# other values from the config, defined by the needs of env.py,
# can be acquired:
# my_important_option = config.get_main_option("my_important_option")
# ... etc.
def run_migrations_offline() -> None:
"""Run migrations in 'offline' mode.
This configures the context with just a URL
and not an Engine, though an Engine is acceptable
here as well. By skipping the Engine creation
we don't even need a DBAPI to be available.
Calls to context.execute() here emit the given string to the
script output.
"""
url = config.get_main_option("sqlalchemy.url")
context.configure(
url=url,
target_metadata=target_metadata,
literal_binds=True,
dialect_opts={"paramstyle": "named"},
)
with context.begin_transaction():
context.run_migrations()
def do_run_migrations(connection: Connection) -> None:
context.configure(connection=connection, target_metadata=target_metadata)
with context.begin_transaction():
context.run_migrations()
async def run_async_migrations() -> None:
"""In this scenario we need to create an Engine
and associate a connection with the context.
"""
config.set_main_option(
"sqlalchemy.url",
os.getenv(
"DATABASE_URL",
"postgresql+asyncpg://messenger:strongpassword@localhost:5432/messenger",
),
)
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()
def run_migrations_online() -> None:
"""Run migrations in 'online' mode."""
asyncio.run(run_async_migrations())
if context.is_offline_mode():
run_migrations_offline()
else:
run_migrations_online()
+26
View File
@@ -0,0 +1,26 @@
"""${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 identifiers, used by Alembic.
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"}
@@ -0,0 +1,85 @@
"""initial schema
Revision ID: 44ea9d3b68ac
Revises:
Create Date: 2026-10-01 02:42:35.498512
"""
from typing import Sequence, Union
from alembic import op
import sqlalchemy as sa
# revision identifiers, used by Alembic.
revision: str = '44ea9d3b68ac'
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), nullable=False),
sa.PrimaryKeyConstraint('id')
)
op.create_index('idx_chats_created_id', 'chats', ['created_at', 'id'], unique=False)
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), nullable=False),
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_index('idx_chat_members_user', 'chat_members', ['user_id', 'chat_id'], unique=False)
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), nullable=False),
sa.ForeignKeyConstraint(['chat_id'], ['chats.id'], ondelete='CASCADE'),
sa.ForeignKeyConstraint(['sender_id'], ['users.id'], ),
sa.PrimaryKeyConstraint('id')
)
op.create_index('idx_messages_chat_created_id', 'messages', ['chat_id', 'created_at', 'id'], unique=False)
op.create_table('sessions',
sa.Column('id', sa.UUID(), nullable=False),
sa.Column('user_id', sa.UUID(), nullable=False),
sa.Column('token_hash', sa.String(length=64), nullable=False),
sa.Column('expires_at', sa.DateTime(timezone=True), nullable=False),
sa.Column('created_at', sa.DateTime(timezone=True), nullable=False),
sa.ForeignKeyConstraint(['user_id'], ['users.id'], ondelete='CASCADE'),
sa.PrimaryKeyConstraint('id')
)
op.create_index(op.f('ix_sessions_expires_at'), 'sessions', ['expires_at'], unique=False)
op.create_index(op.f('ix_sessions_token_hash'), 'sessions', ['token_hash'], unique=True)
# ### end Alembic commands ###
def downgrade() -> None:
# ### commands auto generated by Alembic - please adjust! ###
op.drop_index(op.f('ix_sessions_token_hash'), table_name='sessions')
op.drop_index(op.f('ix_sessions_expires_at'), table_name='sessions')
op.drop_table('sessions')
op.drop_index('idx_messages_chat_created_id', table_name='messages')
op.drop_table('messages')
op.drop_index('idx_chat_members_user', table_name='chat_members')
op.drop_table('chat_members')
op.drop_index(op.f('ix_users_username'), table_name='users')
op.drop_table('users')
op.drop_index('idx_chats_created_id', table_name='chats')
op.drop_table('chats')
# ### end Alembic commands ###
+12
View File
@@ -0,0 +1,12 @@
fastapi==0.110.0
uvicorn[standard]==0.29.0
pydantic==2.6.4
sqlalchemy[asyncio]==2.0.29
asyncpg==0.29.0
alembic==1.13.1
bcrypt==4.1.2
python-dotenv==1.0.1
redis==5.0.3
httpx==0.27.0
pytest==8.1.1
pytest-asyncio==0.23.5
+36
View File
@@ -0,0 +1,36 @@
@echo off
REM Останавливаем всё в обратном порядке зависимостей
docker compose stop api
docker compose stop postgres
docker compose stop redis
REM Поднимаем в правильном порядке
docker compose up -d postgres
docker compose up -d redis
REM Ждём, пока они станут healthy
:wait_pg
docker compose ps postgres | findstr /C:"(healthy)" >nul
if errorlevel 1 (
timeout /t 2 /nobreak >nul
goto wait_pg
)
:wait_redis
docker compose ps redis | findstr /C:"(healthy)" >nul
if errorlevel 1 (
timeout /t 2 /nobreak >nul
goto wait_redis
)
REM Поднимаем api (он сам применит миграции и стартует)
docker compose up -d api
:wait_api
docker compose ps api | findstr /C:"(healthy)" >nul
if errorlevel 1 (
timeout /t 2 /nobreak >nul
goto wait_api
)
echo Restart complete
+78
View File
@@ -0,0 +1,78 @@
#!/usr/bin/env python3
"""Заполняет чат 10 000 сообщениями через urllib (httpx не работает через docker-proxy на Windows)."""
import json
import base64
import uuid
import urllib.request
import urllib.error
BASE = "http://127.0.0.1:8080"
PASSWORD = "Example-only-not-a-real-secret-123"
def call(method, path, body=None, token=None, raw_body=None, content_type=None):
h = {"Accept": "application/json"}
if token:
h["Authorization"] = f"Bearer {token}"
data = None
if raw_body is not None:
data = raw_body
h["Content-Type"] = content_type or "application/json"
elif body is not None:
data = json.dumps(body).encode("utf-8")
h["Content-Type"] = "application/json"
req = urllib.request.Request(BASE + path, data=data, headers=h, method=method)
try:
with urllib.request.urlopen(req, timeout=60) as r:
payload = r.read()
return r.status, (json.loads(payload) if payload else None)
except urllib.error.HTTPError as e:
payload = e.read()
try:
return e.code, (json.loads(payload) if payload else None)
except ValueError:
return e.code, None
def main():
name = f"seeder_{uuid.uuid4().hex[:6]}"
# 1) пользователь
s, u = call("POST", "/api/v1/users",
{"username": name, "display_name": name, "password": PASSWORD})
assert s == 201, f"create user: {s} {u}"
# 2) сессия через Basic
cred = base64.b64encode(f"{name}:{PASSWORD}".encode()).decode()
req = urllib.request.Request(
BASE + "/api/v1/auth/sessions",
method="POST",
headers={"Authorization": f"Basic {cred}", "Accept": "application/json"},
)
with urllib.request.urlopen(req, timeout=30) as r:
session = json.loads(r.read())
token = session["token"]
# 3) чат
s, chat = call("POST", "/api/v1/chats",
{"title": "seed", "member_ids": [u["id"]]}, token=token)
assert s == 201, f"create chat: {s} {chat}"
cid = chat["id"]
print("chat_id =", cid, flush=True)
# 4) 10 000 сообщений
for i in range(10000):
s, _ = call("POST", f"/api/v1/chats/{cid}/messages",
{"text": f"m{i}"}, token=token)
if s != 201:
print(f"failed at {i}: {s}")
break
if (i + 1) % 1000 == 0:
print(f" {i + 1}/10000", flush=True)
print("DONE")
print("chat_id =", cid)
if __name__ == "__main__":
main()
+54
View File
@@ -0,0 +1,54 @@
#!/usr/bin/env python3
import base64
import json
import time
import urllib.request
import urllib.error
import uuid
BASE = "http://127.0.0.1:8080"
PASSWORD = "Example-only-not-a-real-secret-123"
def call(method, path, body=None, token=None, basic=None):
h = {"Accept": "application/json"}
if token:
h["Authorization"] = f"Bearer {token}"
if basic:
h["Authorization"] = f"Basic {basic}"
data = None
if body is not None:
data = json.dumps(body).encode("utf-8")
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 r:
return r.status, json.loads(r.read()) if r.status != 204 else None
except urllib.error.HTTPError as e:
payload = e.read()
try:
return e.code, json.loads(payload) if payload else None
except ValueError:
return e.code, None
name = f"exp_{uuid.uuid4().hex[:6]}"
s, _ = call("POST", "/api/v1/users", {"username": name, "display_name": name, "password": PASSWORD})
assert s == 201, s
cred = base64.b64encode(f"{name}:{PASSWORD}".encode()).decode()
s, session = call("POST", "/api/v1/auth/sessions", basic=cred)
assert s == 201, (s, session)
token = session["token"]
print(f"session created, expires_at={session['expires_at']}")
# Сразу
s, _ = call("GET", "/api/v1/users/me", token=token)
print(f"immediately: {s} (expect 200)")
# Ждём 4 секунды (TTL=2s)
time.sleep(4)
s, body = call("GET", "/api/v1/users/me", token=token)
print(f"after 4s: {s} (expect 401)")
print(f"body: {body}")
+89
View File
@@ -0,0 +1,89 @@
#!/usr/bin/env python3
import json
import math
import time
import urllib.error
import urllib.request
import uuid
from concurrent.futures import ThreadPoolExecutor
from pathlib import Path
BASE = "http://127.0.0.1:8080"
OUT = Path(__file__).resolve().parents[1] / "evidence" / "track1.json"
def call(method, path, body=None, actor=None):
h = {"Accept": "application/json"}
if actor:
h["X-User-Id"] = actor
data = None
if body is not None:
data = json.dumps(body).encode("utf-8")
h["Content-Type"] = "application/json"
req = urllib.request.Request(BASE + path, data=data, headers=h, method=method)
try:
with urllib.request.urlopen(req, timeout=60) as r:
return r.status, json.loads(r.read())
except urllib.error.HTTPError as e:
return e.code, None
def setup(history: int):
s, u = call("POST", "/api/v1/users",
{"username": f"load_{uuid.uuid4().hex[:10]}",
"display_name": "load"})
assert s == 201
s, chat = call("POST", "/api/v1/chats",
{"title": "load", "member_ids": [u["id"]]},
actor=u["id"])
assert s == 201
for i in range(history):
s, _ = call("POST", f"/api/v1/chats/{chat['id']}/messages",
{"text": f"seed-{i}"}, actor=u["id"])
assert s == 201
return u, chat
def measure(history, concurrency, per_worker=50):
u, chat = setup(history)
lat = []
def worker():
for _ in range(per_worker):
t0 = time.perf_counter()
s, _ = call("GET", f"/api/v1/chats/{chat['id']}/messages?limit=50",
actor=u["id"])
if s == 200:
lat.append(time.perf_counter() - t0)
t0 = time.perf_counter()
with ThreadPoolExecutor(max_workers=concurrency) as ex:
list(ex.map(lambda _: worker(), range(concurrency)))
elapsed = time.perf_counter() - t0
lat.sort()
def pct(p):
return round(1000 * lat[max(0, math.ceil(p * len(lat)) - 1)], 3) if lat else None
return {
"history": history,
"concurrency": concurrency,
"successful_rps": round(len(lat) / elapsed, 2),
"p50_ms": pct(0.50), "p95_ms": pct(0.95), "p99_ms": pct(0.99),
}
def main():
rows = []
for history in (100, 1000, 10000):
for conc in (1, 10, 50):
r = measure(history, conc)
rows.append(r)
print(r)
OUT.parent.mkdir(parents=True, exist_ok=True)
OUT.write_text(json.dumps(rows, indent=2))
if __name__ == "__main__":
main()
+224
View File
@@ -0,0 +1,224 @@
#!/usr/bin/env python3
"""
Замер производительности чтения первой страницы истории.
Используется до и после включения кэша (track A).
Запуск:
python scripts/track_a_bench.py --history 1000 --requests 300 --output evidence/track_a_before.json
python scripts/track_a_bench.py --history 1000 --requests 300 --output evidence/track_a_after.json
Опционально: --reset-pg-stat и --read-pg-stat для подсчёта SQL-запросов
(требует включённого pg_stat_statements в postgres).
"""
import argparse
import base64
import json
import math
import statistics
import time
import urllib.error
import urllib.request
import uuid
from pathlib import Path
BASE = "http://127.0.0.1:8080"
PASSWORD = "Example-only-not-a-real-secret-123"
def call(method, path, body=None, token=None, raw_basic=None, timeout=30):
headers = {"Accept": "application/json"}
if token:
headers["Authorization"] = f"Bearer {token}"
elif raw_basic:
headers["Authorization"] = f"Basic {raw_basic}"
data = None
if body is not None:
data = json.dumps(body).encode("utf-8")
headers["Content-Type"] = "application/json"
req = urllib.request.Request(BASE + path, data=data, headers=headers, method=method)
try:
with urllib.request.urlopen(req, timeout=timeout) as r:
payload = r.read()
return r.status, (json.loads(payload) if payload else None)
except urllib.error.HTTPError as e:
payload = e.read()
try:
return e.code, (json.loads(payload) if payload else None)
except ValueError:
return e.code, None
def setup(history: int):
name = f"bench_{uuid.uuid4().hex[:8]}"
s, u = call("POST", "/api/v1/users", {
"username": name, "display_name": name, "password": PASSWORD,
})
assert s == 201, f"create_user: {s} {u}"
cred = base64.b64encode(f"{name}:{PASSWORD}".encode()).decode()
s, session = call("POST", "/api/v1/auth/sessions", raw_basic=cred)
assert s == 201, f"login: {s} {session}"
token = session["token"]
s, chat = call("POST", "/api/v1/chats",
{"title": "bench", "member_ids": [u["id"]]}, token=token)
assert s == 201, f"create_chat: {s} {chat}"
cid = chat["id"]
print(f"[setup] seeding {history} messages into chat {cid} ...", flush=True)
for i in range(history):
s, _ = call("POST", f"/api/v1/chats/{cid}/messages",
{"text": f"m{i}"}, token=token)
if s != 201:
print(f" seed failed at {i}: {s}")
break
if (i + 1) % 500 == 0:
print(f" {i + 1}/{history}", flush=True)
return token, cid
def percentiles(latencies_ms: list[float]):
if not latencies_ms:
return {}
s = sorted(latencies_ms)
def pct(p):
idx = max(0, math.ceil(p * len(s)) - 1)
return round(s[idx], 3)
return {
"p50": pct(0.50),
"p95": pct(0.95),
"p99": pct(0.99),
"min": round(s[0], 3),
"max": round(s[-1], 3),
"mean": round(statistics.mean(s), 3),
}
def measure(token, cid, requests: int, path: str = "messages"):
latencies = []
errors = 0
t_start = time.perf_counter()
for i in range(requests):
t0 = time.perf_counter()
s, _ = call("GET", f"/api/v1/chats/{cid}/{path}?limit=50", token=token)
dt_ms = (time.perf_counter() - t0) * 1000
if s == 200:
latencies.append(dt_ms)
else:
errors += 1
elapsed = time.perf_counter() - t_start
return {
"requests": requests,
"successful": len(latencies),
"errors": errors,
"elapsed_s": round(elapsed, 3),
"rps": round(len(latencies) / elapsed, 2) if elapsed > 0 else None,
"latency_ms": percentiles(latencies),
}
def reset_pg_stat():
"""Сбросить pg_stat_statements. Требует включённого расширения в postgres."""
import subprocess
cmd = [
"docker", "compose", "exec", "-T", "postgres",
"psql", "-U", "messenger", "-d", "messenger",
"-c", "SELECT pg_stat_statements_reset();",
]
try:
subprocess.run(cmd, check=True, capture_output=True, timeout=15)
print("[pg] pg_stat_statements_reset ok")
except Exception as e:
print(f"[pg] reset failed (ok if extension not enabled): {e}")
def read_pg_stat() -> dict:
"""Прочитать счётчик SQL-запросов к messages."""
import subprocess
query = (
"SELECT calls, rows, total_exec_time, mean_exec_time "
"FROM pg_stat_statements "
"WHERE query ILIKE '%FROM messages%' "
"AND query ILIKE '%ORDER BY%' "
"ORDER BY calls DESC LIMIT 5;"
)
cmd = [
"docker", "compose", "exec", "-T", "postgres",
"psql", "-U", "messenger", "-d", "messenger",
"-t", "-A", "-F", ",", "-c", query,
]
try:
out = subprocess.run(cmd, check=True, capture_output=True, text=True, timeout=15)
lines = [l.strip() for l in out.stdout.splitlines() if l.strip()]
total_calls = 0
rows = []
for line in lines:
parts = line.split(",")
if len(parts) >= 4:
try:
calls = int(parts[0])
total_calls += calls
rows.append({
"calls": calls,
"rows": int(parts[1]),
"total_ms": float(parts[2]),
"mean_ms": float(parts[3]),
})
except ValueError:
continue
return {"total_calls_to_messages": total_calls, "details": rows}
except Exception as e:
print(f"[pg] read failed (ok if extension not enabled): {e}")
return {"error": str(e)}
def main():
ap = argparse.ArgumentParser(description="Track A bench: измерение чтения первой страницы")
ap.add_argument("--history", type=int, default=1000,
help="Сколько сообщений засеять в чат")
ap.add_argument("--requests", type=int, default=300,
help="Сколько GET-запросов сделать для замера")
ap.add_argument("--output", required=True,
help="Путь к JSON-файлу результата")
ap.add_argument("--reset-pg-stat", action="store_true",
help="Сбросить pg_stat_statements перед замером")
ap.add_argument("--read-pg-stat", action="store_true",
help="Прочитать счётчик SQL после замера")
args = ap.parse_args()
if args.reset_pg_stat:
reset_pg_stat()
print(f"[1/3] setup: {args.history} messages", flush=True)
token, cid = setup(args.history)
# прогрев соединений
call("GET", f"/api/v1/chats/{cid}/messages?limit=50", token=token)
print(f"[2/3] measure: {args.requests} GET requests", flush=True)
result = measure(token, cid, args.requests)
if args.read_pg_stat:
print("[3/3] read pg_stat_statements", flush=True)
result["pg_stat"] = read_pg_stat()
result["history"] = args.history
result["chat_id"] = cid
out_path = Path(args.output)
out_path.parent.mkdir(parents=True, exist_ok=True)
out_path.write_text(json.dumps(result, indent=2), encoding="utf-8")
print(json.dumps(result, indent=2))
print(f"\nSaved: {out_path}")
if __name__ == "__main__":
main()
+91
View File
@@ -0,0 +1,91 @@
#!/usr/bin/env python3
"""10 клиентов × 10 сообщений = 100 уникальных."""
import asyncio
import base64
import json
import urllib.request
import urllib.error
import uuid
from concurrent.futures import ThreadPoolExecutor
BASE = "http://127.0.0.1:8080"
PASSWORD = "Example-only-not-a-real-secret-123"
def call(method, path, body=None, token=None):
h = {"Accept": "application/json"}
if token:
h["Authorization"] = f"Bearer {token}"
data = None
if body is not None:
data = json.dumps(body).encode("utf-8")
h["Content-Type"] = "application/json"
req = urllib.request.Request(BASE + path, data=data, headers=h, method=method)
try:
with urllib.request.urlopen(req, timeout=30) as r:
payload = r.read()
return r.status, (json.loads(payload) if payload else None)
except urllib.error.HTTPError as e:
payload = e.read()
return e.code, (json.loads(payload) if payload else None)
def create_user_and_login(name):
s, u = call("POST", "/api/v1/users",
{"username": name, "display_name": name, "password": PASSWORD})
assert s == 201, f"create_user {name}: {s} {u}"
cred = base64.b64encode(f"{name}:{PASSWORD}".encode()).decode()
req = urllib.request.Request(
BASE + "/api/v1/auth/sessions",
headers={"Authorization": f"Basic {cred}"},
method="POST",
)
with urllib.request.urlopen(req, timeout=30) as r:
session = json.loads(r.read())
return u, session["token"]
def main():
users = [create_user_and_login(f"conc_{i}_{uuid.uuid4().hex[:6]}") for i in range(10)]
owner, owner_token = users[0]
chat = call("POST", "/api/v1/chats",
{"title": "concurrent", "member_ids": [u["id"] for u, _ in users]},
token=owner_token)[1]
cid = chat["id"]
def post_10(user_and_token):
_, token = user_and_token
results = []
for k in range(10):
s, m = call("POST", f"/api/v1/chats/{cid}/messages",
{"text": f"m{k}"}, token=token)
results.append((s, m))
return results
with ThreadPoolExecutor(max_workers=10) as ex:
results = []
for fut in [ex.submit(post_10, u) for u in users]:
results.extend(fut.result())
failures = [r for r in results if r[0] != 201]
assert not failures, f"{len(failures)} failed posts"
seen, cursor = set(), None
while True:
path = f"/api/v1/chats/{cid}/messages?limit=100"
if cursor:
path += f"&cursor={cursor}"
s, page = call("GET", path, token=owner_token)
for m in page["items"]:
seen.add(m["id"])
cursor = page["next_cursor"]
if not cursor:
break
print(f"unique messages: {len(seen)} / 100")
assert len(seen) == 100, f"expected 100, got {len(seen)}"
print("PASS: no lost or duplicated messages")
if __name__ == "__main__":
main()
+86
View File
@@ -0,0 +1,86 @@
import asyncio
import base64
import json
import urllib.error
import urllib.request
import uuid
import pytest
BASE = "http://127.0.0.1:8080"
PASSWORD = "Example-only-not-a-real-secret-123"
def _post(path, body, token=None):
h = {"Content-Type": "application/json", "Accept": "application/json"}
if token:
h["Authorization"] = f"Bearer {token}"
data = json.dumps(body).encode("utf-8")
req = urllib.request.Request(BASE + path, data=data, method="POST", headers=h)
try:
with urllib.request.urlopen(req, timeout=10) as r:
return r.status, json.loads(r.read())
except urllib.error.HTTPError as e:
payload = e.read()
try:
return e.code, json.loads(payload) if payload else None
except ValueError:
return e.code, None
def _post_basic(path, username, password):
cred = base64.b64encode(f"{username}:{password}".encode()).decode()
req = urllib.request.Request(
BASE + path, method="POST",
headers={"Authorization": f"Basic {cred}", "Accept": "application/json"},
)
with urllib.request.urlopen(req, timeout=10) as r:
return r.status, json.loads(r.read())
def _create_user(name):
return _post("/api/v1/users", {
"username": name, "display_name": name, "password": PASSWORD,
})
def _login(name):
_, body = _post_basic("/api/v1/auth/sessions", name, PASSWORD)
return body["token"]
def test_duplicate_username_race():
name = f"dup_{uuid.uuid4().hex[:8]}"
import threading
results = [None, None]
def worker(i):
results[i] = _create_user(name)
t1 = threading.Thread(target=worker, args=(0,))
t2 = threading.Thread(target=worker, args=(1,))
t1.start(); t2.start()
t1.join(); t2.join()
codes = sorted([results[0][0], results[1][0]])
assert codes == [201, 409], codes
def test_chat_with_unknown_member_rolls_back():
name = f"cb_{uuid.uuid4().hex[:8]}"
s, me = _create_user(name)
assert s == 201, me
tok = _login(name)
s, _ = _post("/api/v1/chats", {
"title": "x", "member_ids": [me["id"], str(uuid.uuid4())],
}, token=tok)
assert s == 404
def test_message_to_missing_chat():
name = f"mc_{uuid.uuid4().hex[:8]}"
_create_user(name)
tok = _login(name)
s, _ = _post(f"/api/v1/chats/{uuid.uuid4()}/messages", {"text": "hi"}, token=tok)
assert s == 404