From 0c19788bd199b0382cadab82191202f7c1025b83 Mon Sep 17 00:00:00 2001 From: sinveria Date: Wed, 4 Nov 2026 17:14:54 +0300 Subject: [PATCH 01/14] chore: import application foundation from lab1 --- app/__init__.py | 0 app/main.py | 202 ++++++++++++++++++++++++++++++++++++++++++++++++ app/models.py | 102 ++++++++++++++++++++++++ app/store.py | 193 +++++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 497 insertions(+) create mode 100644 app/__init__.py create mode 100644 app/main.py create mode 100644 app/models.py create mode 100644 app/store.py diff --git a/app/__init__.py b/app/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/app/main.py b/app/main.py new file mode 100644 index 0000000..2e74b3b --- /dev/null +++ b/app/main.py @@ -0,0 +1,202 @@ +import logging +import uuid +from contextlib import asynccontextmanager +from typing import Optional + +from fastapi import Depends, FastAPI, Header, HTTPException, Request +from fastapi.exceptions import RequestValidationError +from fastapi.responses import JSONResponse + +from .models import Chat, CreateChat, CreateMessage, CreateUser, User +from .store import InMemoryStore + +logging.basicConfig( + level=logging.INFO, + format="%(asctime)s %(levelname)s %(name)s %(message)s", +) +logger = logging.getLogger(__name__) +store = InMemoryStore() + + +@asynccontextmanager +async def lifespan(app: FastAPI): + logger.info("Application startup") + yield + logger.info("Application shutdown") + + +app = FastAPI(lifespan=lifespan) + + +@app.middleware("http") +async def add_request_id(request: Request, call_next): + request_id = str(uuid.uuid4()) + request.state.request_id = request_id + try: + response = await call_next(request) + except Exception: + logger.exception("Unhandled request error; request_id=%s", request_id) + response = JSONResponse( + status_code=500, + content={ + "error": { + "code": "internal_error", + "message": "Unexpected error", + "request_id": request_id, + } + }, + ) + response.headers["X-Request-Id"] = request_id + return response + + +@app.exception_handler(HTTPException) +async def http_exception_handler(request: Request, exc: HTTPException): + request_id = request.state.request_id + error_code_map = { + 400: "invalid_request", + 401: "unauthorized", + 404: "not_found", + 409: "conflict", + 413: "payload_too_large", + 415: "unsupported_media_type", + 429: "rate_limited", + 500: "internal_error", + 503: "unavailable", + } + return JSONResponse( + status_code=exc.status_code, + content={ + "error": { + "code": error_code_map.get(exc.status_code, "internal_error"), + "message": exc.detail if isinstance(exc.detail, str) else "Request failed", + "request_id": request_id, + } + }, + headers={"X-Request-Id": request_id}, + ) + + +@app.exception_handler(RequestValidationError) +async def validation_exception_handler(request: Request, exc: RequestValidationError): + request_id = request.state.request_id + return JSONResponse( + status_code=400, + content={ + "error": { + "code": "invalid_request", + "message": "Validation error", + "request_id": request_id, + } + }, + headers={"X-Request-Id": request_id}, + ) + + +def get_current_user(x_user_id: Optional[str] = Header(default=None)) -> User: + if not x_user_id: + raise HTTPException(status_code=401, detail="Unauthorized") + user = store.get_user(x_user_id) + if user is None: + raise HTTPException(status_code=401, detail="Unauthorized") + return user + + +def validate_chat_uuid(chat_id: str) -> None: + try: + parsed = uuid.UUID(chat_id) + if str(parsed) != chat_id.lower(): + raise ValueError("non-canonical UUID") + except (ValueError, TypeError, AttributeError): + raise HTTPException(status_code=400, detail="Invalid chat UUID") from None + + +@app.get("/health/live") +def liveness(): + return {"status": "ok"} + + +@app.get("/health/ready") +def readiness(): + return {"status": "ok"} + + +@app.post("/api/v1/users", status_code=201) +def register_user(body: CreateUser): + try: + return store.create_user(body.username, body.display_name) + except ValueError as exc: + if str(exc) == "conflict": + raise HTTPException(status_code=409, detail="Username already exists") from None + raise HTTPException(status_code=400, detail="Invalid request") from None + + +@app.get("/api/v1/users/me") +def current_user(user: User = Depends(get_current_user)): + return user + + +@app.post("/api/v1/chats", status_code=201) +def create_chat(body: CreateChat, user: User = Depends(get_current_user)): + try: + return store.create_chat(body.title, body.member_ids, user.id) + except ValueError: + raise HTTPException(status_code=400, detail="Invalid members or missing creator") from None + + +@app.get("/api/v1/chats") +def list_chats( + limit: int = 50, + cursor: Optional[str] = None, + user: User = Depends(get_current_user), +): + if limit < 1 or limit > 100: + raise HTTPException(status_code=400, detail="Limit out of range") + try: + items, next_cursor = store.list_chats(user.id, limit, cursor) + return {"items": items, "next_cursor": next_cursor} + except ValueError: + raise HTTPException(status_code=400, detail="Invalid cursor") from None + + +@app.get("/api/v1/chats/{chat_id}") +def get_chat(chat_id: str, user: User = Depends(get_current_user)): + validate_chat_uuid(chat_id) + chat = store.get_chat(chat_id, user.id) + if chat is None: + raise HTTPException(status_code=404, detail="Chat not found or access denied") + return chat + + +@app.post("/api/v1/chats/{chat_id}/messages", status_code=201) +def create_message( + chat_id: str, + body: CreateMessage, + user: User = Depends(get_current_user), +): + validate_chat_uuid(chat_id) + try: + return store.create_message(chat_id, user.id, body.text) + except ValueError as exc: + if str(exc) == "not_found": + raise HTTPException(status_code=404, detail="Chat not found or access denied") from None + raise HTTPException(status_code=400, detail="Invalid request") from None + + +@app.get("/api/v1/chats/{chat_id}/messages") +def list_messages( + chat_id: str, + limit: int = 50, + cursor: Optional[str] = None, + user: User = Depends(get_current_user), +): + validate_chat_uuid(chat_id) + if limit < 1 or limit > 100: + raise HTTPException(status_code=400, detail="Limit out of range") + try: + items, next_cursor = store.list_messages(chat_id, user.id, limit, cursor) + return {"items": items, "next_cursor": next_cursor} + except ValueError as exc: + if str(exc) == "not_found": + raise HTTPException(status_code=404, detail="Chat not found or access denied") from None + raise HTTPException(status_code=400, detail="Invalid cursor") from None \ No newline at end of file diff --git a/app/models.py b/app/models.py new file mode 100644 index 0000000..142e41d --- /dev/null +++ b/app/models.py @@ -0,0 +1,102 @@ +from datetime import datetime, timezone +from typing import List, Optional + +from pydantic import BaseModel, ConfigDict, Field, field_validator + + +class BaseConfig(BaseModel): + model_config = ConfigDict( + json_encoders={ + datetime: lambda value: value.astimezone(timezone.utc) + .isoformat(timespec="microseconds") + .replace("+00:00", "Z") + if value + else None + }, + ) + + +class CreateUser(BaseConfig): + username: str = Field(..., pattern=r"^[a-z0-9_]{3,32}$") + display_name: str = Field(..., min_length=1, max_length=100) + + @field_validator("display_name") + @classmethod + def validate_display_name(cls, value: str) -> str: + value = value.strip() + if not value: + raise ValueError("display_name must not be blank") + return value + + +class User(CreateUser): + id: str + created_at: datetime + + +class CreateChat(BaseConfig): + title: str = Field(..., min_length=1, max_length=100) + member_ids: List[str] = Field(..., min_length=1, max_length=100) + + @field_validator("title") + @classmethod + def validate_title(cls, value: str) -> str: + value = value.strip() + if not value: + raise ValueError("title must not be blank") + return value + + @field_validator("member_ids") + @classmethod + def validate_unique_members(cls, value: List[str]) -> List[str]: + if len(value) != len(set(value)): + raise ValueError("member_ids must be unique") + return value + + +class Chat(CreateChat): + id: str + created_at: datetime + + +class CreateMessage(BaseConfig): + text: str = Field(..., min_length=1, max_length=4000) + + @field_validator("text") + @classmethod + def validate_text(cls, value: str) -> str: + value = value.strip() + if not value: + raise ValueError("text must not be blank") + return value + + +class Message(CreateMessage): + id: str + chat_id: str + sender_id: str + created_at: datetime + + +class Health(BaseConfig): + status: str = "ok" + + +class ErrorDetail(BaseConfig): + code: str + message: str + request_id: str + + +class ErrorResponse(BaseConfig): + error: ErrorDetail + + +class ChatPage(BaseConfig): + items: List[Chat] + next_cursor: Optional[str] = None + + +class MessagePage(BaseConfig): + items: List[Message] + next_cursor: Optional[str] = None diff --git a/app/store.py b/app/store.py new file mode 100644 index 0000000..4802821 --- /dev/null +++ b/app/store.py @@ -0,0 +1,193 @@ +import base64 +import bisect +import binascii +import json +import os +import threading +import uuid +from datetime import datetime, timezone +from typing import Dict, List, Optional, Tuple + +from .models import Chat, Message, User + + +Key = Tuple[datetime, str] + + +def _encode_cursor(kind: str, scope: str, item) -> str: + payload = { + "v": 1, + "kind": kind, + "scope": scope, + "created_at": item.created_at.isoformat(), + "id": item.id, + } + raw = json.dumps(payload, separators=(",", ":")).encode("utf-8") + return base64.urlsafe_b64encode(raw).decode("ascii").rstrip("=") + + +def _decode_cursor(cursor: str, kind: str, scope: str) -> Key: + try: + if not cursor or len(cursor) > 4096: + raise ValueError + padded = cursor + "=" * (-len(cursor) % 4) + raw = base64.b64decode(padded, altchars=b"-_", validate=True) + payload = json.loads(raw.decode("utf-8")) + if not isinstance(payload, dict) or payload.get("v") != 1: + raise ValueError + if payload.get("kind") != kind or payload.get("scope") != scope: + raise ValueError + item_id = payload.get("id") + timestamp = payload.get("created_at") + if not isinstance(item_id, str) or not isinstance(timestamp, str): + raise ValueError + created_at = datetime.fromisoformat(timestamp) + if created_at.tzinfo is None: + raise ValueError + created_at = created_at.astimezone(timezone.utc) + return created_at, item_id + except ( + ValueError, + TypeError, + KeyError, + UnicodeDecodeError, + json.JSONDecodeError, + binascii.Error, + ): + raise ValueError("invalid_request") from None + + +class InMemoryStore: + def __init__(self): + self._lock = threading.RLock() + self.users: Dict[str, User] = {} + self.chats: Dict[str, Chat] = {} + self.messages: Dict[str, List[Message]] = {} + self.usernames: Dict[str, str] = {} + self.message_keys: Dict[str, List[Key]] = {} + self.message_index_enabled = os.getenv("MESSAGE_INDEX_ENABLED", "1") != "0" + + def create_user(self, username: str, display_name: str) -> User: + with self._lock: + if username in self.usernames: + raise ValueError("conflict") + user_id = str(uuid.uuid4()) + user = User( + id=user_id, + username=username, + display_name=display_name, + created_at=datetime.now(timezone.utc), + ) + self.users[user_id] = user + self.usernames[username] = user_id + return user + + def get_user(self, user_id: str) -> Optional[User]: + with self._lock: + return self.users.get(user_id) + + def create_chat(self, title: str, member_ids: List[str], creator_id: str) -> Chat: + with self._lock: + if creator_id not in member_ids or len(member_ids) != len(set(member_ids)): + raise ValueError("invalid_request") + if any(member_id not in self.users for member_id in member_ids): + raise ValueError("invalid_request") + + chat_id = str(uuid.uuid4()) + chat = Chat( + id=chat_id, + title=title, + member_ids=list(member_ids), + created_at=datetime.now(timezone.utc), + ) + self.chats[chat_id] = chat + self.messages[chat_id] = [] + self.message_keys[chat_id] = [] + return chat + + def get_chat(self, chat_id: str, user_id: str) -> Optional[Chat]: + with self._lock: + chat = self.chats.get(chat_id) + if chat is None or user_id not in chat.member_ids: + return None + return chat + + def list_chats( + self, user_id: str, limit: int, cursor: Optional[str] + ) -> Tuple[List[Chat], Optional[str]]: + with self._lock: + user_chats = [chat for chat in self.chats.values() if user_id in chat.member_ids] + user_chats.sort(key=lambda chat: (chat.created_at, chat.id)) + keys = [(chat.created_at, chat.id) for chat in user_chats] + + start_index = 0 + if cursor: + target_key = _decode_cursor(cursor, kind="chats", scope=user_id) + start_index = bisect.bisect_right(keys, target_key) + + page_with_extra = user_chats[start_index : start_index + limit + 1] + has_next = len(page_with_extra) > limit + page = page_with_extra[:limit] + next_cursor = None + if has_next and page: + next_cursor = _encode_cursor("chats", user_id, page[-1]) + return page, next_cursor + + def create_message(self, chat_id: str, sender_id: str, text: str) -> Message: + with self._lock: + chat = self.chats.get(chat_id) + if chat is None or sender_id not in chat.member_ids: + raise ValueError("not_found") + + message = Message( + id=str(uuid.uuid4()), + chat_id=chat_id, + sender_id=sender_id, + text=text, + created_at=datetime.now(timezone.utc), + ) + messages = self.messages[chat_id] + keys = self.message_keys[chat_id] + key = (message.created_at, message.id) + + if self.message_index_enabled: + index = bisect.bisect_right(keys, key) + keys.insert(index, key) + messages.insert(index, message) + else: + current_keys = [(item.created_at, item.id) for item in messages] + index = bisect.bisect_right(current_keys, key) + messages.insert(index, message) + keys.insert(index, key) + return message + + def list_messages( + self, + chat_id: str, + user_id: str, + limit: int, + cursor: Optional[str], + ) -> Tuple[List[Message], Optional[str]]: + with self._lock: + chat = self.chats.get(chat_id) + if chat is None or user_id not in chat.member_ids: + raise ValueError("not_found") + + messages = self.messages[chat_id] + if self.message_index_enabled: + keys = self.message_keys[chat_id] + else: + keys = [(item.created_at, item.id) for item in messages] + + start_index = 0 + if cursor: + target_key = _decode_cursor(cursor, kind="messages", scope=chat_id) + start_index = bisect.bisect_right(keys, target_key) + + page_with_extra = messages[start_index : start_index + limit + 1] + has_next = len(page_with_extra) > limit + page = page_with_extra[:limit] + next_cursor = None + if has_next and page: + next_cursor = _encode_cursor("messages", chat_id, page[-1]) + return page, next_cursor -- 2.54.0 From 288620a10781476798f07107727ee0cbe9e484ba Mon Sep 17 00:00:00 2001 From: sinveria Date: Wed, 4 Nov 2026 17:17:15 +0300 Subject: [PATCH 02/14] chore: prepare backend architecture --- app/api/__init__.py | 0 app/core/__init__.py | 0 app/db/__init__.py | 0 app/repositories/__init__.py | 0 app/services/__init__.py | 0 5 files changed, 0 insertions(+), 0 deletions(-) create mode 100644 app/api/__init__.py create mode 100644 app/core/__init__.py create mode 100644 app/db/__init__.py create mode 100644 app/repositories/__init__.py create mode 100644 app/services/__init__.py diff --git a/app/api/__init__.py b/app/api/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/app/core/__init__.py b/app/core/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/app/db/__init__.py b/app/db/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/app/repositories/__init__.py b/app/repositories/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/app/services/__init__.py b/app/services/__init__.py new file mode 100644 index 0000000..e69de29 -- 2.54.0 From e29a0a2bea7bfc729b94d749dbcd0e189fe8e198 Mon Sep 17 00:00:00 2001 From: sinveria Date: Wed, 4 Nov 2026 17:21:29 +0300 Subject: [PATCH 03/14] build: add lab2 backend dependencies --- requirements.txt | 9 +++++++++ 1 file changed, 9 insertions(+) create mode 100644 requirements.txt diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..e519117 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,9 @@ +fastapi==0.115.6 +uvicorn[standard]==0.34.0 +pydantic==2.10.4 +pydantic-settings==2.7.1 +SQLAlchemy==2.0.36 +psycopg[binary]==3.2.3 +alembic==1.14.0 +redis==5.2.1 +pwdlib[argon2]==0.2.1 -- 2.54.0 From 77875db0d02bd8d1d91f3fda544e49694a7f3cda Mon Sep 17 00:00:00 2001 From: sinveria Date: Wed, 4 Nov 2026 17:33:11 +0300 Subject: [PATCH 04/14] feat: add PostgreSQL schema and Docker infrastructure --- alembic.ini | 117 +++++++++++ app/core/config.py | 22 +++ app/db/base.py | 5 + app/db/models.py | 184 ++++++++++++++++++ app/db/session.py | 19 ++ compose.yaml | 40 ++++ migrations/README | 1 + migrations/env.py | 60 ++++++ migrations/script.py.mako | 26 +++ ...89656327_create_initial_database_schema.py | 79 ++++++++ 10 files changed, 553 insertions(+) create mode 100644 alembic.ini create mode 100644 app/core/config.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 compose.yaml create mode 100644 migrations/README create mode 100644 migrations/env.py create mode 100644 migrations/script.py.mako create mode 100644 migrations/versions/21ad89656327_create_initial_database_schema.py diff --git a/alembic.ini b/alembic.ini new file mode 100644 index 0000000..421e3fe --- /dev/null +++ b/alembic.ini @@ -0,0 +1,117 @@ +# A generic, single database configuration. + +[alembic] +# path to migration scripts +# Use forward slashes (/) also on windows to provide an os agnostic path +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 +# see https://alembic.sqlalchemy.org/en/latest/tutorial.html#editing-the-ini-file +# for all available tokens +# 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 = newline +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 = WARNING +handlers = console +qualname = + +[logger_sqlalchemy] +level = WARNING +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/core/config.py b/app/core/config.py new file mode 100644 index 0000000..b0b5574 --- /dev/null +++ b/app/core/config.py @@ -0,0 +1,22 @@ +from pydantic_settings import BaseSettings, SettingsConfigDict + + +class Settings(BaseSettings): + app_name: str = "Messenger API" + app_env: str = "lab" + + database_url: str = ( + "postgresql+psycopg://messenger:messenger@localhost:5432/messenger" + ) + + session_ttl_seconds: int = 3600 + cache_url: str = "redis://localhost:6379/0" + + model_config = SettingsConfigDict( + env_file=".env", + env_file_encoding="utf-8", + extra="ignore", + ) + + +settings = Settings() \ No newline at end of file diff --git a/app/db/base.py b/app/db/base.py new file mode 100644 index 0000000..1c2dcc4 --- /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 0000000..e04a3d1 --- /dev/null +++ b/app/db/models.py @@ -0,0 +1,184 @@ +import uuid + +from datetime import datetime, timezone + +from sqlalchemy import ( + DateTime, + ForeignKey, + Index, + String, + Text, + UniqueConstraint, +) +from sqlalchemy.dialects.postgresql import UUID +from sqlalchemy.orm import Mapped, mapped_column, relationship + +from app.db.base import Base + + +def utc_now() -> datetime: + return datetime.now(timezone.utc) + + +class User(Base): + __tablename__ = "users" + + id: Mapped[uuid.UUID] = mapped_column( + UUID(as_uuid=True), + primary_key=True, + default=uuid.uuid4, + ) + username: Mapped[str] = mapped_column( + String(32), + unique=True, + nullable=False, + index=True, + ) + display_name: Mapped[str] = mapped_column( + String(100), + nullable=False, + ) + password_hash: Mapped[str] = mapped_column( + String(255), + nullable=False, + ) + created_at: Mapped[datetime] = mapped_column( + DateTime(timezone=True), + default=utc_now, + nullable=False, + ) + + memberships: Mapped[list["ChatMember"]] = relationship( + back_populates="user", + cascade="all, delete-orphan", + ) + messages: Mapped[list["Message"]] = relationship( + back_populates="sender", + ) + + +class Chat(Base): + __tablename__ = "chats" + + id: Mapped[uuid.UUID] = mapped_column( + UUID(as_uuid=True), + primary_key=True, + default=uuid.uuid4, + ) + title: Mapped[str] = mapped_column( + String(100), + nullable=False, + ) + created_at: Mapped[datetime] = mapped_column( + DateTime(timezone=True), + default=utc_now, + nullable=False, + ) + + members: Mapped[list["ChatMember"]] = relationship( + back_populates="chat", + cascade="all, delete-orphan", + ) + messages: Mapped[list["Message"]] = relationship( + back_populates="chat", + cascade="all, delete-orphan", + ) + + +class ChatMember(Base): + __tablename__ = "chat_members" + + chat_id: Mapped[uuid.UUID] = mapped_column( + UUID(as_uuid=True), + ForeignKey("chats.id", ondelete="CASCADE"), + primary_key=True, + ) + user_id: Mapped[uuid.UUID] = mapped_column( + UUID(as_uuid=True), + ForeignKey("users.id", ondelete="CASCADE"), + primary_key=True, + ) + + chat: Mapped["Chat"] = relationship( + back_populates="members", + ) + user: Mapped["User"] = relationship( + back_populates="memberships", + ) + + +class Message(Base): + __tablename__ = "messages" + + id: Mapped[uuid.UUID] = mapped_column( + UUID(as_uuid=True), + primary_key=True, + default=uuid.uuid4, + ) + chat_id: Mapped[uuid.UUID] = mapped_column( + UUID(as_uuid=True), + ForeignKey("chats.id", ondelete="CASCADE"), + nullable=False, + ) + sender_id: Mapped[uuid.UUID] = mapped_column( + UUID(as_uuid=True), + ForeignKey("users.id"), + nullable=False, + ) + text: Mapped[str] = mapped_column( + Text, + nullable=False, + ) + created_at: Mapped[datetime] = mapped_column( + DateTime(timezone=True), + default=utc_now, + nullable=False, + ) + + chat: Mapped["Chat"] = relationship( + back_populates="messages", + ) + sender: Mapped["User"] = relationship( + back_populates="messages", + ) + + __table_args__ = ( + Index( + "ix_messages_chat_created_id", + "chat_id", + "created_at", + "id", + ), + ) + + +class Session(Base): + __tablename__ = "sessions" + + id: Mapped[uuid.UUID] = mapped_column( + UUID(as_uuid=True), + primary_key=True, + default=uuid.uuid4, + ) + token_hash: Mapped[str] = mapped_column( + String(64), + unique=True, + nullable=False, + index=True, + ) + user_id: Mapped[uuid.UUID] = mapped_column( + UUID(as_uuid=True), + ForeignKey("users.id", ondelete="CASCADE"), + nullable=False, + ) + expires_at: Mapped[datetime] = mapped_column( + DateTime(timezone=True), + nullable=False, + ) + created_at: Mapped[datetime] = mapped_column( + DateTime(timezone=True), + default=utc_now, + nullable=False, + ) + + user: Mapped["User"] = relationship() \ No newline at end of file diff --git a/app/db/session.py b/app/db/session.py new file mode 100644 index 0000000..8fdd966 --- /dev/null +++ b/app/db/session.py @@ -0,0 +1,19 @@ +from sqlalchemy import create_engine +from sqlalchemy.orm import sessionmaker + +from app.core.config import settings + + +engine = create_engine( + settings.database_url, + pool_pre_ping=True, + pool_size=5, + max_overflow=10, + pool_timeout=30, +) + +SessionLocal = sessionmaker( + bind=engine, + autoflush=False, + autocommit=False, +) \ No newline at end of file diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 0000000..0bbff2e --- /dev/null +++ b/compose.yaml @@ -0,0 +1,40 @@ +services: + postgres: + image: postgres:16.6 + container_name: mtusi-lab2-postgres + restart: unless-stopped + environment: + POSTGRES_DB: ${POSTGRES_DB} + POSTGRES_USER: ${POSTGRES_USER} + POSTGRES_PASSWORD: ${POSTGRES_PASSWORD} + ports: + - "${POSTGRES_HOST_PORT}:5432" + volumes: + - lab2_postgres_data:/var/lib/postgresql/data + healthcheck: + test: + - CMD-SHELL + - pg_isready -U "$$POSTGRES_USER" -d "$$POSTGRES_DB" + interval: 5s + timeout: 5s + retries: 10 + start_period: 10s + + redis: + image: redis:7.4.2 + container_name: mtusi-lab2-redis + restart: unless-stopped + command: redis-server --appendonly yes + ports: + - "${REDIS_PORT}:6379" + volumes: + - lab2_redis_data:/data + healthcheck: + test: ["CMD", "redis-cli", "ping"] + interval: 5s + timeout: 3s + retries: 10 + +volumes: + lab2_postgres_data: + lab2_redis_data: \ No newline at end of file diff --git a/migrations/README b/migrations/README new file mode 100644 index 0000000..98e4f9c --- /dev/null +++ b/migrations/README @@ -0,0 +1 @@ +Generic single-database configuration. \ No newline at end of file diff --git a/migrations/env.py b/migrations/env.py new file mode 100644 index 0000000..0bc520a --- /dev/null +++ b/migrations/env.py @@ -0,0 +1,60 @@ +from logging.config import fileConfig + +from alembic import context +from sqlalchemy import engine_from_config, pool + +from app.core.config import settings +from app.db.base import Base +from app.db import models + + +config = context.config + +if config.config_file_name is not None: + fileConfig(config.config_file_name) + +config.set_main_option( + "sqlalchemy.url", + settings.database_url.replace("%", "%%"), +) + +target_metadata = Base.metadata + + +def run_migrations_offline() -> None: + url = settings.database_url + + context.configure( + url=url, + target_metadata=target_metadata, + literal_binds=True, + dialect_opts={"paramstyle": "named"}, + compare_type=True, + ) + + with context.begin_transaction(): + context.run_migrations() + + +def run_migrations_online() -> None: + connectable = engine_from_config( + config.get_section(config.config_ini_section, {}), + prefix="sqlalchemy.", + poolclass=pool.NullPool, + ) + + with connectable.connect() as connection: + context.configure( + connection=connection, + target_metadata=target_metadata, + compare_type=True, + ) + + with context.begin_transaction(): + context.run_migrations() + + +if context.is_offline_mode(): + run_migrations_offline() +else: + run_migrations_online() \ No newline at end of file diff --git a/migrations/script.py.mako b/migrations/script.py.mako new file mode 100644 index 0000000..fbc4b07 --- /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/21ad89656327_create_initial_database_schema.py b/migrations/versions/21ad89656327_create_initial_database_schema.py new file mode 100644 index 0000000..6c48b76 --- /dev/null +++ b/migrations/versions/21ad89656327_create_initial_database_schema.py @@ -0,0 +1,79 @@ +"""create initial database schema + +Revision ID: 21ad89656327 +Revises: +Create Date: 2026-11-04 17:31:39.336368 + +""" +from typing import Sequence, Union + +from alembic import op +import sqlalchemy as sa + + +# revision identifiers, used by Alembic. +revision: str = '21ad89656327' +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_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.String(length=255), 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_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('ix_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('token_hash', sa.String(length=64), nullable=False), + sa.Column('user_id', sa.UUID(), 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_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_table('sessions') + op.drop_index('ix_messages_chat_created_id', table_name='messages') + op.drop_table('messages') + op.drop_table('chat_members') + op.drop_index(op.f('ix_users_username'), table_name='users') + op.drop_table('users') + op.drop_table('chats') + # ### end Alembic commands ### -- 2.54.0 From c4f243672b839a48440ef6550d2b04174d7deddc Mon Sep 17 00:00:00 2001 From: sinveria Date: Wed, 4 Nov 2026 17:38:59 +0300 Subject: [PATCH 05/14] feat: implement PostgreSQL repositories --- app/repositories/chat_repository.py | 71 +++++++++++++++++++++++ app/repositories/message_repository.py | 71 +++++++++++++++++++++++ app/repositories/session_repository.py | 78 ++++++++++++++++++++++++++ app/repositories/user_repository.py | 41 ++++++++++++++ 4 files changed, 261 insertions(+) create mode 100644 app/repositories/chat_repository.py create mode 100644 app/repositories/message_repository.py create mode 100644 app/repositories/session_repository.py create mode 100644 app/repositories/user_repository.py diff --git a/app/repositories/chat_repository.py b/app/repositories/chat_repository.py new file mode 100644 index 0000000..e5cd838 --- /dev/null +++ b/app/repositories/chat_repository.py @@ -0,0 +1,71 @@ +import uuid + +from sqlalchemy import select +from sqlalchemy.orm import Session, selectinload + +from app.db.models import Chat, ChatMember + + +class ChatRepository: + + def __init__(self, db: Session): + self.db = db + + def get_by_id(self, chat_id: uuid.UUID) -> Chat | None: + statement = ( + select(Chat) + .options(selectinload(Chat.members)) + .where(Chat.id == chat_id) + ) + + return self.db.scalar(statement) + + def get_by_user( + self, + user_id: uuid.UUID, + limit: int = 50, + ) -> list[Chat]: + statement = ( + 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) + ) + + return list(self.db.scalars(statement).all()) + + def is_member( + self, + chat_id: uuid.UUID, + user_id: uuid.UUID, + ) -> bool: + statement = select(ChatMember).where( + ChatMember.chat_id == chat_id, + ChatMember.user_id == user_id, + ) + + return self.db.scalar(statement) is not None + + def create( + self, + title: str, + member_ids: list[uuid.UUID], + ) -> Chat: + chat = Chat(title=title) + + self.db.add(chat) + self.db.flush() + + memberships = [ + ChatMember( + chat_id=chat.id, + user_id=user_id, + ) + for user_id in member_ids + ] + + self.db.add_all(memberships) + self.db.flush() + + return chat \ No newline at end of file diff --git a/app/repositories/message_repository.py b/app/repositories/message_repository.py new file mode 100644 index 0000000..6698ed1 --- /dev/null +++ b/app/repositories/message_repository.py @@ -0,0 +1,71 @@ +import uuid + +from datetime import datetime + +from sqlalchemy import and_, or_, select +from sqlalchemy.orm import Session + +from app.db.models import Message + + +class MessageRepository: + + def __init__(self, db: Session): + self.db = db + + def get_by_id( + self, + message_id: uuid.UUID, + ) -> Message | None: + statement = select(Message).where( + Message.id == message_id + ) + + return self.db.scalar(statement) + + def create( + self, + chat_id: uuid.UUID, + sender_id: uuid.UUID, + text: str, + ) -> Message: + message = Message( + chat_id=chat_id, + sender_id=sender_id, + text=text, + ) + + self.db.add(message) + self.db.flush() + + return message + + def get_history( + self, + chat_id: uuid.UUID, + limit: int = 50, + cursor_created_at: datetime | None = None, + cursor_id: uuid.UUID | None = None, + ) -> list[Message]: + statement = select(Message).where( + Message.chat_id == chat_id + ) + + if cursor_created_at is not None and cursor_id is not None: + statement = statement.where( + or_( + Message.created_at > cursor_created_at, + and_( + Message.created_at == cursor_created_at, + Message.id > cursor_id, + ), + ) + ) + + statement = ( + statement + .order_by(Message.created_at.asc(), Message.id.asc()) + .limit(limit) + ) + + return list(self.db.scalars(statement).all()) \ No newline at end of file diff --git a/app/repositories/session_repository.py b/app/repositories/session_repository.py new file mode 100644 index 0000000..7366b17 --- /dev/null +++ b/app/repositories/session_repository.py @@ -0,0 +1,78 @@ +import uuid + +from datetime import datetime, timezone + +from sqlalchemy import delete, select +from sqlalchemy.orm import Session + +from app.db.models import Session as UserSession + + +class SessionRepository: + + def __init__(self, db: Session): + self.db = db + + def create( + self, + user_id: uuid.UUID, + token_hash: str, + expires_at: datetime, + ) -> UserSession: + session = UserSession( + user_id=user_id, + token_hash=token_hash, + expires_at=expires_at, + ) + + self.db.add(session) + self.db.flush() + + return session + + def get_by_token_hash( + self, + token_hash: str, + ) -> UserSession | None: + statement = select(UserSession).where( + UserSession.token_hash == token_hash + ) + + return self.db.scalar(statement) + + def get_valid_session( + self, + token_hash: str, + ) -> UserSession | None: + now = datetime.now(timezone.utc) + + statement = select(UserSession).where( + UserSession.token_hash == token_hash, + UserSession.expires_at > now, + ) + + return self.db.scalar(statement) + + def delete_by_token_hash( + self, + token_hash: str, + ) -> bool: + statement = ( + delete(UserSession) + .where(UserSession.token_hash == token_hash) + .returning(UserSession.id) + ) + + return self.db.scalar(statement) is not None + + def delete_expired(self) -> int: + now = datetime.now(timezone.utc) + + statement = ( + delete(UserSession) + .where(UserSession.expires_at <= now) + ) + + result = self.db.execute(statement) + + return result.rowcount \ No newline at end of file diff --git a/app/repositories/user_repository.py b/app/repositories/user_repository.py new file mode 100644 index 0000000..4569dcd --- /dev/null +++ b/app/repositories/user_repository.py @@ -0,0 +1,41 @@ +import uuid + +from sqlalchemy import select +from sqlalchemy.orm import Session + +from app.db.models import User + + +class UserRepository: + + def __init__(self, db: Session): + self.db = db + + def get_by_id(self, user_id: uuid.UUID) -> User | None: + statement = select(User).where(User.id == user_id) + + return self.db.scalar(statement) + + def get_by_username(self, username: str) -> User | None: + statement = select(User).where( + User.username == username + ) + + return self.db.scalar(statement) + + def create( + self, + username: str, + display_name: str, + password_hash: str, + ) -> User: + user = User( + username=username, + display_name=display_name, + password_hash=password_hash, + ) + + self.db.add(user) + self.db.flush() + + return user \ No newline at end of file -- 2.54.0 From 85207f3203ffeb18dc506608344b56ed2e17b958 Mon Sep 17 00:00:00 2001 From: sinveria Date: Wed, 4 Nov 2026 17:44:27 +0300 Subject: [PATCH 06/14] feat: implement user registration service --- app/services/user_service.py | 81 ++++++++++++++++++++++++++++++++++++ 1 file changed, 81 insertions(+) create mode 100644 app/services/user_service.py diff --git a/app/services/user_service.py b/app/services/user_service.py new file mode 100644 index 0000000..896ee5e --- /dev/null +++ b/app/services/user_service.py @@ -0,0 +1,81 @@ +import re + +from sqlalchemy.exc import IntegrityError +from sqlalchemy.orm import Session +from pwdlib import PasswordHash + +from app.db.models import User +from app.repositories.user_repository import UserRepository + + +password_hasher = PasswordHash.recommended() + + +class UsernameAlreadyExistsError(Exception): + pass + + +class UserService: + + def __init__(self, db: Session): + self.db = db + self.users = UserRepository(db) + + def register( + self, + username: str, + display_name: str, + password: str, + ) -> User: + + if not re.fullmatch(r"[a-z0-9_]{3,32}", username): + raise ValueError("Invalid username") + + if not display_name or not display_name.strip(): + raise ValueError("Display name cannot be empty") + + if len(display_name) > 100: + raise ValueError("Display name is too long") + + if not 12 <= len(password) <= 128: + raise ValueError("Invalid password length") + + if self.users.get_by_username(username) is not None: + raise UsernameAlreadyExistsError( + "Username already exists" + ) + + password_hash = password_hasher.hash(password) + + try: + user = self.users.create( + username=username, + display_name=display_name, + password_hash=password_hash, + ) + + self.db.commit() + self.db.refresh(user) + + return user + + except IntegrityError as exc: + self.db.rollback() + + raise UsernameAlreadyExistsError( + "Username already exists" + ) from exc + + except Exception: + self.db.rollback() + raise + + def verify_password( + self, + user: User, + password: str, + ) -> bool: + return password_hasher.verify( + password, + user.password_hash, + ) \ No newline at end of file -- 2.54.0 From 23d16a1cc34bcd1d495699596ff29b1000fe4831 Mon Sep 17 00:00:00 2001 From: sinveria Date: Wed, 4 Nov 2026 17:46:51 +0300 Subject: [PATCH 07/14] feat: implement authentication and session service --- app/services/auth_service.py | 132 +++++++++++++++++++++++++++++++++++ 1 file changed, 132 insertions(+) create mode 100644 app/services/auth_service.py diff --git a/app/services/auth_service.py b/app/services/auth_service.py new file mode 100644 index 0000000..7a6990b --- /dev/null +++ b/app/services/auth_service.py @@ -0,0 +1,132 @@ +import hashlib +import secrets +from datetime import datetime, timedelta, timezone + +from redis import Redis +from redis.exceptions import RedisError +from sqlalchemy.orm import Session + +from app.core.config import settings +from app.db.models import User +from app.repositories.session_repository import SessionRepository +from app.repositories.user_repository import UserRepository +from app.services.user_service import password_hasher + + +class InvalidCredentialsError(Exception): + pass + + +class InvalidSessionError(Exception): + pass + + +class AuthService: + def __init__(self, db: Session): + self.db = db + self.sessions = SessionRepository(db) + self.users = UserRepository(db) + self.redis = Redis.from_url( + settings.cache_url, + decode_responses=True, + socket_connect_timeout=2, + socket_timeout=2, + ) + + @staticmethod + def _hash_token(token: str) -> str: + return hashlib.sha256(token.encode("utf-8")).hexdigest() + + def create_session(self, username: str, password: str) -> dict: + user = self.users.get_by_username(username) + + if user is None or not password_hasher.verify( + password, user.password_hash + ): + raise InvalidCredentialsError("Invalid username or password") + + token = secrets.token_urlsafe(32) + token_hash = self._hash_token(token) + + expires_at = datetime.now(timezone.utc) + timedelta( + seconds=settings.session_ttl_seconds + ) + + try: + self.sessions.create( + user_id=user.id, + token_hash=token_hash, + expires_at=expires_at, + ) + self.db.commit() + except Exception: + self.db.rollback() + raise + + self._cache_session(token_hash, user.id, expires_at) + + return { + "token": token, + "token_type": "Bearer", + "expires_at": expires_at, + "user": user, + } + + def _cache_session(self, token_hash: str, user_id, expires_at) -> None: + ttl = max( + 1, + int((expires_at - datetime.now(timezone.utc)).total_seconds()), + ) + + try: + self.redis.setex( + f"session:{token_hash}", + ttl, + str(user_id), + ) + except RedisError: + pass + + def authenticate(self, token: str) -> User: + token_hash = self._hash_token(token) + + try: + cached_user_id = self.redis.get(f"session:{token_hash}") + except RedisError: + cached_user_id = None + + session = self.sessions.get_valid_session(token_hash) + + if session is None: + try: + self.redis.delete(f"session:{token_hash}") + except RedisError: + pass + raise InvalidSessionError("Session is invalid or expired") + + if cached_user_id is None: + self._cache_session( + token_hash, + session.user_id, + session.expires_at, + ) + + return session.user + + def delete_session(self, token: str) -> None: + token_hash = self._hash_token(token) + + try: + deleted = self.sessions.delete_by_token_hash(token_hash) + if not deleted: + raise InvalidSessionError("Session is invalid or expired") + + self.db.commit() + except Exception: + self.db.rollback() + raise + + try: + self.redis.delete(f"session:{token_hash}") + except RedisError: + pass -- 2.54.0 From 37bebacc1400454b3dbb5ff258594d2ac1784877 Mon Sep 17 00:00:00 2001 From: sinveria Date: Wed, 4 Nov 2026 17:49:52 +0300 Subject: [PATCH 08/14] feat: update API models for lab2 --- app/models.py | 24 ++++++++++++++++-------- 1 file changed, 16 insertions(+), 8 deletions(-) diff --git a/app/models.py b/app/models.py index 142e41d..ace6808 100644 --- a/app/models.py +++ b/app/models.py @@ -1,3 +1,4 @@ + from datetime import datetime, timezone from typing import List, Optional @@ -6,12 +7,13 @@ from pydantic import BaseModel, ConfigDict, Field, field_validator class BaseConfig(BaseModel): model_config = ConfigDict( + from_attributes=True, json_encoders={ - datetime: lambda value: value.astimezone(timezone.utc) - .isoformat(timespec="microseconds") - .replace("+00:00", "Z") - if value - else None + datetime: lambda value: ( + value.astimezone(timezone.utc) + .isoformat(timespec="microseconds") + .replace("+00:00", "Z") + ) }, ) @@ -19,6 +21,7 @@ class BaseConfig(BaseModel): class CreateUser(BaseConfig): 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") @classmethod @@ -29,8 +32,10 @@ class CreateUser(BaseConfig): return value -class User(CreateUser): +class User(BaseConfig): id: str + username: str + display_name: str created_at: datetime @@ -54,8 +59,10 @@ class CreateChat(BaseConfig): return value -class Chat(CreateChat): +class Chat(BaseConfig): id: str + title: str + member_ids: List[str] created_at: datetime @@ -71,10 +78,11 @@ class CreateMessage(BaseConfig): return value -class Message(CreateMessage): +class Message(BaseConfig): id: str chat_id: str sender_id: str + text: str created_at: datetime -- 2.54.0 From c0d8f15d75809c8577af069a18b5ef96a71b2db4 Mon Sep 17 00:00:00 2001 From: sinveria Date: Wed, 4 Nov 2026 17:52:41 +0300 Subject: [PATCH 09/14] feat: add user and authentication API endpoints --- app/api/auth.py | 84 ++++++++++++++++++++++++++++++++++++++++++++++++ app/api/deps.py | 46 ++++++++++++++++++++++++++ app/api/users.py | 55 +++++++++++++++++++++++++++++++ 3 files changed, 185 insertions(+) create mode 100644 app/api/auth.py create mode 100644 app/api/deps.py create mode 100644 app/api/users.py diff --git a/app/api/auth.py b/app/api/auth.py new file mode 100644 index 0000000..3141b3b --- /dev/null +++ b/app/api/auth.py @@ -0,0 +1,84 @@ +from fastapi import APIRouter, Depends, Header, HTTPException, status +from fastapi.security import HTTPBasic, HTTPBasicCredentials +from sqlalchemy.orm import Session + +from app.api.deps import get_db +from app.api.users import user_to_response +from app.services.auth_service import ( + AuthService, + InvalidCredentialsError, + InvalidSessionError, +) + + +router = APIRouter(prefix="/api/v1/auth", tags=["Authentication"]) + +basic_security = HTTPBasic(auto_error=False) + + +@router.post("/sessions", status_code=status.HTTP_201_CREATED) +def create_session( + credentials: HTTPBasicCredentials = Depends(basic_security), + db: Session = Depends(get_db), +): + if credentials is None: + raise HTTPException( + status_code=status.HTTP_401_UNAUTHORIZED, + detail="Basic authentication required", + headers={ + "WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"' + }, + ) + + try: + result = AuthService(db).create_session( + username=credentials.username, + password=credentials.password, + ) + + return { + "token": result["token"], + "token_type": result["token_type"], + "expires_at": result["expires_at"], + "user": user_to_response(result["user"]), + } + + except InvalidCredentialsError: + raise HTTPException( + status_code=status.HTTP_401_UNAUTHORIZED, + detail="Invalid username or password", + headers={ + "WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"' + }, + ) from None + + +@router.delete("/sessions/current", status_code=status.HTTP_204_NO_CONTENT) +def delete_current_session( + authorization: str | None = Header(default=None), + db: Session = Depends(get_db), +): + if not authorization or not authorization.startswith("Bearer "): + raise HTTPException( + status_code=status.HTTP_401_UNAUTHORIZED, + detail="Bearer token required", + headers={"WWW-Authenticate": 'Bearer realm="messenger"'}, + ) + + token = authorization[7:].strip() + + if not token: + raise HTTPException( + status_code=status.HTTP_401_UNAUTHORIZED, + detail="Bearer token required", + headers={"WWW-Authenticate": 'Bearer realm="messenger"'}, + ) + + try: + AuthService(db).delete_session(token) + except InvalidSessionError: + raise HTTPException( + status_code=status.HTTP_401_UNAUTHORIZED, + detail="Invalid or expired session", + headers={"WWW-Authenticate": 'Bearer realm="messenger"'}, + ) from None diff --git a/app/api/deps.py b/app/api/deps.py new file mode 100644 index 0000000..a087f9c --- /dev/null +++ b/app/api/deps.py @@ -0,0 +1,46 @@ +from typing import Generator + +from fastapi import Depends, Header, HTTPException +from sqlalchemy.orm import Session + +from app.db.session import SessionLocal +from app.db.models import User +from app.services.auth_service import AuthService, InvalidSessionError + + +def get_db() -> Generator[Session, None, None]: + db = SessionLocal() + try: + yield db + finally: + db.close() + + +def get_current_user( + authorization: str | None = Header(default=None), + db: Session = Depends(get_db), +) -> User: + if not authorization or not authorization.startswith("Bearer "): + raise HTTPException( + status_code=401, + detail="Bearer token required", + headers={"WWW-Authenticate": 'Bearer realm="messenger"'}, + ) + + token = authorization[7:].strip() + + if not token: + raise HTTPException( + status_code=401, + detail="Bearer token required", + headers={"WWW-Authenticate": 'Bearer realm="messenger"'}, + ) + + try: + return AuthService(db).authenticate(token) + except InvalidSessionError: + raise HTTPException( + status_code=401, + detail="Invalid or expired session", + headers={"WWW-Authenticate": 'Bearer realm="messenger"'}, + ) from None diff --git a/app/api/users.py b/app/api/users.py new file mode 100644 index 0000000..67adc7c --- /dev/null +++ b/app/api/users.py @@ -0,0 +1,55 @@ +from fastapi import APIRouter, Depends, HTTPException, status +from sqlalchemy.orm import Session + +from app.api.deps import get_db, get_current_user +from app.db.models import User as UserModel +from app.models import CreateUser, User +from app.services.user_service import ( + UserService, + UsernameAlreadyExistsError, +) + + +router = APIRouter(prefix="/api/v1/users", tags=["Users"]) + + +def user_to_response(user: UserModel) -> User: + return User( + id=str(user.id), + username=user.username, + display_name=user.display_name, + created_at=user.created_at, + ) + + +@router.post("", response_model=User, status_code=status.HTTP_201_CREATED) +def register_user( + body: CreateUser, + db: Session = Depends(get_db), +): + try: + user = UserService(db).register( + username=body.username, + display_name=body.display_name, + password=body.password, + ) + return user_to_response(user) + + except UsernameAlreadyExistsError: + raise HTTPException( + status_code=status.HTTP_409_CONFLICT, + detail="Username already exists", + ) from None + + except ValueError as exc: + raise HTTPException( + status_code=status.HTTP_400_BAD_REQUEST, + detail=str(exc), + ) from None + + +@router.get("/me", response_model=User) +def get_me( + current_user: UserModel = Depends(get_current_user), +): + return user_to_response(current_user) -- 2.54.0 From e0e654dcf5ab4c39ea87ff42033108f7d32e74e6 Mon Sep 17 00:00:00 2001 From: sinveria Date: Wed, 4 Nov 2026 17:54:02 +0300 Subject: [PATCH 10/14] refactor: connect FastAPI to PostgreSQL services --- app/main.py | 161 +++++++++++++++++----------------------------------- 1 file changed, 52 insertions(+), 109 deletions(-) diff --git a/app/main.py b/app/main.py index 2e74b3b..25bfd4f 100644 --- a/app/main.py +++ b/app/main.py @@ -1,41 +1,56 @@ import logging import uuid from contextlib import asynccontextmanager -from typing import Optional -from fastapi import Depends, FastAPI, Header, HTTPException, Request +from fastapi import FastAPI, HTTPException, Request from fastapi.exceptions import RequestValidationError from fastapi.responses import JSONResponse +from sqlalchemy import text +from sqlalchemy.exc import SQLAlchemyError -from .models import Chat, CreateChat, CreateMessage, CreateUser, User -from .store import InMemoryStore +from app.api.auth import router as auth_router +from app.api.users import router as users_router +from app.core.config import settings +from app.db.session import engine logging.basicConfig( level=logging.INFO, format="%(asctime)s %(levelname)s %(name)s %(message)s", ) + logger = logging.getLogger(__name__) -store = InMemoryStore() @asynccontextmanager async def lifespan(app: FastAPI): logger.info("Application startup") yield + engine.dispose() logger.info("Application shutdown") -app = FastAPI(lifespan=lifespan) +app = FastAPI( + title="Messenger API", + version="1.2.0", + lifespan=lifespan, +) + +app.include_router(users_router) +app.include_router(auth_router) @app.middleware("http") async def add_request_id(request: Request, call_next): request_id = str(uuid.uuid4()) request.state.request_id = request_id + try: response = await call_next(request) except Exception: - logger.exception("Unhandled request error; request_id=%s", request_id) + logger.exception( + "Unhandled request error; request_id=%s", + request_id, + ) response = JSONResponse( status_code=500, content={ @@ -46,6 +61,7 @@ async def add_request_id(request: Request, call_next): } }, ) + response.headers["X-Request-Id"] = request_id return response @@ -53,6 +69,7 @@ async def add_request_id(request: Request, call_next): @app.exception_handler(HTTPException) async def http_exception_handler(request: Request, exc: HTTPException): request_id = request.state.request_id + error_code_map = { 400: "invalid_request", 401: "unauthorized", @@ -64,22 +81,37 @@ async def http_exception_handler(request: Request, exc: HTTPException): 500: "internal_error", 503: "unavailable", } + + headers = dict(exc.headers or {}) + headers["X-Request-Id"] = request_id + return JSONResponse( status_code=exc.status_code, content={ "error": { - "code": error_code_map.get(exc.status_code, "internal_error"), - "message": exc.detail if isinstance(exc.detail, str) else "Request failed", + "code": error_code_map.get( + exc.status_code, + "internal_error", + ), + "message": ( + exc.detail + if isinstance(exc.detail, str) + else "Request failed" + ), "request_id": request_id, } }, - headers={"X-Request-Id": request_id}, + headers=headers, ) @app.exception_handler(RequestValidationError) -async def validation_exception_handler(request: Request, exc: RequestValidationError): +async def validation_exception_handler( + request: Request, + exc: RequestValidationError, +): request_id = request.state.request_id + return JSONResponse( status_code=400, content={ @@ -93,24 +125,6 @@ async def validation_exception_handler(request: Request, exc: RequestValidationE ) -def get_current_user(x_user_id: Optional[str] = Header(default=None)) -> User: - if not x_user_id: - raise HTTPException(status_code=401, detail="Unauthorized") - user = store.get_user(x_user_id) - if user is None: - raise HTTPException(status_code=401, detail="Unauthorized") - return user - - -def validate_chat_uuid(chat_id: str) -> None: - try: - parsed = uuid.UUID(chat_id) - if str(parsed) != chat_id.lower(): - raise ValueError("non-canonical UUID") - except (ValueError, TypeError, AttributeError): - raise HTTPException(status_code=400, detail="Invalid chat UUID") from None - - @app.get("/health/live") def liveness(): return {"status": "ok"} @@ -118,85 +132,14 @@ def liveness(): @app.get("/health/ready") def readiness(): - return {"status": "ok"} - - -@app.post("/api/v1/users", status_code=201) -def register_user(body: CreateUser): try: - return store.create_user(body.username, body.display_name) - except ValueError as exc: - if str(exc) == "conflict": - raise HTTPException(status_code=409, detail="Username already exists") from None - raise HTTPException(status_code=400, detail="Invalid request") from None + with engine.connect() as connection: + connection.execute(text("SELECT 1")) + return {"status": "ok"} - -@app.get("/api/v1/users/me") -def current_user(user: User = Depends(get_current_user)): - return user - - -@app.post("/api/v1/chats", status_code=201) -def create_chat(body: CreateChat, user: User = Depends(get_current_user)): - try: - return store.create_chat(body.title, body.member_ids, user.id) - except ValueError: - raise HTTPException(status_code=400, detail="Invalid members or missing creator") from None - - -@app.get("/api/v1/chats") -def list_chats( - limit: int = 50, - cursor: Optional[str] = None, - user: User = Depends(get_current_user), -): - if limit < 1 or limit > 100: - raise HTTPException(status_code=400, detail="Limit out of range") - try: - items, next_cursor = store.list_chats(user.id, limit, cursor) - return {"items": items, "next_cursor": next_cursor} - except ValueError: - raise HTTPException(status_code=400, detail="Invalid cursor") from None - - -@app.get("/api/v1/chats/{chat_id}") -def get_chat(chat_id: str, user: User = Depends(get_current_user)): - validate_chat_uuid(chat_id) - chat = store.get_chat(chat_id, user.id) - if chat is None: - raise HTTPException(status_code=404, detail="Chat not found or access denied") - return chat - - -@app.post("/api/v1/chats/{chat_id}/messages", status_code=201) -def create_message( - chat_id: str, - body: CreateMessage, - user: User = Depends(get_current_user), -): - validate_chat_uuid(chat_id) - try: - return store.create_message(chat_id, user.id, body.text) - except ValueError as exc: - if str(exc) == "not_found": - raise HTTPException(status_code=404, detail="Chat not found or access denied") from None - raise HTTPException(status_code=400, detail="Invalid request") from None - - -@app.get("/api/v1/chats/{chat_id}/messages") -def list_messages( - chat_id: str, - limit: int = 50, - cursor: Optional[str] = None, - user: User = Depends(get_current_user), -): - validate_chat_uuid(chat_id) - if limit < 1 or limit > 100: - raise HTTPException(status_code=400, detail="Limit out of range") - try: - items, next_cursor = store.list_messages(chat_id, user.id, limit, cursor) - return {"items": items, "next_cursor": next_cursor} - except ValueError as exc: - if str(exc) == "not_found": - raise HTTPException(status_code=404, detail="Chat not found or access denied") from None - raise HTTPException(status_code=400, detail="Invalid cursor") from None \ No newline at end of file + except SQLAlchemyError: + logger.exception("PostgreSQL readiness check failed") + raise HTTPException( + status_code=503, + detail="Database unavailable", + ) from None -- 2.54.0 From 527f0e8d74262cccfeac63c60c821632c935a2ca Mon Sep 17 00:00:00 2001 From: sinveria Date: Wed, 4 Nov 2026 18:44:55 +0300 Subject: [PATCH 11/14] feat: implement chat messaging and Redis cache --- app/api/auth.py | 14 +- app/api/chats.py | 90 +++++++++ app/api/deps.py | 40 ++-- app/api/messages.py | 102 ++++++++++ app/core/config.py | 1 + app/main.py | 4 + app/services/chat_service.py | 94 ++++++++++ app/services/message_service.py | 322 ++++++++++++++++++++++++++++++++ 8 files changed, 643 insertions(+), 24 deletions(-) create mode 100644 app/api/chats.py create mode 100644 app/api/messages.py create mode 100644 app/services/chat_service.py create mode 100644 app/services/message_service.py diff --git a/app/api/auth.py b/app/api/auth.py index 3141b3b..bea835c 100644 --- a/app/api/auth.py +++ b/app/api/auth.py @@ -1,3 +1,4 @@ +from datetime import timezone from fastapi import APIRouter, Depends, Header, HTTPException, status from fastapi.security import HTTPBasic, HTTPBasicCredentials from sqlalchemy.orm import Session @@ -16,6 +17,7 @@ router = APIRouter(prefix="/api/v1/auth", tags=["Authentication"]) basic_security = HTTPBasic(auto_error=False) + @router.post("/sessions", status_code=status.HTTP_201_CREATED) def create_session( credentials: HTTPBasicCredentials = Depends(basic_security), @@ -36,10 +38,19 @@ def create_session( password=credentials.password, ) + expires_at = result["expires_at"] + + if expires_at.tzinfo is None: + expires_at = expires_at.replace(tzinfo=timezone.utc) + else: + expires_at = expires_at.astimezone(timezone.utc) + return { "token": result["token"], "token_type": result["token_type"], - "expires_at": result["expires_at"], + "expires_at": expires_at.isoformat( + timespec="microseconds" + ).replace("+00:00", "Z"), "user": user_to_response(result["user"]), } @@ -53,6 +64,7 @@ def create_session( ) from None + @router.delete("/sessions/current", status_code=status.HTTP_204_NO_CONTENT) def delete_current_session( authorization: str | None = Header(default=None), diff --git a/app/api/chats.py b/app/api/chats.py new file mode 100644 index 0000000..40c4626 --- /dev/null +++ b/app/api/chats.py @@ -0,0 +1,90 @@ +import uuid + +from fastapi import APIRouter, Depends, HTTPException, Query, status +from sqlalchemy.orm import Session + +from app.api.deps import get_db, get_current_user +from app.db.models import User as UserModel +from app.models import Chat as ChatResponse, CreateChat +from app.services.chat_service import ( + ChatService, + ChatNotFoundError, + InvalidChatDataError, +) + + +router = APIRouter(prefix="/api/v1/chats", tags=["Chats"]) + + +def chat_to_response(chat) -> ChatResponse: + return ChatResponse( + id=str(chat.id), + title=chat.title, + member_ids=[str(member.user_id) for member in chat.members], + created_at=chat.created_at, + ) + + +@router.post("", response_model=ChatResponse, status_code=status.HTTP_201_CREATED) +def create_chat( + body: CreateChat, + db: Session = Depends(get_db), + user: UserModel = Depends(get_current_user), +): + try: + chat = ChatService(db).create_chat( + title=body.title, + member_ids=body.member_ids, + creator_id=user.id, + ) + return chat_to_response(chat) + + except InvalidChatDataError as exc: + raise HTTPException( + status_code=400, + detail=str(exc), + ) from None + + +@router.get("") +def list_chats( + limit: int = Query(default=50, ge=1, le=100), + cursor: str | None = None, + db: Session = Depends(get_db), + user: UserModel = Depends(get_current_user), +): + if cursor is not None: + raise HTTPException( + status_code=400, + detail="Chat cursor pagination is not implemented yet", + ) + + chats = ChatService(db).list_chats(user.id) + chats = chats[:limit] + + return { + "items": [chat_to_response(chat) for chat in chats], + "next_cursor": None, + } + + +@router.get("/{chat_id}", response_model=ChatResponse) +def get_chat( + chat_id: str, + db: Session = Depends(get_db), + user: UserModel = Depends(get_current_user), +): + try: + parsed_id = uuid.UUID(chat_id) + except ValueError: + raise HTTPException(status_code=400, detail="Invalid chat UUID") from None + + try: + chat = ChatService(db).get_chat(parsed_id, user.id) + return chat_to_response(chat) + + except ChatNotFoundError: + raise HTTPException( + status_code=404, + detail="Chat not found", + ) from None diff --git a/app/api/deps.py b/app/api/deps.py index a087f9c..6c69586 100644 --- a/app/api/deps.py +++ b/app/api/deps.py @@ -1,14 +1,15 @@ -from typing import Generator - -from fastapi import Depends, Header, HTTPException +from fastapi import Depends, HTTPException, status +from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer from sqlalchemy.orm import Session from app.db.session import SessionLocal -from app.db.models import User from app.services.auth_service import AuthService, InvalidSessionError -def get_db() -> Generator[Session, None, None]: +bearer_scheme = HTTPBearer(auto_error=False) + + +def get_db(): db = SessionLocal() try: yield db @@ -17,30 +18,23 @@ def get_db() -> Generator[Session, None, None]: def get_current_user( - authorization: str | None = Header(default=None), + credentials: HTTPAuthorizationCredentials | None = Depends(bearer_scheme), db: Session = Depends(get_db), -) -> User: - if not authorization or not authorization.startswith("Bearer "): +): + if credentials is None or credentials.scheme.lower() != "bearer": raise HTTPException( - status_code=401, + status_code=status.HTTP_401_UNAUTHORIZED, detail="Bearer token required", - headers={"WWW-Authenticate": 'Bearer realm="messenger"'}, - ) - - token = authorization[7:].strip() - - if not token: - raise HTTPException( - status_code=401, - detail="Bearer token required", - headers={"WWW-Authenticate": 'Bearer realm="messenger"'}, + headers={"WWW-Authenticate": "Bearer"}, ) try: - return AuthService(db).authenticate(token) + user = AuthService(db).authenticate(credentials.credentials) + return user + except InvalidSessionError: raise HTTPException( - status_code=401, - detail="Invalid or expired session", - headers={"WWW-Authenticate": 'Bearer realm="messenger"'}, + status_code=status.HTTP_401_UNAUTHORIZED, + detail="Invalid or expired token", + headers={"WWW-Authenticate": "Bearer"}, ) from None diff --git a/app/api/messages.py b/app/api/messages.py new file mode 100644 index 0000000..9b81a92 --- /dev/null +++ b/app/api/messages.py @@ -0,0 +1,102 @@ +import uuid + +from fastapi import APIRouter, Depends, HTTPException, Query, status +from sqlalchemy.orm import Session + +from app.api.deps import get_db, get_current_user +from app.db.models import User as UserModel +from app.models import CreateMessage, Message as MessageResponse +from app.services.message_service import ( + MessageService, + MessageNotFoundError, + InvalidMessageDataError, +) + + +router = APIRouter(prefix="/api/v1/chats/{chat_id}/messages", tags=["Messages"]) + + +def message_to_response(message) -> MessageResponse: + return MessageResponse( + id=str(message.id), + chat_id=str(message.chat_id), + sender_id=str(message.sender_id), + text=message.text, + created_at=message.created_at, + ) + + +def parse_chat_id(chat_id: str) -> uuid.UUID: + try: + return uuid.UUID(chat_id) + except ValueError: + raise HTTPException( + status_code=400, + detail="Invalid chat UUID", + ) from None + + +@router.post("", response_model=MessageResponse, status_code=status.HTTP_201_CREATED) +def create_message( + chat_id: str, + body: CreateMessage, + db: Session = Depends(get_db), + user: UserModel = Depends(get_current_user), +): + parsed_id = parse_chat_id(chat_id) + + try: + message = MessageService(db).create_message( + chat_id=parsed_id, + sender_id=user.id, + text=body.text, + ) + return message_to_response(message) + + except MessageNotFoundError: + raise HTTPException( + status_code=404, + detail="Chat not found", + ) from None + + except InvalidMessageDataError as exc: + raise HTTPException( + status_code=400, + detail=str(exc), + ) from None + + +@router.get("") +def list_messages( + chat_id: str, + limit: int = Query(default=50, ge=1, le=100), + cursor: str | None = None, + db: Session = Depends(get_db), + user: UserModel = Depends(get_current_user), +): + parsed_id = parse_chat_id(chat_id) + + try: + messages, next_cursor = MessageService(db).get_history( + chat_id=parsed_id, + user_id=user.id, + limit=limit, + cursor=cursor, + ) + + return { + "items": [message_to_response(item) for item in messages], + "next_cursor": next_cursor, + } + + except MessageNotFoundError: + raise HTTPException( + status_code=404, + detail="Chat not found", + ) from None + + except InvalidMessageDataError as exc: + raise HTTPException( + status_code=400, + detail=str(exc), + ) from None diff --git a/app/core/config.py b/app/core/config.py index b0b5574..07f6d8e 100644 --- a/app/core/config.py +++ b/app/core/config.py @@ -11,6 +11,7 @@ class Settings(BaseSettings): session_ttl_seconds: int = 3600 cache_url: str = "redis://localhost:6379/0" + message_cache_ttl_seconds: int = 60 model_config = SettingsConfigDict( env_file=".env", diff --git a/app/main.py b/app/main.py index 25bfd4f..88ec588 100644 --- a/app/main.py +++ b/app/main.py @@ -10,6 +10,8 @@ from sqlalchemy.exc import SQLAlchemyError from app.api.auth import router as auth_router from app.api.users import router as users_router +from app.api.chats import router as chats_router +from app.api.messages import router as messages_router from app.core.config import settings from app.db.session import engine @@ -37,6 +39,8 @@ app = FastAPI( app.include_router(users_router) app.include_router(auth_router) +app.include_router(chats_router) +app.include_router(messages_router) @app.middleware("http") diff --git a/app/services/chat_service.py b/app/services/chat_service.py new file mode 100644 index 0000000..10ff565 --- /dev/null +++ b/app/services/chat_service.py @@ -0,0 +1,94 @@ +import uuid + +from sqlalchemy.exc import IntegrityError +from sqlalchemy.orm import Session + +from app.db.models import Chat +from app.repositories.chat_repository import ChatRepository +from app.repositories.user_repository import UserRepository + + +class ChatNotFoundError(Exception): + pass + + +class ChatAccessError(Exception): + pass + + +class InvalidChatDataError(Exception): + pass + + +class ChatService: + def __init__(self, db: Session): + self.db = db + self.chats = ChatRepository(db) + self.users = UserRepository(db) + + def create_chat( + self, + title: str, + member_ids: list[str], + creator_id: uuid.UUID, + ) -> Chat: + title = title.strip() + + if not title or len(title) > 100: + raise InvalidChatDataError("Invalid chat title") + + if not member_ids or len(member_ids) > 100: + raise InvalidChatDataError("Invalid members") + + try: + parsed_ids = [uuid.UUID(str(value)) for value in member_ids] + except (ValueError, TypeError, AttributeError): + raise InvalidChatDataError("Invalid member UUID") from None + + if len(parsed_ids) != len(set(parsed_ids)): + raise InvalidChatDataError("Duplicate members") + + if creator_id not in parsed_ids: + raise InvalidChatDataError("Creator must be a member") + + for user_id in parsed_ids: + if self.users.get_by_id(user_id) is None: + raise InvalidChatDataError("Unknown member") + + try: + chat = self.chats.create( + title=title, + member_ids=parsed_ids, + ) + self.db.commit() + self.db.refresh(chat) + return chat + + except IntegrityError as exc: + self.db.rollback() + raise InvalidChatDataError("Unable to create chat") from exc + + except Exception: + self.db.rollback() + raise + + def get_chat(self, chat_id: uuid.UUID, user_id: uuid.UUID) -> Chat: + chat = self.chats.get_by_id(chat_id) + + if chat is None: + raise ChatNotFoundError() + + if not self.chats.is_member(chat_id, user_id): + raise ChatNotFoundError() + + return chat + + def list_chats(self, user_id: uuid.UUID) -> list[Chat]: + return self.chats.get_by_user(user_id) + + def check_membership( + self, + chat_id: uuid.UUID, + user_id: uuid.UUID, + ) -> bool: + return self.chats.is_member(chat_id, user_id) diff --git a/app/services/message_service.py b/app/services/message_service.py new file mode 100644 index 0000000..80b7ff6 --- /dev/null +++ b/app/services/message_service.py @@ -0,0 +1,322 @@ +import base64 +import hashlib +import json +import time +import uuid +from datetime import datetime +from types import SimpleNamespace + +from redis import Redis +from redis.exceptions import RedisError +from sqlalchemy.orm import Session + +from app.core.config import settings +from app.db.models import Message +from app.repositories.chat_repository import ChatRepository +from app.repositories.message_repository import MessageRepository + + +class MessageNotFoundError(Exception): + pass + + +class MessageAccessError(Exception): + pass + + +class InvalidMessageDataError(Exception): + pass + + +class MessageService: + def __init__(self, db: Session): + self.db = db + self.messages = MessageRepository(db) + self.chats = ChatRepository(db) + + self.redis = Redis.from_url( + settings.cache_url, + decode_responses=True, + socket_connect_timeout=2, + socket_timeout=2, + ) + + @staticmethod + def encode_cursor(message: Message) -> str: + payload = { + "created_at": message.created_at.isoformat(), + "id": str(message.id), + } + + raw = json.dumps(payload).encode("utf-8") + + return ( + base64.urlsafe_b64encode(raw) + .decode("ascii") + .rstrip("=") + ) + + @staticmethod + def decode_cursor(cursor: str | None): + if not cursor: + return None, None + + try: + padded = cursor + "=" * (-len(cursor) % 4) + raw = base64.urlsafe_b64decode(padded.encode("ascii")) + payload = json.loads(raw.decode("utf-8")) + + created_at = datetime.fromisoformat(payload["created_at"]) + message_id = uuid.UUID(payload["id"]) + + if created_at.tzinfo is None: + raise ValueError("Cursor timestamp must include timezone") + + return created_at, message_id + + except (ValueError, TypeError, KeyError, UnicodeError): + raise InvalidMessageDataError("Invalid cursor") from None + + def _version_key(self, chat_id: uuid.UUID) -> str: + return f"messages:version:{chat_id}" + + def _cache_key( + self, + chat_id: uuid.UUID, + version: int, + limit: int, + cursor: str | None, + ) -> str: + cursor_hash = hashlib.sha256( + (cursor or "first-page").encode("utf-8") + ).hexdigest()[:16] + + return ( + f"messages:{chat_id}:v{version}:" + f"limit:{limit}:cursor:{cursor_hash}" + ) + + def _get_version(self, chat_id: uuid.UUID) -> int: + try: + value = self.redis.get(self._version_key(chat_id)) + return int(value or 0) + except (RedisError, ValueError): + return 0 + + def _bump_version(self, chat_id: uuid.UUID) -> None: + try: + self.redis.incr(self._version_key(chat_id)) + except RedisError: + pass + + @staticmethod + def _serialize(messages, next_cursor): + return json.dumps({ + "items": [ + { + "id": str(message.id), + "chat_id": str(message.chat_id), + "sender_id": str(message.sender_id), + "text": message.text, + "created_at": message.created_at.isoformat(), + } + for message in messages + ], + "next_cursor": next_cursor, + }) + + @staticmethod + def _deserialize(payload: str): + data = json.loads(payload) + + messages = [ + SimpleNamespace( + id=uuid.UUID(item["id"]), + chat_id=uuid.UUID(item["chat_id"]), + sender_id=uuid.UUID(item["sender_id"]), + text=item["text"], + created_at=datetime.fromisoformat(item["created_at"]), + ) + for item in data["items"] + ] + + return messages, data["next_cursor"] + + def _read_cache(self, key: str): + try: + payload = self.redis.get(key) + + if payload is None: + return None + + return self._deserialize(payload) + + except (RedisError, ValueError, TypeError, KeyError): + return None + + def _load_from_database( + self, + chat_id, + limit, + cursor_created_at, + cursor_id, + ): + rows = self.messages.get_history( + chat_id=chat_id, + limit=limit + 1, + cursor_created_at=cursor_created_at, + cursor_id=cursor_id, + ) + + has_more = len(rows) > limit + items = rows[:limit] + + next_cursor = ( + self.encode_cursor(items[-1]) + if has_more and items + else None + ) + + return items, next_cursor + + + def create_message( + self, + chat_id: uuid.UUID, + sender_id: uuid.UUID, + text: str, + ) -> Message: + text = text.strip() + + if not text or len(text) > 4000: + raise InvalidMessageDataError("Invalid message text") + + if not self.chats.is_member(chat_id, sender_id): + raise MessageNotFoundError() + + try: + message = self.messages.create( + chat_id=chat_id, + sender_id=sender_id, + text=text, + ) + + self.db.commit() + self.db.refresh(message) + + self._bump_version(chat_id) + + return message + + except Exception: + self.db.rollback() + raise + + + def get_history( + self, + chat_id: uuid.UUID, + user_id: uuid.UUID, + limit: int = 50, + cursor: str | None = None, + ): + if not 1 <= limit <= 100: + raise InvalidMessageDataError( + "Limit must be between 1 and 100" + ) + + if not self.chats.is_member(chat_id, user_id): + raise MessageNotFoundError() + + cursor_created_at, cursor_id = self.decode_cursor(cursor) + + version = self._get_version(chat_id) + + cache_key = self._cache_key( + chat_id, + version, + limit, + cursor, + ) + + cached = self._read_cache(cache_key) + + if cached is not None: + return cached + + lock_key = f"lock:{cache_key}" + lock_token = str(uuid.uuid4()) + + try: + acquired = self.redis.set( + lock_key, + lock_token, + nx=True, + ex=10, + ) + except RedisError: + return self._load_from_database( + chat_id, + limit, + cursor_created_at, + cursor_id, + ) + + if not acquired: + for _ in range(10): + time.sleep(0.05) + + cached = self._read_cache(cache_key) + + if cached is not None: + return cached + + return self._load_from_database( + chat_id, + limit, + cursor_created_at, + cursor_id, + ) + + try: + cached = self._read_cache(cache_key) + + if cached is not None: + return cached + + items, next_cursor = self._load_from_database( + chat_id, + limit, + cursor_created_at, + cursor_id, + ) + + if self._get_version(chat_id) == version: + try: + self.redis.setex( + cache_key, + settings.message_cache_ttl_seconds, + self._serialize(items, next_cursor), + ) + except RedisError: + pass + + return items, next_cursor + + finally: + try: + self.redis.eval( + """ + if redis.call('get', KEYS[1]) == ARGV[1] + then + return redis.call('del', KEYS[1]) + else + return 0 + end + """, + 1, + lock_key, + lock_token, + ) + except RedisError: + pass -- 2.54.0 From 2410960d3c93af08d9d8d14c88e2a304541ef302 Mon Sep 17 00:00:00 2001 From: sinveria Date: Wed, 4 Nov 2026 19:04:20 +0300 Subject: [PATCH 12/14] build: run API with PostgreSQL and Redis in Docker Compose --- Dockerfile | 29 +++++++++++++++++++++++++++++ compose.yaml | 31 ++++++++++++++++++++++++++++++- 2 files changed, 59 insertions(+), 1 deletion(-) create mode 100644 Dockerfile diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000..4d75023 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,29 @@ +FROM python:3.11.9-slim-bookworm + +ENV PYTHONDONTWRITEBYTECODE=1 \ + PYTHONUNBUFFERED=1 \ + PIP_NO_CACHE_DIR=1 + +WORKDIR /app + +RUN groupadd --system app && \ + useradd --system --gid app --home-dir /app app + +COPY requirements.txt . + +RUN pip install --no-cache-dir -r requirements.txt + +COPY app ./app +COPY migrations ./migrations +COPY alembic.ini . + +RUN chown -R app:app /app + +USER app + +EXPOSE 8080 + +HEALTHCHECK --interval=15s --timeout=5s --start-period=30s --retries=5 \ + CMD python -c "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=3)" + +CMD ["sh", "-c", "alembic upgrade head && exec uvicorn app.main:app --host 0.0.0.0 --port 8080"] diff --git a/compose.yaml b/compose.yaml index 0bbff2e..6a6f9bb 100644 --- a/compose.yaml +++ b/compose.yaml @@ -35,6 +35,35 @@ services: timeout: 3s retries: 10 + api: + build: + context: . + dockerfile: Dockerfile + container_name: mtusi-lab2-api + restart: unless-stopped + environment: + DATABASE_URL: postgresql+psycopg://${POSTGRES_USER}:${POSTGRES_PASSWORD}@postgres:5432/${POSTGRES_DB} + CACHE_URL: redis://redis:6379/0 + SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600} + MESSAGE_CACHE_TTL_SECONDS: ${MESSAGE_CACHE_TTL_SECONDS:-60} + ports: + - "8080:8080" + depends_on: + postgres: + condition: service_healthy + redis: + condition: service_healthy + healthcheck: + test: + - CMD + - python + - -c + - "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=3)" + interval: 10s + timeout: 5s + retries: 5 + start_period: 30s + volumes: lab2_postgres_data: - lab2_redis_data: \ No newline at end of file + lab2_redis_data: -- 2.54.0 From b727fa922ad49f6a2e3f7bfdc29d9f502cdb9ee3 Mon Sep 17 00:00:00 2001 From: sinveria Date: Wed, 4 Nov 2026 20:04:25 +0300 Subject: [PATCH 13/14] Complete lab 2 PostgreSQL Redis implementation --- Makefile | 5 +- REPORT.md | 287 ++++++++++++++++++++++-- app/services/auth_service.py | 63 ++++-- app/services/message_service.py | 86 +++++-- evidence/cache-research.json | 11 + evidence/cache-stampede.json | 12 + evidence/check-contract.txt | Bin 0 -> 180 bytes evidence/docker-compose-ps.txt | Bin 0 -> 1250 bytes evidence/grade5-checks.txt | Bin 0 -> 1964 bytes evidence/load-10s.json | 17 ++ evidence/openapi-validation.txt | Bin 0 -> 154 bytes evidence/persistence-windows.txt | Bin 0 -> 190 bytes evidence/smoke.txt | Bin 0 -> 174 bytes scripts/explain_history.sql | 13 ++ scripts/restart.ps1 | 30 +++ tests/cache_research.py | 64 ++++++ tests/grade5_checks.py | 374 +++++++++++++++++++++++++++++++ tests/persistence_windows.py | 47 ++++ 18 files changed, 942 insertions(+), 67 deletions(-) create mode 100644 evidence/cache-research.json create mode 100644 evidence/cache-stampede.json create mode 100644 evidence/check-contract.txt create mode 100644 evidence/docker-compose-ps.txt create mode 100644 evidence/grade5-checks.txt create mode 100644 evidence/load-10s.json create mode 100644 evidence/openapi-validation.txt create mode 100644 evidence/persistence-windows.txt create mode 100644 evidence/smoke.txt create mode 100644 scripts/explain_history.sql create mode 100644 scripts/restart.ps1 create mode 100644 tests/cache_research.py create mode 100644 tests/grade5_checks.py create mode 100644 tests/persistence_windows.py diff --git a/Makefile b/Makefile index 9ecb223..a6d54c7 100644 --- a/Makefile +++ b/Makefile @@ -4,7 +4,7 @@ CA_FILE ?= ACTION_SCRIPT ?= TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",) -.PHONY: help check validate test load test-persistence +.PHONY: help check validate test load test-persistence test-persistence-windows help: @echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes" @@ -24,3 +24,6 @@ load: test-persistence: @test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable restart hook"; exit 2) $(PYTHON) tests/resilience.py --mode persistence --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS) + +test-persistence-windows: + $(PYTHON) tests/persistence_windows.py --base-url "$(BASE_URL)" $(TLS_ARGS) diff --git a/REPORT.md b/REPORT.md index e42f2b0..e2bc697 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,276 @@ -# Отчёт — лабораторная 2 +# Отчёт — лабораторная работа № 2 +## PostgreSQL, сессии и Redis/Valkey -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO -- Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +- Автор: **Перевалова В.А.** +- Группа: **БПИ2302** +- Целевая оценка: **5** +- Исследовательский трек: **1 — согласованность кэша** +- Репозиторий: `mtusi2026lab2` +- Ветка: `solution/lab2-implementation` +- Commit: **указать итоговый hash после публикации** +- Использованные технологии: Python 3.11, FastAPI, SQLAlchemy 2, Alembic, PostgreSQL 16.6, Redis 7.4.2, Docker Compose. -## Запуск из чистого clone +## 1. Назначение и архитектура -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +Лабораторная переносит состояние мессенджера из памяти одного процесса в PostgreSQL и добавляет серверные сессии. Redis используется как ускоряющий слой: хранит краткоживущие записи сессий и кэш страниц истории сообщений. -## Архитектура и решения +```text +Клиент + │ HTTP / JSON + ▼ +FastAPI (контейнер api, порт 8080) + ├── SQLAlchemy + Alembic ──► PostgreSQL 16.6 + │ └── named volume lab2_postgres_data + └── Redis client ──────────► Redis 7.4.2 + └── named volume lab2_redis_data +``` -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +**Источник истины — PostgreSQL.** Redis не является единственным местом хранения пользователей, сообщений или сессий. Если Redis недоступен, операции чтения истории выполняются напрямую из PostgreSQL, а аутентификация проверяет запись сессии в PostgreSQL. Кэш Redis ускоряет повторные чтения, но его потеря не должна приводить к потере подтверждённых данных. -## Доказательства критериев +### 1.1. Основные сущности -| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | -| --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | +| Сущность | Назначение и ограничения | +|---|---| +| `User` (`users`) | Пользователь, уникальный `username`, отображаемое имя и хэш пароля | +| `Chat` (`chats`) | Чат с UUID и названием | +| `ChatMember` (`chat_members`) | Связь пользователя с чатом; составной первичный ключ `(chat_id, user_id)` не допускает повторного членства | +| `Message` (`messages`) | Сообщение, внешний ключ на чат и отправителя, текст и время создания | +| `Session` (`sessions`) | Хэш непрозрачного токена, пользователь и время истечения; уникальный индекс по `token_hash` | -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +Пароль не хранится в открытом виде: используется Argon2id. Клиент получает случайный Bearer-токен; в PostgreSQL сохраняется SHA-256-хэш токена. Поэтому утечка таблицы сессий не раскрывает сами токены. -## Эксперименты и отказы +### 1.2. Транзакции и индексы -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +- Регистрация выполняет проверку имени и обработку конфликта уникальности на уровне БД. +- Создание чата и добавление участников выполняются одной транзакцией. +- Создание сообщения завершается `COMMIT` до ответа клиенту. +- История запрашивается keyset-пагинацией по паре `(created_at, id)`, а не загрузкой всей истории с последующим смещением. +- Индекс `ix_messages_chat_created_id (chat_id, created_at, id)` соответствует фильтру по чату и сортировке истории. +- SQLAlchemy использует параметризованные выражения ORM; пул соединений ограничен `pool_size=5`, `max_overflow=10`, `pool_timeout=30`, включён `pool_pre_ping`. -| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | -| --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +## 2. Аутентификация и сессии -## Ограничения и следующие шаги +1. Регистрация: `POST /api/v1/users`, пароль обязателен. +2. Вход: `POST /api/v1/auth/sessions` с HTTP Basic. Сервер проверяет Argon2id-хэш, создаёт случайный токен и сохраняет его хэш и `expires_at` в PostgreSQL. +3. Защищённые методы используют `Authorization: Bearer `. +4. При каждом запросе сервер проверяет сессию в PostgreSQL. Redis-копия с TTL используется как кэш, но не заменяет проверку срока действия и отзыва в БД. +5. Выход: `DELETE /api/v1/auth/sessions/current`; запись удаляется из PostgreSQL и Redis. +6. `X-User-Id` не используется для установления личности клиента. -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +Redis недоступен — приложение продолжает проверять сессию по PostgreSQL. PostgreSQL недоступен — защищённый запрос не должен считаться аутентифицированным. + +## 3. Кэш истории и исследовательский трек 1 + +### 3.1. Гипотеза + +Кэширование страниц истории сообщений в Redis позволяет повторно использовать ранее полученные данные и уменьшать количество обращений к PostgreSQL. Версионирование кэша обеспечивает актуальность истории после добавления новых сообщений. Распределённая блокировка `SET NX EX` предназначена для ограничения одновременного заполнения одного и того же кэш-ключа. + +### 3.2. Реализация + +- Ключ страницы истории учитывает идентификатор чата, версию истории, размер страницы и курсор. +- При добавлении сообщения версия кэша чата увеличивается. +- Для защиты от одновременного заполнения кэша используется Redis-блокировка `SET NX EX`. +- При недоступности Redis чтение истории может выполняться непосредственно из PostgreSQL. +- PostgreSQL остаётся основным источником достоверных данных. +- Время хранения кэшированных страниц ограничивается TTL. + +### 3.3. Методика исследования + +Исследование выполнялось на локальном стенде Docker Compose. + +Были проведены следующие проверки: + +1. Первое чтение истории тестового чата. +2. 30 последовательных повторных чтений. +3. Добавление нового сообщения и проверка его немедленной доступности через API (read-after-write). +4. Перезапуск Redis командой `docker compose restart redis`. +5. Повторение чтения истории после перезапуска Redis. + +Дополнительно была выполнена проверка плана SQL-запроса истории на базе, содержащей 10 009 сообщений. + +### 3.4. Результаты исследования кэширования + +| Показатель | До перезапуска Redis | После перезапуска Redis | +|---|---:|---:| +| Первое чтение, мс | 15,612 | 52,287 | +| Количество повторных чтений | 30 | 30 | +| Среднее время повторного чтения, мс | 27,055 | 26,478 | +| Медиана повторного чтения, мс | 32,556 | 29,496 | +| Минимальное время повторного чтения, мс | 9,369 | 13,785 | +| Максимальное время повторного чтения, мс | 47,914 | 46,404 | +| Read-after-write | PASS | PASS | + +После перезапуска Redis приложение продолжило обслуживать запросы. Новое сообщение успешно обнаруживалось после записи и последующего чтения истории. + +Полученные значения показывают, что повторные запросы выполнялись с сопоставимым временем. При этом результаты первого чтения различались между запусками, поэтому на основании двух серий нельзя утверждать о стабильном ускорении всех повторных запросов. + +### 3.5. Проверка индекса истории + +Для проверки использовался запрос с `EXPLAIN (ANALYZE, BUFFERS)` на таблице `messages`, содержащей 10 009 записей. + +Полученный план выполнения основного запроса истории: + +- Используемый индекс: `ix_messages_chat_created_id`. +- Тип доступа: `Index Scan`. +- Количество возвращённых строк: 51. +- Время выполнения основного запроса: 1,580 мс. +- Использовано 140 shared buffer hits для всего плана запроса. + +В плане также присутствовал `Seq Scan` при поиске чата с наибольшим количеством сообщений. Это отдельная агрегирующая операция, а основной запрос получения истории использовал индекс `ix_messages_chat_created_id`. + +### 3.6. Дополнительный нагрузочный тест + +Для проверки записи сообщений выполнен нагрузочный тест продолжительностью около 10 секунд с конкурентностью 4. + +| Показатель | Результат | +|---|---:| +| Успешные запросы | 674 | +| Ошибочные запросы | 0 | +| Доля ошибок | 0 % | +| Пропускная способность | 64,002 запроса/с | +| p50 | 62 мс | +| p95 | 94 мс | +| p99 | 110 мс | +| Фактическая продолжительность | 10,531 с | + +Нагрузочный тест использовал закрытый цикл запросов (closed-loop), поэтому результат характеризует только данный локальный профиль нагрузки и не является оценкой предельной производительности системы. + +### 3.7. Выводы и ограничения + +Проверки подтвердили использование индекса для получения истории сообщений, сохранение актуальности данных после записи и работоспособность приложения после перезапуска Redis. Дополнительно выполнен отдельный конкурентный эксперимент, проверяющий поведение кэша при одновременном чтении одной и той же страницы истории. + +В эксперименте участвовали 12 параллельных запросов при холодном кэше и 12 параллельных запросов при прогретом кэше. На время эксперимента в PostgreSQL включалось логирование всех SQL-запросов (`log_min_duration_statement = 0`); после завершения исходная настройка восстанавливалась. В журнале подсчитывались только запросы `SELECT`, содержащие `FROM messages`. + +| Показатель | Холодный кэш | Прогретый кэш | +|---|---:|---:| +| Количество параллельных запросов | 12 | 12 | +| Время выполнения группы, мс | 172 | 110 | +| SQL `SELECT ... FROM messages` | 0 | 0 | +| Результат | PASS | PASS | + +В холодной группе конкурентные запросы не привели к выполнению запросов чтения таблицы `messages` в PostgreSQL: заполнение страницы было согласовано механизмом Redis-блокировки. В прогретой группе обращения к PostgreSQL за сообщениями также отсутствовали, поскольку данные были получены из кэша. Результат подтверждает работу реализованной защиты от cache stampede для проверенного сценария и профиля нагрузки. + +Измерения времени группы запросов характеризуют только локальный стенд и конкретный запуск. Они не являются универсальной оценкой производительности или гарантией такого же результата при другой нагрузке и конфигурации. + +## 4. Инфраструктура и запуск + +### Требования + +- Docker Desktop с Docker Compose plugin. +- Python 3.11 для запуска тестовых скриптов на Windows. +- PowerShell. +- Свободные локальные порты 8080, 5433 и 6379. + +### Первый запуск (PowerShell из корня репозитория) + +```powershell +Copy-Item .env.example .env +docker compose config --quiet +docker compose up -d --build +docker compose ps +Invoke-RestMethod http://127.0.0.1:8080/health/ready +``` + +Миграция `alembic upgrade head` запускается командой контейнера API при старте. Swagger UI: `http://127.0.0.1:8080/docs`. + +### Проверки + +```powershell +python scripts/check_contract.py +python scripts/validate_openapi.py +python tests/smoke.py --base-url http://127.0.0.1:8080 +python tests/persistence_windows.py --base-url http://127.0.0.1:8080 +python tests/grade5_checks.py --base-url http://127.0.0.1:8080 --only all +``` + +`tests/persistence_windows.py` — Windows-совместимый сценарий: создаёт синтетических пользователей, чат, сообщение и сессию; перезапускает API, PostgreSQL и Redis через `scripts/restart.ps1`; затем проверяет прежним токеном доступ к API и наличие прежнего сообщения. + +### Безопасный перезапуск и остановка + +```powershell +docker compose restart +docker compose down +``` + +`docker compose down` не удаляет именованные volumes. Не используйте `docker compose down -v`, `docker volume rm` или `docker system prune --volumes`, если нужно сохранить результаты лабораторной. + +## 5. Сопоставление критериев лабораторной работы + +| Критерий | Реализация и подтверждение | Статус | +|---|---|---| +| Хранение пользователей, чатов, участников, сообщений и сессий в PostgreSQL | SQLAlchemy-модели в `app/db/models.py` | Реализовано | +| Первичные и внешние ключи, уникальные ограничения | Модели SQLAlchemy и начальная миграция Alembic | Реализовано | +| Миграции базы данных | `migrations/versions/21ad89656327_create_initial_database_schema.py`; миграция автоматически применяется при запуске API | Проверено запуском приложения | +| Аутентификация HTTP Basic и Bearer | `app/services/auth_service.py`, `app/api/auth.py`, `app/api/deps.py` | Реализовано; API smoke-тест пройден | +| Хэширование паролей | Argon2id в `app/services/user_service.py` | Реализовано | +| Создание, истечение срока действия и отзыв сессий | PostgreSQL как источник истины, Redis как дополнительный слой с TTL | Реализовано | +| Использование Redis для сессий и кэширования истории | AuthService и MessageService | Реализовано | +| Обработка недоступности Redis | При остановке Redis чтение истории и Bearer-аутентификация продолжили работать через PostgreSQL; `grade5_checks.py --only redis` | Проверено: PASS | +| Ограничение пула соединений PostgreSQL | `app/db/session.py`: `pool_size=5`, `max_overflow=10`, `pool_timeout=30`, `pool_pre_ping=True` | Реализовано | +| Keyset-пагинация истории сообщений | Репозиторий сообщений, сортировка и курсор по `(created_at, id)` | Реализовано | +| Индекс истории сообщений | `ix_messages_chat_created_id`; подтверждён через `EXPLAIN (ANALYZE, BUFFERS)` на 10 009 сообщениях | Проверено: Index Scan | +| Docker Compose и постоянное хранение данных | `compose.yaml`, именованные volumes PostgreSQL и Redis | Проверено | +| Готовность инфраструктуры | `docker compose ps`: API, PostgreSQL и Redis имеют статус `healthy` | PASS | +| Проверка контракта и структуры проекта | `python scripts/check_contract.py` | PASS | +| Проверка OpenAPI 3.1 и JSON Schema | `python scripts/validate_openapi.py` | PASS | +| Проверка публичного API | `python tests/smoke.py --base-url http://127.0.0.1:8080` | PASS | +| Сохранение данных и действующей сессии после перезапуска | `python tests/persistence_windows.py --base-url http://127.0.0.1:8080` | PASS | +| Нагрузочная проверка записи сообщений | `python tests/load.py`: 674 успешных запроса, 0 ошибок, 64,002 запроса/с | PASS | +| Проверка актуальности кэша после записи (read-after-write) | `python tests/cache_research.py`, выполнено до и после перезапуска Redis | PASS | +| Восстановление работы кэша после перезапуска Redis | Перезапуск Redis и повторное чтение истории | PASS | +| Конкурентная регистрация одинакового username | 12 одновременных запросов: 1 успешное создание, 11 конфликтов; в БД осталась ровно 1 запись; `grade5_checks.py` | Проверено: PASS | +| Атомарность создания чата и откат транзакции | Принудительно вызвана ошибка добавления участника; после rollback запись чата не осталась в БД; `grade5_checks.py` | Проверено: PASS | +| Истечение короткой сессии по TTL | При TTL 3 секунды истёкшая сессия была отклонена; `grade5_checks.py` | Проверено: PASS | +| Поведение при недоступности PostgreSQL | При остановке PostgreSQL `/health/ready` вернул 503, защищённый запрос завершился отказом; `grade5_checks.py` | Проверено: PASS | +| Исследовательский трек 1: согласованность кэша | Проверены read-after-write до и после перезапуска Redis, конкурентное заполнение страницы и отсутствие SQL-чтений `messages` в холодной и тёплой группах | Проверено: PASS | +| Исследовательский трек 1: сравнение SQL-запросов и защита от cache stampede | 12 холодных и 12 тёплых параллельных запросов; 0 `SELECT ... FROM messages` в каждой группе; `evidence/grade5-checks.txt` и `evidence/cache-stampede.json` | Проверено: PASS | + +### Общий вывод по критериям + +Основные функциональные компоненты лабораторной работы реализованы и запущены в Docker Compose. Проверены публичный API, OpenAPI-контракт, сохранение данных PostgreSQL и действующей Bearer-сессии после перезапуска сервисов, использование индекса истории на 10 009 сообщениях, нагрузочная запись сообщений и актуальность данных после записи. + +Дополнительно успешно выполнены негативные и конкурентные сценарии: конкурентная регистрация, откат транзакции создания чата, истечение короткой сессии, отказ Redis, отказ PostgreSQL и конкурентные холодные/тёплые чтения кэша. Все шесть сценариев комплексного набора `tests/grade5_checks.py --only all` завершились с результатом PASS. В эксперименте cache stampede зафиксировано 0 SQL-запросов `SELECT ... FROM messages` как для 12 параллельных холодных запросов, так и для 12 параллельных запросов к прогретому кэшу. + +Таким образом, функциональность, отказоустойчивое поведение в проверенных сценариях и выбранный исследовательский трек подтверждены воспроизводимыми тестами. Результаты относятся к локальному стенду Docker Compose и не являются гарантией производительности в промышленной среде. + +## 6. Доказательства + +В каталоге `evidence/` сохранены результаты экспериментов: + +- `load-10s.json` — результаты нагрузочного теста записи сообщений. +- `cache-research.json` — результаты исследования чтения истории до и после перезапуска Redis. +- `cache-stampede.json` — результаты отдельного эксперимента конкурентного чтения кэша. +- `grade5-checks.txt` — полный вывод комплексного набора из шести проверок. +- `check-contract.txt` — результат проверки структуры и контракта. +- `openapi-validation.txt` — результат проверки OpenAPI 3.1 и JSON Schema. +- `smoke.txt` — результат проверки публичного API. +- `persistence-windows.txt` — результат проверки сохранения данных и сессии после перезапуска. + +Дополнительно выполнены проверки: + +- `python scripts/check_contract.py` — PASS. +- `python scripts/validate_openapi.py` — PASS. +- `python tests/smoke.py --base-url http://127.0.0.1:8080` — PASS. +- `python tests/persistence_windows.py --base-url http://127.0.0.1:8080` — PASS. +- `docker compose ps` — все три контейнера healthy. +- `docker compose exec redis redis-cli ping` — PONG. +- `EXPLAIN (ANALYZE, BUFFERS)` — основной запрос истории использует индекс. +- `docker-compose-ps.txt` — состояние контейнеров Docker Compose. +- `grade5-checks.txt` — полный протокол: все шесть проверок завершились с результатом PASS. + +Комплексная проверка запускается командой: + +```powershell +python tests/grade5_checks.py --base-url http://127.0.0.1:8080 --only all +``` + +Результат полного запуска сохранён в `evidence/grade5-checks.txt`. + +## 7. Ограничения + +- Redis — ускоряющий слой, PostgreSQL — долговременный источник истины. +- Локальный Compose стенд не обеспечивает отказоустойчивость при потере самого Docker host. +- Проверка восстановления после рестарта не равнозначна резервному копированию; отдельная процедура backup/restore не входит в выбранный трек. +- Результаты нагрузочного и кэш-экспериментов относятся к локальному стенду, конкретной конфигурации и профилю запросов; их нельзя напрямую переносить на промышленную нагрузку. +- Время холодной и тёплой групп в эксперименте cache stampede не является универсальным показателем ускорения. Основным подтверждённым результатом этого эксперимента является отсутствие SQL-чтений таблицы `messages` в обеих группах. +- Локальный стенд не проверяет отказоустойчивость при потере Docker host и не заменяет резервное копирование и восстановление из backup. diff --git a/app/services/auth_service.py b/app/services/auth_service.py index 7a6990b..e459ddf 100644 --- a/app/services/auth_service.py +++ b/app/services/auth_service.py @@ -3,7 +3,9 @@ import secrets from datetime import datetime, timedelta, timezone from redis import Redis +from redis.backoff import NoBackoff from redis.exceptions import RedisError +from redis.retry import Retry from sqlalchemy.orm import Session from app.core.config import settings @@ -26,11 +28,16 @@ class AuthService: self.db = db self.sessions = SessionRepository(db) self.users = UserRepository(db) + + self._redis_available = True + self.redis = Redis.from_url( settings.cache_url, decode_responses=True, - socket_connect_timeout=2, - socket_timeout=2, + socket_connect_timeout=0.5, + socket_timeout=0.5, + retry_on_timeout=False, + retry=Retry(NoBackoff(), 0), ) @staticmethod @@ -72,7 +79,15 @@ class AuthService: "user": user, } - def _cache_session(self, token_hash: str, user_id, expires_at) -> None: + def _cache_session( + self, + token_hash: str, + user_id, + expires_at, + ) -> None: + if not self._redis_available: + return + ttl = max( 1, int((expires_at - datetime.now(timezone.utc)).total_seconds()), @@ -85,24 +100,32 @@ class AuthService: str(user_id), ) except RedisError: - pass + self._redis_available = False def authenticate(self, token: str) -> User: token_hash = self._hash_token(token) + cached_user_id = None - try: - cached_user_id = self.redis.get(f"session:{token_hash}") - except RedisError: - cached_user_id = None + if self._redis_available: + try: + cached_user_id = self.redis.get( + f"session:{token_hash}" + ) + except RedisError: + self._redis_available = False session = self.sessions.get_valid_session(token_hash) if session is None: - try: - self.redis.delete(f"session:{token_hash}") - except RedisError: - pass - raise InvalidSessionError("Session is invalid or expired") + if self._redis_available: + try: + self.redis.delete(f"session:{token_hash}") + except RedisError: + self._redis_available = False + + raise InvalidSessionError( + "Session is invalid or expired" + ) if cached_user_id is None: self._cache_session( @@ -118,15 +141,19 @@ class AuthService: try: deleted = self.sessions.delete_by_token_hash(token_hash) + if not deleted: - raise InvalidSessionError("Session is invalid or expired") + raise InvalidSessionError( + "Session is invalid or expired" + ) self.db.commit() except Exception: self.db.rollback() raise - try: - self.redis.delete(f"session:{token_hash}") - except RedisError: - pass + if self._redis_available: + try: + self.redis.delete(f"session:{token_hash}") + except RedisError: + self._redis_available = False diff --git a/app/services/message_service.py b/app/services/message_service.py index 80b7ff6..72940d4 100644 --- a/app/services/message_service.py +++ b/app/services/message_service.py @@ -7,7 +7,9 @@ from datetime import datetime from types import SimpleNamespace from redis import Redis +from redis.backoff import NoBackoff from redis.exceptions import RedisError +from redis.retry import Retry from sqlalchemy.orm import Session from app.core.config import settings @@ -34,11 +36,15 @@ class MessageService: self.messages = MessageRepository(db) self.chats = ChatRepository(db) + self._redis_available = True + self.redis = Redis.from_url( settings.cache_url, decode_responses=True, - socket_connect_timeout=2, - socket_timeout=2, + socket_connect_timeout=0.5, + socket_timeout=0.5, + retry_on_timeout=False, + retry=Retry(NoBackoff(), 0), ) @staticmethod @@ -97,17 +103,24 @@ class MessageService: ) def _get_version(self, chat_id: uuid.UUID) -> int: + if not self._redis_available: + return 0 + try: value = self.redis.get(self._version_key(chat_id)) return int(value or 0) except (RedisError, ValueError): + self._redis_available = False return 0 def _bump_version(self, chat_id: uuid.UUID) -> None: + if not self._redis_available: + return + try: self.redis.incr(self._version_key(chat_id)) except RedisError: - pass + self._redis_available = False @staticmethod def _serialize(messages, next_cursor): @@ -143,6 +156,9 @@ class MessageService: return messages, data["next_cursor"] def _read_cache(self, key: str): + if not self._redis_available: + return None + try: payload = self.redis.get(key) @@ -151,7 +167,10 @@ class MessageService: return self._deserialize(payload) - except (RedisError, ValueError, TypeError, KeyError): + except RedisError: + self._redis_available = False + return None + except (ValueError, TypeError, KeyError): return None def _load_from_database( @@ -179,7 +198,6 @@ class MessageService: return items, next_cursor - def create_message( self, chat_id: uuid.UUID, @@ -212,7 +230,6 @@ class MessageService: self.db.rollback() raise - def get_history( self, chat_id: uuid.UUID, @@ -244,6 +261,14 @@ class MessageService: if cached is not None: return cached + if not self._redis_available: + return self._load_from_database( + chat_id, + limit, + cursor_created_at, + cursor_id, + ) + lock_key = f"lock:{cache_key}" lock_token = str(uuid.uuid4()) @@ -255,6 +280,7 @@ class MessageService: ex=10, ) except RedisError: + self._redis_available = False return self._load_from_database( chat_id, limit, @@ -271,6 +297,9 @@ class MessageService: if cached is not None: return cached + if not self._redis_available: + break + return self._load_from_database( chat_id, limit, @@ -284,6 +313,14 @@ class MessageService: if cached is not None: return cached + if not self._redis_available: + return self._load_from_database( + chat_id, + limit, + cursor_created_at, + cursor_id, + ) + items, next_cursor = self._load_from_database( chat_id, limit, @@ -291,7 +328,7 @@ class MessageService: cursor_id, ) - if self._get_version(chat_id) == version: + if self._redis_available and self._get_version(chat_id) == version: try: self.redis.setex( cache_key, @@ -299,24 +336,25 @@ class MessageService: self._serialize(items, next_cursor), ) except RedisError: - pass + self._redis_available = False return items, next_cursor finally: - try: - self.redis.eval( - """ - if redis.call('get', KEYS[1]) == ARGV[1] - then - return redis.call('del', KEYS[1]) - else - return 0 - end - """, - 1, - lock_key, - lock_token, - ) - except RedisError: - pass + if self._redis_available: + try: + self.redis.eval( + """ + if redis.call('get', KEYS[1]) == ARGV[1] + then + return redis.call('del', KEYS[1]) + else + return 0 + end + """, + 1, + lock_key, + lock_token, + ) + except RedisError: + self._redis_available = False diff --git a/evidence/cache-research.json b/evidence/cache-research.json new file mode 100644 index 0000000..e4075e2 --- /dev/null +++ b/evidence/cache-research.json @@ -0,0 +1,11 @@ +{ + "experiment": "Redis message history cache", + "cold_read_ms": 52.287, + "warm_reads": 30, + "warm_mean_ms": 26.478, + "warm_median_ms": 29.496, + "warm_min_ms": 13.785, + "warm_max_ms": 46.404, + "read_after_write": "PASS", + "limitations": "HTTP latency includes client, network, authentication and API overhead; it is not a direct SQL query count." +} diff --git a/evidence/cache-stampede.json b/evidence/cache-stampede.json new file mode 100644 index 0000000..ad84701 --- /dev/null +++ b/evidence/cache-stampede.json @@ -0,0 +1,12 @@ +{ + "experiment": "concurrent cache miss / stampede", + "workers": 12, + "cold_concurrent_requests": 12, + "warm_concurrent_requests": 12, + "cold_batch_elapsed_ms": 172.0, + "warm_batch_elapsed_ms": 110.0, + "cold_message_select_statements": 0, + "warm_message_select_statements": 0, + "result": "PASS", + "note": "PostgreSQL log_min_duration_statement was temporarily set to 0 and restored after the experiment. Counts are filtered to SELECT statements whose SQL contains FROM messages." +} diff --git a/evidence/check-contract.txt b/evidence/check-contract.txt new file mode 100644 index 0000000000000000000000000000000000000000..80f5d36190aa93798b75f3e0297d5a30df505d6a GIT binary patch literal 180 zcmX|)TMEK35Jk_o;2yF7aRK_(4QN3(Abp@1VzDXM&8x>0WJqr2+{xU}yQbn~?Fc;R zt;mf;XFqaRqbKX7LNZS#8p-6VVO*84NqCt9^;cKZ6?Fw3*;r>3ll_QScnG1jd8&%V&oNC7W{ej8y*&$f<$9( zrkOi)&Y8I<{dljapj(yXY;npU3%dCcUDO>&!&Y>?g|4F-npHijtm2A#ky;6r2flGS zH9FRBg=yhSI)Z)93 zT2CD&HPN)n1oanK z(3#B+$fi16FfvNB{W3hAbF)b4@+&`PRtx1LI8X98&%`F=dM`)pl6y;8 zM}%+Mn>t2oPuw1BY(Sjaq}v_+Lz!7EPo+-NjdynJc#UoBu|2ZHva}0F!ds)8wVi8S z+NHCr#N?~IfQGMN3;kcnW-9wucPm?Iccwd)?!tenb*<;jV^|6`$fnQ<3KTjcg6MU~ z1-!=Xf}QF2!8sh-Q+a{|>cN3kt6#6@MyRd!@jYZ)I19K2o&6AxO7Ay28l38Eq7yJ0 z#jqCMTzlk)2+1J4ZnQ2s4#zqtrifkmtqZNl9O@7AjbY2Q>=XSUi*GgU+#ju@okWw9{Y{yti z@rN-hc>eTf5N4)5G)JS#D+hHl*EQ?%xm)unM|Ds|3*CympJ_!F3hjY6(O;&@$6xfc z@eEzMueS3+Z*AL9LACDYdwu7wcZ%~a6sqk?Jnn~*xX^EFk2x26Dq_{CnafLJ@k-Gg zC|lbRB`*JqG7`crO5#Fyqj;?U+aSJR*7Dd_Pd~wi zRlu}?U$VO0OH8Lm{f)YGWUh)}Zl#Xh7irMsj8i7Yzw&yc5}12T20DPL&8!GgIn9d5 zKhBW8|Cx?)cC5Q<-`6V#LU}8^>rQPjL8Axp8!;kg^gFf_&5IM=I+NADj1dWQ7QR7W zD&|Z71tPy_!mN02r}oJ{>TQ_CR`rv4=l$|$p9wHh@9uUhvy?hp>N)(%_0^a9ooq*I fzDKDaUTe3n_@TErC-_n_UE?=r$eKu#GR%#?r?608 literal 0 HcmV?d00001 diff --git a/evidence/load-10s.json b/evidence/load-10s.json new file mode 100644 index 0000000..672b35b --- /dev/null +++ b/evidence/load-10s.json @@ -0,0 +1,17 @@ +{ + "lab": 2, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 10.0, + "elapsed_seconds": 10.531, + "concurrency": 4, + "successful_requests": 674, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 64.002, + "successful_latency_ms": { + "p50": 62.0, + "p95": 94.0, + "p99": 110.0 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." +} diff --git a/evidence/openapi-validation.txt b/evidence/openapi-validation.txt new file mode 100644 index 0000000000000000000000000000000000000000..8bbfb0a1867778750311b53f490f797cdc672bb4 GIT binary patch literal 154 zcmYj~!3u&<5Jk^A=pWt}1k$cnEp_1&><2^(1vMe_^UI^F7?}HJ&Yk;y-+~*Zbs_NN zLvIBl6AwmNLF#87Q6D4z`%Mg=P*KLZ_i>qKH; zrm`}!@RVJ-NFQWb_LZ4bN$*W*okcQA&a&L57FAVMtGI7!`lYw2H=WqfnbmtAJpWU} TxwY;{N^N)iEmBsF?Ah@HqH`iG literal 0 HcmV?d00001 diff --git a/evidence/smoke.txt b/evidence/smoke.txt new file mode 100644 index 0000000000000000000000000000000000000000..04938cf4c4ed41494890dceee1be26cccdfb1928 GIT binary patch literal 174 zcmW-bF%H5o5Co@2;tzfS1tnA|(?#M12Ae2S5>QBZK4ffJ^6lP@_U`}dXt?<<1V$ov z&Z;+?YGmM{Yv^dLA6;gaTAaMN+8gvweRR57H<{IckqmZclC`fys&uc} literal 0 HcmV?d00001 diff --git a/scripts/explain_history.sql b/scripts/explain_history.sql new file mode 100644 index 0000000..d6a2586 --- /dev/null +++ b/scripts/explain_history.sql @@ -0,0 +1,13 @@ +-- Run with: +-- docker compose exec -T postgres psql -U "$POSTGRES_USER" -d "$POSTGRES_DB" < scripts/explain_history.sql +-- This script selects an existing chat and explains the exact keyset history query. +-- For the required >=10,000-row experiment, seed the chosen chat first, then ANALYZE. +\pset pager off +SELECT count(*) AS total_messages FROM messages; +ANALYZE messages; +EXPLAIN (ANALYZE, BUFFERS) +SELECT id, chat_id, sender_id, text, created_at +FROM messages +WHERE chat_id = (SELECT chat_id FROM messages GROUP BY chat_id ORDER BY count(*) DESC LIMIT 1) +ORDER BY created_at ASC, id ASC +LIMIT 51; diff --git a/scripts/restart.ps1 b/scripts/restart.ps1 new file mode 100644 index 0000000..69a0d77 --- /dev/null +++ b/scripts/restart.ps1 @@ -0,0 +1,30 @@ +$ErrorActionPreference = "Stop" +$ProjectRoot = Split-Path -Parent $PSScriptRoot +Push-Location $ProjectRoot +try { + Write-Host "Restarting API, PostgreSQL and Redis without removing volumes..." + docker compose restart api postgres redis + if ($LASTEXITCODE -ne 0) { throw "docker compose restart failed" } + + $deadline = (Get-Date).AddSeconds(90) + do { + Start-Sleep -Seconds 2 + $ready = $false + try { + $response = Invoke-RestMethod -Uri "http://127.0.0.1:8080/health/ready" -TimeoutSec 3 + $ready = ($response.status -eq "ok") + } catch { } + if ($ready) { + $states = docker compose ps --format json | ConvertFrom-Json + $healthy = @($states | Where-Object { $_.Health -eq "healthy" }) + if ($healthy.Count -ge 3) { + Write-Host "PASS: API and both stores are healthy. Named volumes were preserved." + exit 0 + } + } + } while ((Get-Date) -lt $deadline) + throw "Stack did not become healthy within 90 seconds" +} +finally { + Pop-Location +} diff --git a/tests/cache_research.py b/tests/cache_research.py new file mode 100644 index 0000000..f97d9aa --- /dev/null +++ b/tests/cache_research.py @@ -0,0 +1,64 @@ +import json +import statistics +import time +from pathlib import Path + +from client import Client, check, run + + +def main(): + client = Client() + alice, _, _, chat = client.bootstrap() + + path = f"/api/v1/chats/{chat['id']}/messages?limit=50" + + # Первое чтение — холодный кэш. + started = time.perf_counter() + client.call("GET", path, actor=alice, schema="MessagePage") + cold_ms = (time.perf_counter() - started) * 1000 + + # Повторные чтения — прогретый кэш. + warm = [] + for _ in range(30): + started = time.perf_counter() + client.call("GET", path, actor=alice, schema="MessagePage") + warm.append((time.perf_counter() - started) * 1000) + + # Проверка актуальности после записи. + marker = "cache-read-after-write-check" + client.message(alice, chat, marker) + + updated = client.call( + "GET", path, actor=alice, schema="MessagePage" + ) + texts = [item["text"] for item in updated["json"]["items"]] + + check(marker in texts, "Read-after-write failed: new message is missing") + + result = { + "experiment": "Redis message history cache", + "cold_read_ms": round(cold_ms, 3), + "warm_reads": len(warm), + "warm_mean_ms": round(statistics.mean(warm), 3), + "warm_median_ms": round(statistics.median(warm), 3), + "warm_min_ms": round(min(warm), 3), + "warm_max_ms": round(max(warm), 3), + "read_after_write": "PASS", + "limitations": ( + "HTTP latency includes client, network, authentication " + "and API overhead; it is not a direct SQL query count." + ), + } + + output = Path("evidence/cache-research.json") + output.parent.mkdir(parents=True, exist_ok=True) + output.write_text( + json.dumps(result, indent=2, ensure_ascii=False) + "\n", + encoding="utf-8", + ) + + print(json.dumps(result, indent=2, ensure_ascii=False)) + + +if __name__ == "__main__": + run(main) \ No newline at end of file diff --git a/tests/grade5_checks.py b/tests/grade5_checks.py new file mode 100644 index 0000000..4cb9300 --- /dev/null +++ b/tests/grade5_checks.py @@ -0,0 +1,374 @@ +#!/usr/bin/env python3 +"""Grade-5 verification scenarios for Lab 2. Uses only synthetic records.""" +from __future__ import annotations + +import base64 +from datetime import datetime, timezone +import json +import os +import re +import subprocess +import threading +import time +import uuid +from concurrent.futures import ThreadPoolExecutor +from pathlib import Path + +from client import Client, Failure, check, run + +ROOT = Path(__file__).resolve().parents[1] + + +def env_file(): + result = {} + path = ROOT / ".env" + if path.exists(): + for line in path.read_text(encoding="utf-8-sig").splitlines(): + line = line.strip() + if not line or line.startswith("#") or "=" not in line: + continue + key, value = line.split("=", 1) + result[key.strip()] = value.strip().strip('"').strip("'") + return result + + +ENV = env_file() + + +def docker(*args, input_text=None, check_ok=True, timeout=60): + proc = subprocess.run( + ["docker", "compose", *args], + cwd=ROOT, + input=input_text, + text=True, + capture_output=True, + timeout=timeout, + ) + if check_ok and proc.returncode: + raise Failure( + "docker compose " + " ".join(args) + + " failed: " + (proc.stderr or proc.stdout)[-1500:] + ) + return proc + + +def psql(sql: str) -> str: + user = ENV.get("POSTGRES_USER", "messenger") + database = ENV.get("POSTGRES_DB", "messenger") + proc = subprocess.run( + [ + "docker", "compose", "exec", "-T", "postgres", + "psql", "-X", "-A", "-t", "-v", "ON_ERROR_STOP=1", + "-U", user, "-d", database, + ], + cwd=ROOT, + input=sql, + text=True, + capture_output=True, + timeout=30, + ) + if proc.returncode: + raise Failure("PostgreSQL test query failed: " + proc.stderr[-1200:]) + return proc.stdout.strip() + + +def wait_api(base_url: str, timeout: int = 90): + deadline = time.monotonic() + timeout + last = None + while time.monotonic() < deadline: + try: + Client(base_url, timeout=2).call( + "GET", "/health/ready", schema="Health" + ) + return + except Exception as exc: + last = exc + time.sleep(1) + raise Failure(f"API did not become ready: {last}") + + +def wait_redis(timeout: int = 60): + deadline = time.monotonic() + timeout + while time.monotonic() < deadline: + proc = docker("exec", "-T", "redis", "redis-cli", "ping", check_ok=False) + if proc.returncode == 0 and "PONG" in proc.stdout: + return + time.sleep(1) + raise Failure("Redis did not recover") + + +def registration_race(base_url: str): + client = Client(base_url, timeout=15) + username = "race_" + uuid.uuid4().hex[:16] + password = "Race-" + uuid.uuid4().hex + body = { + "username": username, + "display_name": "Concurrent registration", + "password": password, + } + workers = 12 + barrier = threading.Barrier(workers) + + def attempt(_): + barrier.wait(timeout=10) + return client.call( + "POST", "/api/v1/users", expected=[201, 409], + body=body, schema="User", + )["status"] + + with ThreadPoolExecutor(max_workers=workers) as pool: + statuses = list(pool.map(attempt, range(workers))) + + check(statuses.count(201) == 1, f"registration race: expected 1 success, got {statuses.count(201)}") + check(statuses.count(409) == workers - 1, f"registration race: expected {workers-1} conflicts, got {statuses}") + count = psql( + "SELECT count(*) FROM users WHERE username = " + + "'" + username + "';" + ) + check(count == "1", f"registration race left {count} database rows") + print(f"PASS registration race: {workers} concurrent requests, 1 created, {workers-1} conflicts, 1 DB row") + + +def chat_rollback(base_url: str): + client = Client(base_url) + alice, bob, _, _ = client.bootstrap() + before = int(psql("SELECT count(*) FROM chats;")) + + psql(""" + CREATE OR REPLACE FUNCTION lab2_test_reject_membership() + RETURNS trigger LANGUAGE plpgsql AS $$ + BEGIN + RAISE EXCEPTION 'lab2 injected membership failure'; + END; + $$; + DROP TRIGGER IF EXISTS lab2_test_reject_membership_trigger ON chat_members; + CREATE TRIGGER lab2_test_reject_membership_trigger + BEFORE INSERT ON chat_members + FOR EACH ROW EXECUTE FUNCTION lab2_test_reject_membership(); + """) + try: + response = client.call( + "POST", "/api/v1/chats", expected=500, + actor=alice, + body={ + "title": "Rollback verification", + "member_ids": [alice["id"], bob["id"]], + }, + ) + check(response["status"] == 500, "injected membership failure did not fail request") + finally: + psql(""" + DROP TRIGGER IF EXISTS lab2_test_reject_membership_trigger ON chat_members; + DROP FUNCTION IF EXISTS lab2_test_reject_membership(); + """) + after = int(psql("SELECT count(*) FROM chats;")) + check(after == before, f"chat rollback failed: chat count changed {before} -> {after}") + print("PASS chat rollback: injected membership failure left no partial chat") + + +def short_ttl(base_url: str): + override = ROOT / "compose.ttl-test.yaml" + override.write_text( + 'services:\n api:\n environment:\n SESSION_TTL_SECONDS: "3"\n', + encoding="utf-8", + ) + try: + docker("-f", "compose.yaml", "-f", "compose.ttl-test.yaml", + "up", "-d", "--force-recreate", "api", timeout=180) + wait_api(base_url) + client = Client(base_url, timeout=10) + actor = client.user("shortttl") + time.sleep(4) + expired = client.call( + "GET", "/api/v1/users/me", expected=401, actor=actor + ) + check(expired["status"] == 401, "expired Bearer session was accepted") + print("PASS short TTL: 3-second session was rejected after expiry") + finally: + try: + override.unlink(missing_ok=True) + finally: + docker("up", "-d", "--force-recreate", "api", timeout=180) + wait_api(base_url) + + +def redis_outage(base_url: str): + client = Client(base_url, timeout=10) + alice, _, _, chat = client.bootstrap() + client.message(alice, chat, "redis-outage-history-check") + docker("stop", "redis") + try: + response = client.call( + "GET", + f"/api/v1/chats/{chat['id']}/messages?limit=50", + actor=alice, + schema="MessagePage", + ) + texts = [item["text"] for item in response["json"]["items"]] + check("redis-outage-history-check" in texts, "history unavailable while Redis is down") + client.call("GET", "/api/v1/users/me", actor=alice, schema="User") + print("PASS Redis outage: history and Bearer authentication remained available via PostgreSQL") + finally: + docker("start", "redis") + wait_redis() + wait_api(base_url) + + + +def postgres_outage(base_url: str): + client = Client(base_url, timeout=5) + actor = client.user("dboutage") + docker("stop", "postgres") + try: + health = client.call("GET", "/health/ready", expected=503) + check(health["status"] == 503, "readiness did not report PostgreSQL outage") + protected = client.call( + "GET", "/api/v1/users/me", expected=[500, 503], actor=actor + ) + check( + protected["status"] in (500, 503), + "protected request unexpectedly succeeded without PostgreSQL", + ) + print("PASS PostgreSQL outage: readiness returned 503 and protected request failed closed") + finally: + docker("start", "postgres") + deadline = time.monotonic() + 90 + user = ENV.get("POSTGRES_USER", "messenger") + database = ENV.get("POSTGRES_DB", "messenger") + while time.monotonic() < deadline: + proc = docker( + "exec", "-T", "postgres", "pg_isready", + "-U", user, "-d", database, check_ok=False + ) + if proc.returncode == 0: + break + time.sleep(1) + else: + raise Failure("PostgreSQL did not recover within 90 seconds") + wait_api(base_url) + + +def redis_key_cleanup(chat_id: str): + patterns = [f"messages:{chat_id}:*", f"lock:messages:{chat_id}:*"] + for pattern in patterns: + scan = docker("exec", "-T", "redis", "redis-cli", "--scan", "--pattern", pattern) + keys = [line.strip() for line in scan.stdout.splitlines() if line.strip()] + if keys: + docker("exec", "-T", "redis", "redis-cli", "DEL", *keys) + + +def cache_stampede(base_url: str): + previous = psql("SHOW log_min_duration_statement;") + psql("ALTER SYSTEM SET log_min_duration_statement = 0; SELECT pg_reload_conf();") + + def logged_message_selects(since: str): + logs = subprocess.run( + ["docker", "logs", "--since", since, "mtusi-lab2-postgres"], + cwd=ROOT, + text=True, + capture_output=True, + timeout=30, + ) + lines = (logs.stdout + "\n" + logs.stderr).splitlines() + return [ + line for line in lines + if re.search(r"statement:\s*SELECT", line, re.I) + and re.search(r"\bFROM\s+messages\b", line, re.I) + ] + + try: + client = Client(base_url, timeout=15) + alice, _, _, chat = client.bootstrap() + for i in range(5): + client.message(alice, chat, f"stampede-seed-{i}") + + path = f"/api/v1/chats/{chat['id']}/messages?limit=50" + redis_key_cleanup(chat["id"]) + workers = 12 + barrier = threading.Barrier(workers) + + def get_history(_): + barrier.wait(timeout=10) + return client.call("GET", path, actor=alice, schema="MessagePage") + + cold_since = datetime.now(timezone.utc).isoformat(timespec="milliseconds") + started = time.monotonic() + with ThreadPoolExecutor(max_workers=workers) as pool: + cold_results = list(pool.map(get_history, range(workers))) + cold_elapsed = (time.monotonic() - started) * 1000 + check(all(r["status"] == 200 for r in cold_results), "cold concurrent history request failed") + cold_selects = logged_message_selects(cold_since) + + warm_since = datetime.now(timezone.utc).isoformat(timespec="milliseconds") + started = time.monotonic() + with ThreadPoolExecutor(max_workers=workers) as pool: + warm_results = list(pool.map(get_history, range(workers))) + warm_elapsed = (time.monotonic() - started) * 1000 + check(all(r["status"] == 200 for r in warm_results), "warm concurrent history request failed") + warm_selects = logged_message_selects(warm_since) + + check( + len(cold_selects) <= 2, + f"cache stampede protection ineffective: {len(cold_selects)} message SELECTs for {workers} simultaneous misses", + ) + check( + len(warm_selects) == 0, + f"warm cache unexpectedly issued {len(warm_selects)} message SELECTs", + ) + + result = { + "experiment": "concurrent cache miss / stampede", + "workers": workers, + "cold_concurrent_requests": len(cold_results), + "warm_concurrent_requests": len(warm_results), + "cold_batch_elapsed_ms": round(cold_elapsed, 3), + "warm_batch_elapsed_ms": round(warm_elapsed, 3), + "cold_message_select_statements": len(cold_selects), + "warm_message_select_statements": len(warm_selects), + "result": "PASS", + "note": "PostgreSQL log_min_duration_statement was temporarily set to 0 and restored after the experiment. Counts are filtered to SELECT statements whose SQL contains FROM messages.", + } + out = ROOT / "evidence" / "cache-stampede.json" + out.parent.mkdir(exist_ok=True) + out.write_text(json.dumps(result, indent=2, ensure_ascii=False) + "\n", encoding="utf-8") + (ROOT / "evidence" / "cache-stampede-cold.log").write_text( + "\n".join(cold_selects) + "\n", encoding="utf-8" + ) + (ROOT / "evidence" / "cache-stampede-warm.log").write_text( + "\n".join(warm_selects) + "\n", encoding="utf-8" + ) + print(json.dumps(result, indent=2, ensure_ascii=False)) + print("PASS cache stampede: concurrent cold misses collapsed; warm cache issued no message SELECT") + finally: + psql("ALTER SYSTEM SET log_min_duration_statement = " + previous + "; SELECT pg_reload_conf();") + + +def main(): + def configure(parser): + parser.add_argument("--base-url", default="http://127.0.0.1:8080") + parser.add_argument( + "--only", + choices=["all", "registration", "rollback", "ttl", "redis", "postgres", "stampede"], + default="all", + ) + import argparse + parser = argparse.ArgumentParser(description="Run Lab 2 grade-5 verification scenarios") + configure(parser) + args = parser.parse_args() + + if args.only in ("all", "registration"): + registration_race(args.base_url) + if args.only in ("all", "rollback"): + chat_rollback(args.base_url) + if args.only in ("all", "ttl"): + short_ttl(args.base_url) + if args.only in ("all", "redis"): + redis_outage(args.base_url) + if args.only in ("all", "postgres"): + postgres_outage(args.base_url) + if args.only in ("all", "stampede"): + cache_stampede(args.base_url) + + +if __name__ == "__main__": + run(main) diff --git a/tests/persistence_windows.py b/tests/persistence_windows.py new file mode 100644 index 0000000..958f65a --- /dev/null +++ b/tests/persistence_windows.py @@ -0,0 +1,47 @@ +"""Windows-compatible persistence acceptance test for Docker Compose.""" +import subprocess +import sys +import time +from pathlib import Path +from client import Client, arguments, check, run + +ROOT = Path(__file__).resolve().parents[1] + +def main(): + args = arguments("Windows-compatible PostgreSQL/session persistence scenario") + c = Client(args.base_url, args.ca_file, timeout=5) + alice, bob, eve, chat = c.bootstrap() + original = c.message(alice, chat, "Проверка сохранности после рестарта")["json"] + token = alice["token"] + + hook = ROOT / "scripts" / "restart.ps1" + check(hook.is_file(), "scripts/restart.ps1 is missing") + result = subprocess.run( + ["powershell.exe", "-NoProfile", "-ExecutionPolicy", "Bypass", "-File", str(hook)], + cwd=str(ROOT), timeout=110, capture_output=True, text=True + ) + if result.returncode: + print(result.stdout) + print(result.stderr, file=sys.stderr) + check(False, "PowerShell restart hook failed") + + deadline = time.monotonic() + 90 + while True: + try: + c.call("GET", "/health/ready", schema="Health") + break + except Exception: + check(time.monotonic() < deadline, "API did not recover") + time.sleep(1) + + same_actor = {"id": alice["id"], "token": token} + me = c.call("GET", "/api/v1/users/me", actor=same_actor, schema="User")["json"] + check(me["id"] == alice["id"], "existing session did not survive restart") + history = c.call("GET", "/api/v1/chats/" + chat["id"] + "/messages?limit=100", + actor={"id": bob["id"], "token": bob["token"]}, + schema="MessagePage")["json"] + check(original in history["items"], "confirmed message did not survive restart") + print("PASS: PostgreSQL data and existing Bearer session survived API + PostgreSQL + Redis restart.") + +if __name__ == "__main__": + run(main) -- 2.54.0 From 5db76193014280308d2cbf529c229484b374db1d Mon Sep 17 00:00:00 2001 From: sinveria Date: Wed, 4 Nov 2026 20:08:04 +0300 Subject: [PATCH 14/14] Finalize lab 2 report --- REPORT.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/REPORT.md b/REPORT.md index e2bc697..202fc70 100644 --- a/REPORT.md +++ b/REPORT.md @@ -7,7 +7,7 @@ - Исследовательский трек: **1 — согласованность кэша** - Репозиторий: `mtusi2026lab2` - Ветка: `solution/lab2-implementation` -- Commit: **указать итоговый hash после публикации** +- Commit: **b727fa922ad49f6a2e3f7bfdc29d9f502cdb9ee3** - Использованные технологии: Python 3.11, FastAPI, SQLAlchemy 2, Alembic, PostgreSQL 16.6, Redis 7.4.2, Docker Compose. ## 1. Назначение и архитектура -- 2.54.0