From 7fd38cf2e2f88a7340c01e4d84c8cdc573020c2a Mon Sep 17 00:00:00 2001 From: Maksimova Snezhana Date: Wed, 28 Oct 2026 23:21:31 +0300 Subject: [PATCH 01/11] chore: setup project and copy lab2 code --- Dockerfile | 27 ++ alembic.ini | 114 +++++++ app/__init__.py | 0 app/auth.py | 85 +++++ app/db/__init__.py | 0 app/db/base.py | 5 + app/db/models.py | 100 ++++++ app/db/session.py | 31 ++ app/main.py | 290 ++++++++++++++++++ app/models.py | 56 ++++ app/repositories/__init__.py | 0 app/repositories/chats.py | 80 +++++ app/repositories/messages.py | 128 ++++++++ app/repositories/users.py | 28 ++ migrations/README | 1 + migrations/env.py | 99 ++++++ migrations/script.py.mako | 26 ++ .../versions/44ea9d3b68ac_initial_schema.py | 85 +++++ requirements.txt | 12 + student-tests/concurrent_test.py | 91 ++++++ student-tests/test_rollback.py | 86 ++++++ 21 files changed, 1344 insertions(+) create mode 100644 Dockerfile create mode 100644 alembic.ini create mode 100644 app/__init__.py create mode 100644 app/auth.py create mode 100644 app/db/__init__.py create mode 100644 app/db/base.py create mode 100644 app/db/models.py create mode 100644 app/db/session.py create mode 100644 app/main.py create mode 100644 app/models.py create mode 100644 app/repositories/__init__.py create mode 100644 app/repositories/chats.py create mode 100644 app/repositories/messages.py create mode 100644 app/repositories/users.py create mode 100644 migrations/README create mode 100644 migrations/env.py create mode 100644 migrations/script.py.mako create mode 100644 migrations/versions/44ea9d3b68ac_initial_schema.py create mode 100644 requirements.txt create mode 100644 student-tests/concurrent_test.py create mode 100644 student-tests/test_rollback.py diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..207638eb --- /dev/null +++ b/Dockerfile @@ -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"] \ No newline at end of file diff --git a/alembic.ini b/alembic.ini new file mode 100644 index 00000000..71e7425c --- /dev/null +++ b/alembic.ini @@ -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 diff --git a/app/__init__.py b/app/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/app/auth.py b/app/auth.py new file mode 100644 index 00000000..d996abec --- /dev/null +++ b/app/auth.py @@ -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() \ No newline at end of file diff --git a/app/db/__init__.py b/app/db/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/app/db/base.py b/app/db/base.py new file mode 100644 index 00000000..1c2dcc40 --- /dev/null +++ b/app/db/base.py @@ -0,0 +1,5 @@ +from sqlalchemy.orm import DeclarativeBase + + +class Base(DeclarativeBase): + pass \ No newline at end of file diff --git a/app/db/models.py b/app/db/models.py new file mode 100644 index 00000000..89af0c04 --- /dev/null +++ b/app/db/models.py @@ -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 + ) \ No newline at end of file diff --git a/app/db/session.py b/app/db/session.py new file mode 100644 index 00000000..5bbb910b --- /dev/null +++ b/app/db/session.py @@ -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 \ No newline at end of file diff --git a/app/main.py b/app/main.py new file mode 100644 index 00000000..35305946 --- /dev/null +++ b/app/main.py @@ -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_and_invalidate(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, _cached = await messages_repo.list_page_cached(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"))) \ No newline at end of file diff --git a/app/models.py b/app/models.py new file mode 100644 index 00000000..19dc8595 --- /dev/null +++ b/app/models.py @@ -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 \ No newline at end of file diff --git a/app/repositories/__init__.py b/app/repositories/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/app/repositories/chats.py b/app/repositories/chats.py new file mode 100644 index 00000000..db82b9d1 --- /dev/null +++ b/app/repositories/chats.py @@ -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 \ No newline at end of file diff --git a/app/repositories/messages.py b/app/repositories/messages.py new file mode 100644 index 00000000..0fa80e5e --- /dev/null +++ b/app/repositories/messages.py @@ -0,0 +1,128 @@ +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: + payload = json.dumps(_serialize(rows, next_cursor)) + await redis_client.setex(key, CACHE_TTL, payload) + print(f"CACHE SET OK: {key}", flush=True) + except Exception as e: + import traceback + traceback.print_exc() + print(f"CACHE SET FAILED: {type(e).__name__}: {e}", flush=True) + + return rows, next_cursor, False \ No newline at end of file diff --git a/app/repositories/users.py b/app/repositories/users.py new file mode 100644 index 00000000..58792ea0 --- /dev/null +++ b/app/repositories/users.py @@ -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 \ No newline at end of file diff --git a/migrations/README b/migrations/README new file mode 100644 index 00000000..e0d0858f --- /dev/null +++ b/migrations/README @@ -0,0 +1 @@ +Generic single-database configuration with an async dbapi. \ No newline at end of file diff --git a/migrations/env.py b/migrations/env.py new file mode 100644 index 00000000..ee06e32b --- /dev/null +++ b/migrations/env.py @@ -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() diff --git a/migrations/script.py.mako b/migrations/script.py.mako new file mode 100644 index 00000000..fbc4b07d --- /dev/null +++ b/migrations/script.py.mako @@ -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"} diff --git a/migrations/versions/44ea9d3b68ac_initial_schema.py b/migrations/versions/44ea9d3b68ac_initial_schema.py new file mode 100644 index 00000000..62b49d14 --- /dev/null +++ b/migrations/versions/44ea9d3b68ac_initial_schema.py @@ -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 ### diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 00000000..277e6cdc --- /dev/null +++ b/requirements.txt @@ -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 \ No newline at end of file diff --git a/student-tests/concurrent_test.py b/student-tests/concurrent_test.py new file mode 100644 index 00000000..f8e46d26 --- /dev/null +++ b/student-tests/concurrent_test.py @@ -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() \ No newline at end of file diff --git a/student-tests/test_rollback.py b/student-tests/test_rollback.py new file mode 100644 index 00000000..a83bbf27 --- /dev/null +++ b/student-tests/test_rollback.py @@ -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 \ No newline at end of file -- 2.54.0 From 2ec2447d1c70cd80c501c95b7f0aadd67e7ec6f8 Mon Sep 17 00:00:00 2001 From: Maksimova Snezhana Date: Wed, 28 Oct 2026 23:24:35 +0300 Subject: [PATCH 02/11] feat: implement instance id and idempotency key handling --- app/db/models.py | 17 +++++++++++++++- app/main.py | 50 ++++++++++++++++++++++++++++++++++++++++++++++-- 2 files changed, 64 insertions(+), 3 deletions(-) diff --git a/app/db/models.py b/app/db/models.py index 89af0c04..12884e3d 100644 --- a/app/db/models.py +++ b/app/db/models.py @@ -4,7 +4,7 @@ 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 sqlalchemy import UniqueConstraint from .base import Base @@ -97,4 +97,19 @@ class SessionRow(Base): ) created_at: Mapped[datetime] = mapped_column( DateTime(timezone=True), default=_now, nullable=False + ) + +from sqlalchemy import UniqueConstraint + +class IdempotencyRecord(Base): + __tablename__ = "idempotency_keys" + 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) + key: Mapped[str] = mapped_column(String(128), nullable=False) + request_hash: Mapped[str] = mapped_column(String(64), nullable=False) + response_body: Mapped[str] = mapped_column(Text, nullable=False) + created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), default=_now, nullable=False) + + __table_args__ = ( + UniqueConstraint("user_id", "key", name="uq_idempotency_user_key"), ) \ No newline at end of file diff --git a/app/main.py b/app/main.py index 35305946..54a6bacc 100644 --- a/app/main.py +++ b/app/main.py @@ -1,9 +1,15 @@ import os import uuid +import socket from contextvars import ContextVar from datetime import datetime, timedelta, timezone from typing import Optional from uuid import UUID +from sqlalchemy.exc import IntegrityError +import hashlib +import json + +INSTANCE_ID = os.environ.get("HOSTNAME", f"api-{socket.gethostname()}") from fastapi import Depends, FastAPI, Header, HTTPException, Query, Request from fastapi.exceptions import RequestValidationError @@ -46,7 +52,7 @@ _HTTP_CODES = { def err_json(status: int, code: str, message: str) -> JSONResponse: - return JSONResponse( + resp = JSONResponse( status_code=status, content={ "error": { @@ -56,6 +62,8 @@ def err_json(status: int, code: str, message: str) -> JSONResponse: } }, ) + resp.headers["X-Instance-Id"] = INSTANCE_ID + return resp class RequestIdMiddleware(BaseHTTPMiddleware): @@ -64,6 +72,7 @@ class RequestIdMiddleware(BaseHTTPMiddleware): request_id_var.set(rid) response = await call_next(request) response.headers["X-Request-Id"] = rid + response.headers["X-Instance-Id"] = INSTANCE_ID return response @@ -249,14 +258,51 @@ async def get_chat( async def post_message( chat_id: UUID, body: CreateMessage, + idempotency_key: str = Header(..., alias="Idempotency-Key"), 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") + + req_hash = hashlib.sha256(body.model_dump_json().encode("utf-8")).hexdigest() + + # 1. Проверяем, есть ли уже такой ключ + stmt = select(IdempotencyRecord).where( + IdempotencyRecord.user_id == user.id, + IdempotencyRecord.key == idempotency_key, + ) + record = (await db.execute(stmt)).scalar_one_or_none() + + if record: + if record.request_hash != req_hash: + raise HTTPException(409, "Idempotency key conflict") + # Возвращаем сохраненный ответ (201 и тот же JSON) + return JSONResponse(status_code=201, content=json.loads(record.response_body)) + + # 2. Создаём сообщение msg = await messages_repo.create_and_invalidate(db, chat_id, user.id, body.text) - return _msg_json(msg) + resp_body = json.dumps(_msg_json(msg)) + + # 3. Сохраняем ключ + db.add(IdempotencyRecord( + user_id=user.id, + key=idempotency_key, + request_hash=req_hash, + response_body=resp_body + )) + try: + await db.commit() + except IntegrityError: + # Гонка: другая реплика уже вставила этот ключ + await db.rollback() + record = (await db.execute(stmt)).scalar_one_or_none() + if record and record.request_hash == req_hash: + return JSONResponse(status_code=201, content=json.loads(record.response_body)) + raise HTTPException(409, "Idempotency key conflict") + + return JSONResponse(status_code=201, content=json.loads(resp_body)) @app.get("/api/v1/chats/{chat_id}/messages") -- 2.54.0 From 3be992f95374c8504bdb45e7e7bda2a5d2097de7 Mon Sep 17 00:00:00 2001 From: Maksimova Snezhana Date: Wed, 28 Oct 2026 23:42:21 +0300 Subject: [PATCH 03/11] feat: add idempotency keys database migration --- .../b7965b0447f4_add_idempotency_keys.py | 40 +++++++++++++++++++ 1 file changed, 40 insertions(+) create mode 100644 migrations/versions/b7965b0447f4_add_idempotency_keys.py diff --git a/migrations/versions/b7965b0447f4_add_idempotency_keys.py b/migrations/versions/b7965b0447f4_add_idempotency_keys.py new file mode 100644 index 00000000..143fb31d --- /dev/null +++ b/migrations/versions/b7965b0447f4_add_idempotency_keys.py @@ -0,0 +1,40 @@ +"""add idempotency keys + +Revision ID: b7965b0447f4 +Revises: 44ea9d3b68ac +Create Date: 2026-10-28 23:34:43.564839 + +""" +from typing import Sequence, Union + +from alembic import op +import sqlalchemy as sa + + +# revision identifiers, used by Alembic. +revision: str = 'b7965b0447f4' +down_revision: Union[str, None] = '44ea9d3b68ac' +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('idempotency_keys', + sa.Column('id', sa.UUID(), nullable=False), + sa.Column('user_id', sa.UUID(), nullable=False), + sa.Column('key', sa.String(length=128), nullable=False), + sa.Column('request_hash', sa.String(length=64), nullable=False), + sa.Column('response_body', sa.Text(), nullable=False), + sa.Column('created_at', sa.DateTime(timezone=True), nullable=False), + sa.ForeignKeyConstraint(['user_id'], ['users.id'], ondelete='CASCADE'), + sa.PrimaryKeyConstraint('id'), + sa.UniqueConstraint('user_id', 'key', name='uq_idempotency_user_key') + ) + # ### end Alembic commands ### + + +def downgrade() -> None: + # ### commands auto generated by Alembic - please adjust! ### + op.drop_table('idempotency_keys') + # ### end Alembic commands ### -- 2.54.0 From e782d6c86dc1abed8d80af26096ef000434652c8 Mon Sep 17 00:00:00 2001 From: Maksimova Snezhana Date: Wed, 28 Oct 2026 23:42:27 +0300 Subject: [PATCH 04/11] feat: configure nginx load balancer and compose scaling --- compose.yaml | 52 ++++++++++++++++++++++++++++++++++++++++++++++++ nginx/nginx.conf | 24 ++++++++++++++++++++++ 2 files changed, 76 insertions(+) create mode 100644 compose.yaml create mode 100644 nginx/nginx.conf diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 00000000..7454556d --- /dev/null +++ b/compose.yaml @@ -0,0 +1,52 @@ +services: + postgres: + image: postgres:16.2-alpine + environment: + POSTGRES_USER: ${POSTGRES_USER} + POSTGRES_PASSWORD: ${POSTGRES_PASSWORD} + POSTGRES_DB: ${POSTGRES_DB} + volumes: + - pgdata:/var/lib/postgresql/data + ports: + - "127.0.0.1:5432:5432" + healthcheck: + test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER} -d ${POSTGRES_DB}"] + interval: 5s + timeout: 5s + retries: 10 + + 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 + + api: + build: . + environment: + DATABASE_URL: postgresql+asyncpg://${POSTGRES_USER}:${POSTGRES_PASSWORD}@postgres:5432/${POSTGRES_DB} + REDIS_URL: redis://redis:6379/0 + SESSION_TTL_SECONDS: 3600 + depends_on: + postgres: + condition: service_healthy + redis: + condition: service_healthy + + nginx: + image: nginx:1.25-alpine + ports: + - "127.0.0.1:8080:80" + volumes: + - ./nginx/nginx.conf:/etc/nginx/nginx.conf:ro + depends_on: + - api + +volumes: + pgdata: + redisdata: \ No newline at end of file diff --git a/nginx/nginx.conf b/nginx/nginx.conf new file mode 100644 index 00000000..b1329e9f --- /dev/null +++ b/nginx/nginx.conf @@ -0,0 +1,24 @@ +worker_processes 1; + +events { worker_connections 1024; } + +http { + resolver 127.0.0.11 valid=5s; + upstream api_backend { + server api:8080 max_fails=3 fail_timeout=5s; + keepalive 32; + } + + server { + listen 80; + + location / { + proxy_pass http://api_backend; + proxy_http_version 1.1; + proxy_set_header Connection ""; + proxy_set_header Host $host; + proxy_set_header X-Real-IP $remote_addr; + proxy_connect_timeout 2s; + } + } +} \ No newline at end of file -- 2.54.0 From bac3a9ac107bcaf05c451ef7d0645cf316525a65 Mon Sep 17 00:00:00 2001 From: Maksimova Snezhana Date: Wed, 28 Oct 2026 23:42:33 +0300 Subject: [PATCH 05/11] chore: add restart and failover action scripts --- scripts/restart.cmd | 6 ++++++ scripts/stop-one.cmd | 6 ++++++ 2 files changed, 12 insertions(+) create mode 100644 scripts/restart.cmd create mode 100644 scripts/stop-one.cmd diff --git a/scripts/restart.cmd b/scripts/restart.cmd new file mode 100644 index 00000000..c40b8800 --- /dev/null +++ b/scripts/restart.cmd @@ -0,0 +1,6 @@ +#!/bin/bash +set -e +docker compose restart postgres +docker compose restart redis +docker compose restart api +docker compose restart nginx \ No newline at end of file diff --git a/scripts/stop-one.cmd b/scripts/stop-one.cmd new file mode 100644 index 00000000..e28aaa60 --- /dev/null +++ b/scripts/stop-one.cmd @@ -0,0 +1,6 @@ +@echo off +if "%TARGET_INSTANCE_ID%"=="" ( + echo TARGET_INSTANCE_ID is not set + exit /b 1 +) +docker stop %TARGET_INSTANCE_ID% \ No newline at end of file -- 2.54.0 From 7a4b0e1b080e4dc23247ce699b39239d13099a48 Mon Sep 17 00:00:00 2001 From: Maksimova Snezhana Date: Wed, 28 Oct 2026 23:42:42 +0300 Subject: [PATCH 06/11] feat: implement instance id and idempotency key handling --- app/main.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/app/main.py b/app/main.py index 54a6bacc..17f5fe97 100644 --- a/app/main.py +++ b/app/main.py @@ -15,7 +15,7 @@ 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 import select, text from sqlalchemy.ext.asyncio import AsyncSession from starlette.middleware.base import BaseHTTPMiddleware @@ -29,7 +29,7 @@ from .auth import ( revoke_current_session, verify_password, ) -from .db.models import SessionRow, User +from .db.models import IdempotencyRecord, SessionRow, User from .db.session import get_db from .models import CreateChat, CreateMessage, CreateUser from .repositories import chats as chats_repo -- 2.54.0 From d365425338fd4b06a893b40dfd667b4ae6ffa081 Mon Sep 17 00:00:00 2001 From: Maksimova Snezhana Date: Wed, 28 Oct 2026 23:43:18 +0300 Subject: [PATCH 07/11] test: update concurrent test with idempotency key for lab3 --- student-tests/concurrent_test.py | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/student-tests/concurrent_test.py b/student-tests/concurrent_test.py index f8e46d26..7469c462 100644 --- a/student-tests/concurrent_test.py +++ b/student-tests/concurrent_test.py @@ -1,5 +1,4 @@ #!/usr/bin/env python3 -"""10 клиентов × 10 сообщений = 100 уникальных.""" import asyncio import base64 import json @@ -11,11 +10,14 @@ 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}" + # ДОБАВЛЯЕМ IDEMPOTENCY-KEY ДЛЯ POST + if method == "POST" and "/messages" in path: + h["Idempotency-Key"] = uuid.uuid4().hex + data = None if body is not None: data = json.dumps(body).encode("utf-8") @@ -29,7 +31,6 @@ def call(method, path, body=None, token=None): 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}) @@ -44,7 +45,6 @@ def create_user_and_login(name): 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] @@ -86,6 +86,5 @@ def main(): assert len(seen) == 100, f"expected 100, got {len(seen)}" print("PASS: no lost or duplicated messages") - if __name__ == "__main__": main() \ No newline at end of file -- 2.54.0 From 55072c04c4b8a8b121a51d690b40a1b66484b948 Mon Sep 17 00:00:00 2001 From: Maksimova Snezhana Date: Wed, 28 Oct 2026 23:50:20 +0300 Subject: [PATCH 08/11] test: add track1 scaling benchmark and evidence --- evidence/track1.txt | Bin 0 -> 332 bytes scripts/track1_bench.py | 79 ++++++++++++++++++++++++++++++++++++++++ 2 files changed, 79 insertions(+) create mode 100644 evidence/track1.txt create mode 100644 scripts/track1_bench.py diff --git a/evidence/track1.txt b/evidence/track1.txt new file mode 100644 index 0000000000000000000000000000000000000000..21fb32c50e743a867fa76260a0715bb6ac3d4d5f GIT binary patch literal 332 zcmbV{!3u&v6h+Tk=pXz7nHeXo_U%KzAjE}GB)Rq5wQDnwkPyV 0 else 0 + print(f"Replicas: {replicas} | RPS: {rps:.2f} | p95: {p95:.2f}ms | Errors: {errors}") + +if __name__ == "__main__": + main(sys.argv[1], int(sys.argv[2]), int(sys.argv[3])) \ No newline at end of file -- 2.54.0 From 620537e9a93754aba1b4d333d1743523c58bf64b Mon Sep 17 00:00:00 2001 From: Maksimova Snezhana Date: Thu, 29 Oct 2026 01:39:56 +0300 Subject: [PATCH 09/11] add report.md --- REPORT.md | 77 ++++++++++++++++++++++++++++++++++++++++++++----------- 1 file changed, 62 insertions(+), 15 deletions(-) diff --git a/REPORT.md b/REPORT.md index c2679005..643dc15f 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,84 @@ # Отчёт — лабораторная 3 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO -- Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +- Автор, группа: Максимова Снежана, БПИ2302 +- Целевая оценка: 5, трек 1 (Цена масштабирования) +- Commit/PR: <вставь ссылку на свой PR в Gitea после пуша> +- Использованные источники, библиотеки и помощь ИИ: FastAPI, SQLAlchemy, asyncpg, Alembic, Redis-py, Nginx. ИИ использовался для генерации черновиков конфигураций и скриптов, финальная проверка и отладка проводилась вручную. ## Запуск из чистого clone -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +Для запуска требуются Docker и Docker Compose. + +~~~sh +git clone https://gitea.privcloud.tech/kleprer/mtusi2026lab3.git +cd mtusi2026lab3 +python -c "import shutil; shutil.copy('.env.example', '.env')" +docker compose up -d --build --scale api=2 +~~~ + +Безопасная остановка (с сохранением данных): + +~~~sh +docker compose down +~~~ + +Намеренное удаление учебных данных (базы и сессий): + +~~~sh +docker compose down -v +~~~ ## Архитектура и решения -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab2, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +**Схема процессов:** +Клиент → Nginx (Балансировщик, порт 8080) → 2+ API-реплики (FastAPI) → PostgreSQL (истина) и Redis (сессии). + +**Что изменено по сравнению с lab2:** +1. **Масштабирование:** Приложение упаковано в Docker-образ, который запускается в нескольких экземплярах (`--scale api=2`). Публикация портов API наружу убрана, теперь трафик принимает только Nginx. +2. **X-Instance-Id:** В приложение добавлен middleware, генерирующий уникальный ID процесса (берется из `HOSTNAME` контейнера). Этот ID добавляется в заголовки всех ответов. +3. **Идемпотентность:** Добавлена таблица `idempotency_keys` в PostgreSQL. При POST-запросе сообщения проверяется наличие ключа `(user_id, Idempotency-Key)`. Если ключ есть и хэш тела запроса совпадает, возвращается сохраненный ответ (201). Если тело другое — 409 Conflict. Для защиты от гонок при одновременных запросах используется `IntegrityError` базы данных. + +**Транзакционные границы:** +Создание сообщения и запись ключа идемпотентности выполняются в одной транзакции БД. Если транзакция падает, ключ не сохраняется, и клиент может безопасно повторить запрос. ## Доказательства критериев | Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | | --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | - -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +| Публичный smoke | `python tests/smoke.py` | PASS (проверены health, сессии, RBAC) | вывод консоли | +| Распределение трафика (LB) | `curl -i http://localhost:8080/health/live` (х2) | Разные значения в заголовке `X-Instance-Id` | вывод консоли | +| Отказ одной API-реплики | `python tests/resilience.py --mode failover` | PASS. Восстановление за 3.4 сек. 48 успешных записей во время отказа. | лог теста | +| Сохранность (Persistence) | `python tests/resilience.py --mode persistence` | PASS. Данные и сессия живы после перезапуска. | лог теста | +| Общая идемпотентность | `python tests/smoke.py` (секция idempotency) | PASS. Повторный POST с тем же ключом возвращает 201, без дублей. | лог теста | +| Нагрузочное тестирование | `python scripts/track1_bench.py` | Результаты в разделе "Эксперименты" | `evidence/track1.txt` | ## Эксперименты и отказы -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +**Трек 1: Цена масштабирования** +- **Гипотеза:** С ростом числа API-реплик RPS будет расти, пока узким местом не станет база данных (saturation point). +- **Оборудование:** Локальный Docker-host (Windows/WSL2). Ресурсы не ограничены искусственно. +- **Методика:** 20 параллельных клиентов, длительность 10 секунд, POST-запросы на отправку сообщений. Использовался скрипт `track1_bench.py`. +- **Результаты замеров:** + +| Количество реплик | Успешный RPS | p95 Latency | Ошибки | +| --- | --- | --- | --- | +| 1 | 115.68 | 290.74 ms | 0 | +| 2 | 121.26 | 292.46 ms | 0 | +| 4 | 100.47 | 352.11 ms | 0 | + +**Анализ результатов:** +1. При переходе с 1 на 2 реплики RPS вырос незначительно (+5%). Это говорит о том, что даже одна реплика успевала обрабатывать запросы, а основное время тратилось на базу данных. +2. При увеличении до 4 реплик RPS **упал**, а p95 latency вырос. Мы нашли **saturation point** (точку насыщения). +3. **Вывод:** Узким местом стала общая база данных PostgreSQL. Четыре реплики начинают конкурировать за пул соединений (connection pool) и ресурсы CPU хоста, создавая избыточные блокировки и накладные расходы на переключение контекста. Дальнейшее масштабирование API бессмысленно без репликации самой базы данных. | Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | | --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +| Остановка одной API-реплики (Failover) | Nginx перенаправит трафик на живую реплику | Несколько 502 ошибок во время переключения, затем стабильная работа | ~3.4 секунды, потери подтвержденных данных нет | +| Перезапуск всей инфраструктуры | Данные и сессии сохранятся | Успешный вход по старому токену, история сообщений на месте | ~10 секунд (время старта контейнеров) | ## Ограничения и следующие шаги -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +- **Единая точка отказа (SPOF):** В текущей конфигурации используется только один инстанс PostgreSQL. При падении узла с базой данных вся система перестанет работать. +- **Один хост:** Nginx и все реплики запущены на одной машине. При потере хоста стенд полностью недоступен (нет отказоустойчивости на уровне железа). +- **Connection Pool:** Каждая реплика открывает свой пул соединений к БД. При слишком большом числе реплик можно исчерпать лимит `max_connections` в PostgreSQL. +- **Учебное упрощение:** В качестве балансировщика используется Nginx с базовой конфигурацией round-robin без сложных проверок состояния (используется только пассивный `max_fails`). \ No newline at end of file -- 2.54.0 From db980c439fed5ae762d154bd0c9882c18041e810 Mon Sep 17 00:00:00 2001 From: Maksimova Snezhana Date: Fri, 30 Oct 2026 00:53:40 +0300 Subject: [PATCH 10/11] docs: final lab3 report and failover results --- REPORT.md | 40 ++++++++++++++++++++-------------------- nginx/nginx.conf | 5 +++-- scripts/stop-one.cmd | 2 +- 3 files changed, 24 insertions(+), 23 deletions(-) diff --git a/REPORT.md b/REPORT.md index 643dc15f..5c3bbeb9 100644 --- a/REPORT.md +++ b/REPORT.md @@ -2,31 +2,31 @@ - Автор, группа: Максимова Снежана, БПИ2302 - Целевая оценка: 5, трек 1 (Цена масштабирования) -- Commit/PR: <вставь ссылку на свой PR в Gitea после пуша> +- Commit/PR: <вставь ссылку на свой PR в Gitea> - Использованные источники, библиотеки и помощь ИИ: FastAPI, SQLAlchemy, asyncpg, Alembic, Redis-py, Nginx. ИИ использовался для генерации черновиков конфигураций и скриптов, финальная проверка и отладка проводилась вручную. ## Запуск из чистого clone Для запуска требуются Docker и Docker Compose. -~~~sh +```sh git clone https://gitea.privcloud.tech/kleprer/mtusi2026lab3.git cd mtusi2026lab3 python -c "import shutil; shutil.copy('.env.example', '.env')" docker compose up -d --build --scale api=2 -~~~ +``` Безопасная остановка (с сохранением данных): -~~~sh +```sh docker compose down -~~~ +``` Намеренное удаление учебных данных (базы и сессий): -~~~sh +```sh docker compose down -v -~~~ +``` ## Архитектура и решения @@ -34,7 +34,7 @@ docker compose down -v Клиент → Nginx (Балансировщик, порт 8080) → 2+ API-реплики (FastAPI) → PostgreSQL (истина) и Redis (сессии). **Что изменено по сравнению с lab2:** -1. **Масштабирование:** Приложение упаковано в Docker-образ, который запускается в нескольких экземплярах (`--scale api=2`). Публикация портов API наружу убрана, теперь трафик принимает только Nginx. +1. **Масштабирование:** Приложение упаковано в Docker-образ, который запускается в нескольких экземплярах (`--scale api=2`). Публикация портов API наружу убрана, теперь трафик принимает только Nginx, использующий динамическое разрешение имен (resolver) для распределения запросов между репликами. 2. **X-Instance-Id:** В приложение добавлен middleware, генерирующий уникальный ID процесса (берется из `HOSTNAME` контейнера). Этот ID добавляется в заголовки всех ответов. 3. **Идемпотентность:** Добавлена таблица `idempotency_keys` в PostgreSQL. При POST-запросе сообщения проверяется наличие ключа `(user_id, Idempotency-Key)`. Если ключ есть и хэш тела запроса совпадает, возвращается сохраненный ответ (201). Если тело другое — 409 Conflict. Для защиты от гонок при одновременных запросах используется `IntegrityError` базы данных. @@ -47,7 +47,7 @@ docker compose down -v | --- | --- | --- | --- | | Публичный smoke | `python tests/smoke.py` | PASS (проверены health, сессии, RBAC) | вывод консоли | | Распределение трафика (LB) | `curl -i http://localhost:8080/health/live` (х2) | Разные значения в заголовке `X-Instance-Id` | вывод консоли | -| Отказ одной API-реплики | `python tests/resilience.py --mode failover` | PASS. Восстановление за 3.4 сек. 48 успешных записей во время отказа. | лог теста | +| Отказ одной API-реплики | `python tests/resilience.py --mode failover` | PASS. Восстановление за 5.2 сек. 7 успешных записей во время отказа, 0 ошибок. | лог теста | | Сохранность (Persistence) | `python tests/resilience.py --mode persistence` | PASS. Данные и сессия живы после перезапуска. | лог теста | | Общая идемпотентность | `python tests/smoke.py` (секция idempotency) | PASS. Повторный POST с тем же ключом возвращает 201, без дублей. | лог теста | | Нагрузочное тестирование | `python scripts/track1_bench.py` | Результаты в разделе "Эксперименты" | `evidence/track1.txt` | @@ -55,30 +55,30 @@ docker compose down -v ## Эксперименты и отказы **Трек 1: Цена масштабирования** -- **Гипотеза:** С ростом числа API-реплик RPS будет расти, пока узким местом не станет база данных (saturation point). -- **Оборудование:** Локальный Docker-host (Windows/WSL2). Ресурсы не ограничены искусственно. +- **Гипотеза:** С ростом числа API-реплик RPS будет расти линейно, пока узким местом (saturation point) не станет база данных. +- **Оборудование:** Локальный Docker-host (Windows/WSL2). - **Методика:** 20 параллельных клиентов, длительность 10 секунд, POST-запросы на отправку сообщений. Использовался скрипт `track1_bench.py`. - **Результаты замеров:** | Количество реплик | Успешный RPS | p95 Latency | Ошибки | | --- | --- | --- | --- | -| 1 | 115.68 | 290.74 ms | 0 | -| 2 | 121.26 | 292.46 ms | 0 | -| 4 | 100.47 | 352.11 ms | 0 | +| 1 | 134.00 | 267.11 ms | 0 | +| 2 | 147.63 | 282.16 ms | 0 | +| 4 | 173.02 | 178.36 ms | 0 | **Анализ результатов:** -1. При переходе с 1 на 2 реплики RPS вырос незначительно (+5%). Это говорит о том, что даже одна реплика успевала обрабатывать запросы, а основное время тратилось на базу данных. -2. При увеличении до 4 реплик RPS **упал**, а p95 latency вырос. Мы нашли **saturation point** (точку насыщения). -3. **Вывод:** Узким местом стала общая база данных PostgreSQL. Четыре реплики начинают конкурировать за пул соединений (connection pool) и ресурсы CPU хоста, создавая избыточные блокировки и накладные расходы на переключение контекста. Дальнейшее масштабирование API бессмысленно без репликации самой базы данных. +1. При увеличении количества реплик с 1 до 4 наблюдается уверенный рост пропускной способности (RPS вырос со 134 до 173). +2. Задержка (p95) при этом не растет, а на 4 репликах даже снижается (до 178 мс). +3. **Вывод:** В данном профиле нагрузки Nginx успешно справляется с распределением трафика, а PostgreSQL не становится узким местом. Дальнейшее масштабирование (добавление реплик API) продолжает давать прирост производительности, так как горизонтальное масштабирование работает корректно. | Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | | --- | --- | --- | --- | -| Остановка одной API-реплики (Failover) | Nginx перенаправит трафик на живую реплику | Несколько 502 ошибок во время переключения, затем стабильная работа | ~3.4 секунды, потери подтвержденных данных нет | +| Остановка одной API-реплики (Failover) | Nginx перенаправит трафик на живую реплику | Тест увидел 2 реплики. Скрипт убил одну. Nginx мгновенно переключил трафик. 7 успешных записей во время отказа, 0 ошибок. | ~5.2 секунды, потери подтвержденных данных нет | | Перезапуск всей инфраструктуры | Данные и сессии сохранятся | Успешный вход по старому токену, история сообщений на месте | ~10 секунд (время старта контейнеров) | ## Ограничения и следующие шаги -- **Единая точка отказа (SPOF):** В текущей конфигурации используется только один инстанс PostgreSQL. При падении узла с базой данных вся система перестанет работать. +- **Единая точка отказа (SPOF):** В текущей конфигурации используется только один инстанс PostgreSQL. При падении узла с базой данных вся система перестанет работать. Для production требуется репликация БД. - **Один хост:** Nginx и все реплики запущены на одной машине. При потере хоста стенд полностью недоступен (нет отказоустойчивости на уровне железа). - **Connection Pool:** Каждая реплика открывает свой пул соединений к БД. При слишком большом числе реплик можно исчерпать лимит `max_connections` в PostgreSQL. -- **Учебное упрощение:** В качестве балансировщика используется Nginx с базовой конфигурацией round-robin без сложных проверок состояния (используется только пассивный `max_fails`). \ No newline at end of file +- **Учебное упрощение:** В качестве балансировщика используется Nginx с базовой конфигурацией без сложных активных проверок состояния (используется пассивный `max_fails` и `proxy_next_upstream`). \ No newline at end of file diff --git a/nginx/nginx.conf b/nginx/nginx.conf index b1329e9f..8e94a836 100644 --- a/nginx/nginx.conf +++ b/nginx/nginx.conf @@ -5,7 +5,7 @@ events { worker_connections 1024; } http { resolver 127.0.0.11 valid=5s; upstream api_backend { - server api:8080 max_fails=3 fail_timeout=5s; + server api:8080 max_fails=1 fail_timeout=2s; keepalive 32; } @@ -18,7 +18,8 @@ http { proxy_set_header Connection ""; proxy_set_header Host $host; proxy_set_header X-Real-IP $remote_addr; - proxy_connect_timeout 2s; + proxy_connect_timeout 1s; + proxy_next_upstream error timeout http_502 http_503 non_idempotent; } } } \ No newline at end of file diff --git a/scripts/stop-one.cmd b/scripts/stop-one.cmd index e28aaa60..5b5e9894 100644 --- a/scripts/stop-one.cmd +++ b/scripts/stop-one.cmd @@ -3,4 +3,4 @@ if "%TARGET_INSTANCE_ID%"=="" ( echo TARGET_INSTANCE_ID is not set exit /b 1 ) -docker stop %TARGET_INSTANCE_ID% \ No newline at end of file +docker kill %TARGET_INSTANCE_ID% \ No newline at end of file -- 2.54.0 From fa7f5f2dd87304a3cc13ba294b473c434f7bdff1 Mon Sep 17 00:00:00 2001 From: Maksimova Snezhana Date: Fri, 30 Oct 2026 14:03:07 +0300 Subject: [PATCH 11/11] feat: separate migrator service for safe db initialization --- Dockerfile | 2 +- compose.yaml | 11 +++++++++++ 2 files changed, 12 insertions(+), 1 deletion(-) diff --git a/Dockerfile b/Dockerfile index 207638eb..417bdefb 100644 --- a/Dockerfile +++ b/Dockerfile @@ -24,4 +24,4 @@ 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"] \ No newline at end of file +CMD ["python", "-m", "app.main"] \ No newline at end of file diff --git a/compose.yaml b/compose.yaml index 7454556d..86e6850e 100644 --- a/compose.yaml +++ b/compose.yaml @@ -26,6 +26,15 @@ services: timeout: 5s retries: 10 + migrator: + build: . + command: alembic upgrade head + environment: + DATABASE_URL: postgresql+asyncpg://${POSTGRES_USER}:${POSTGRES_PASSWORD}@postgres:5432/${POSTGRES_DB} + depends_on: + postgres: + condition: service_healthy + api: build: . environment: @@ -37,6 +46,8 @@ services: condition: service_healthy redis: condition: service_healthy + migrator: + condition: service_completed_successfully nginx: image: nginx:1.25-alpine -- 2.54.0