diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000..f560375 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,29 @@ +# Pinned base image. Use a digest for reproducibility if you have one available: +# FROM python:3.12.7-slim-bookworm@sha256: +FROM python:3.12.7-slim-bookworm + +ENV PYTHONDONTWRITEBYTECODE=1 \ + PYTHONUNBUFFERED=1 \ + PIP_DISABLE_PIP_VERSION_CHECK=1 \ + PIP_NO_CACHE_DIR=1 \ + APP_HOST=0.0.0.0 \ + APP_PORT=8080 + +WORKDIR /app + +COPY requirements.txt . +RUN pip install --no-cache-dir -r requirements.txt + +COPY src/ ./src/ + +RUN useradd --create-home --uid 10001 --shell /usr/sbin/nologin appuser \ + && chown -R appuser:appuser /app +USER appuser + +EXPOSE 8080 + +HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \ + CMD python -c "import sys,urllib.request; \ +sys.exit(0 if urllib.request.urlopen('http://127.0.0.1:8080/health/live',timeout=2).status==200 else 1)" + +CMD ["python", "-m", "src"] \ No newline at end of file diff --git a/REPORT.md b/REPORT.md index e42f2b0..cdaadcf 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,60 @@ # Отчёт — лабораторная 2 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO -- Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +- Автор, группа: Вотчицева, БВТ2302 +- Целевая оценка: 4, трек 5 не заявлен +- Commit/PR: см. Merge Request в Gitea +- Использованные источники, библиотеки и помощь ИИ: + - Python 3.12, FastAPI, Uvicorn, SQLAlchemy (asyncpg), Redis, Passlib (bcrypt) + - При подготовке каркаса приложения использовался ассистент (Claude). + - Все зависимости закреплены в `requirements.txt`. ## Запуск из чистого clone -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +Prerequisites: Docker 24+, свободные порты `127.0.0.1:8080`. + +```sh +git clone https://gitea.privcloud.tech/Tutuxa/mtusi2026lab2.git +cd mtusi2026lab2 + +docker compose up -d --build + +# В другом терминале: +python tests\smoke.py --base-url http://localhost:8080 +python tests\resilience.py --mode persistence --action-script scripts\restart.cmd --base-url http://localhost:8080 + +# Остановка: +docker compose down ## Архитектура и решения -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +API: Python 3.12 + FastAPI (Uvicorn). Работает в контейнере от non-root пользователя (UID 10001). + +PostgreSQL: Источник истины для пользователей, чатов, участников и сообщений. Используется SQLAlchemy (ORM) + asyncpg. + +Сессии (Redis): Сессии хранятся в Redis с TTL (по умолчанию 3600 секунд). Включена персистентность AOF (appendonly yes). Источник истины для сессий — Redis. + +Хеширование: Passlib + bcrypt (версия 4.0.1 закреплена для стабильности). + +Пагинация: Keyset cursor по (created_at, id). Добавлен составной индекс ix_messages_chat_created_id. + +Обработка отказов: Если Redis или PostgreSQL недоступны, API возвращает 503 unavailable в едином формате ошибки. + +Docker Compose: Поднимает api, db (PostgreSQL 16-alpine) и redis (Redis 7-alpine). Для БД и Redis используются именованные volumes (pgdata, redisdata). ## Доказательства критериев | Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | | --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | - -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +| Публичный smoke | `python tests\smoke.py` | `PASS` | evidence/smoke.txt | +| Persistence | `python tests\resilience.py ...` | `PASS` | evidence/persistence.txt | +| Свои тесты (уровень 4) | `python student-tests\run.py` | `PASS` | evidence/student-tests.txt | +| Отказ Redis (503) | `python scripts\test_redis_down.py` | `PASS` | evidence/redis-down.txt | +| EXPLAIN (Индекс) | `EXPLAIN ...` | `Index Scan` | evidence/explain.txt | ## Эксперименты и отказы -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. - -| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | +| Воздействие | Что ожидали | Что наблюдали | Потеря данных | | --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | - -## Ограничения и следующие шаги - -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +| `docker compose restart` | Сохранение данных | Токен выжил | Нет | +| Остановка Redis | Ошибка 503 | Ошибка 503 | Нет | +| Гонка при регистрации | Один 201, один 409 | 201 и 409 | Нет | \ No newline at end of file diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 0000000..c89b8ef --- /dev/null +++ b/compose.yaml @@ -0,0 +1,51 @@ +services: + api: + build: . + ports: + - "127.0.0.1:8080:8080" + environment: + - APP_HOST=0.0.0.0 + - APP_PORT=8080 + - SESSION_TTL_SECONDS=3600 + - DATABASE_URL=postgresql+asyncpg://user:password@db:5432/messenger + - SESSION_STORE=redis + - CACHE_URL=redis://redis:6379/0 + depends_on: + db: + 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/live')"] + interval: 5s + timeout: 3s + retries: 5 + + db: + image: postgres:16-alpine + environment: + - POSTGRES_USER=user + - POSTGRES_PASSWORD=password + - POSTGRES_DB=messenger + volumes: + - pgdata:/var/lib/postgresql/data + healthcheck: + test: ["CMD-SHELL", "pg_isready -U user -d messenger"] + interval: 3s + timeout: 3s + retries: 5 + + redis: + image: redis:7-alpine + command: redis-server --appendonly yes + volumes: + - redisdata:/data + healthcheck: + test: ["CMD", "redis-cli", "ping"] + interval: 3s + timeout: 3s + retries: 5 + +volumes: + pgdata: + redisdata: \ No newline at end of file diff --git a/evidence/explain.txt b/evidence/explain.txt new file mode 100644 index 0000000..754c154 Binary files /dev/null and b/evidence/explain.txt differ diff --git a/evidence/persistence.txt b/evidence/persistence.txt new file mode 100644 index 0000000..c25ceba Binary files /dev/null and b/evidence/persistence.txt differ diff --git a/evidence/redis-down.txt b/evidence/redis-down.txt new file mode 100644 index 0000000..900d0ec Binary files /dev/null and b/evidence/redis-down.txt differ diff --git a/evidence/smoke.txt b/evidence/smoke.txt new file mode 100644 index 0000000..04938cf Binary files /dev/null and b/evidence/smoke.txt differ diff --git a/evidence/student-tests.txt b/evidence/student-tests.txt new file mode 100644 index 0000000..ea2f5f9 Binary files /dev/null and b/evidence/student-tests.txt differ diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..b34c068 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,8 @@ +fastapi==0.115.4 +uvicorn==0.32.0 +sqlalchemy==2.0.36 +asyncpg==0.30.0 +redis==5.2.0 +passlib[bcrypt]==1.7.4 +bcrypt==4.0.1 +python-dotenv==1.0.1 \ No newline at end of file diff --git a/scripts/generate_10k.py b/scripts/generate_10k.py new file mode 100644 index 0000000..99aefa9 --- /dev/null +++ b/scripts/generate_10k.py @@ -0,0 +1,34 @@ +import sys, os, subprocess +sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..', 'tests'))) +from client import Client + +def main(): + c = Client() + # Создаем одного пользователя и один чат через API + alice, bob, eve, chat = c.bootstrap() + chat_id = chat['id'] + alice_id = alice['id'] + print(f"Чат создан: {chat_id}") + print("Генерируем 10000 сообщений напрямую в PostgreSQL (это займет пару секунд)...") + + # SQL-запрос, который создаст 10 000 строк за один раз + sql = f""" + INSERT INTO messages (id, chat_id, sender_id, text, created_at) + SELECT + gen_random_uuid(), + '{chat_id}'::uuid, + '{alice_id}'::uuid, + 'Bulk message ' || i, + now() - interval '1 second' * (10000 - i) + FROM generate_series(1, 10000) AS i; + """ + + subprocess.run( + ["docker", "compose", "exec", "-T", "db", "psql", "-U", "user", "-d", "messenger", "-c", sql], + check=True + ) + print("Готово! 10000 сообщений добавлено.") + print(f"ID чата для EXPLAIN: {chat_id}") + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/scripts/restart.cmd b/scripts/restart.cmd new file mode 100644 index 0000000..d728bce --- /dev/null +++ b/scripts/restart.cmd @@ -0,0 +1 @@ +docker compose restart \ No newline at end of file diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100644 index 0000000..e6cfbc5 --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,3 @@ +#!/bin/sh +set -eu +docker compose restart \ No newline at end of file diff --git a/scripts/test_redis_down.py b/scripts/test_redis_down.py new file mode 100644 index 0000000..767ea44 --- /dev/null +++ b/scripts/test_redis_down.py @@ -0,0 +1,29 @@ +import subprocess +import time +import sys +import os +sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..', 'tests'))) +from client import Client, Failure + +def main(): + print("Stopping Redis...") + # stdout и stderr в DEVNULL, чтобы PowerShell не ругался на вывод Docker + subprocess.run(["docker", "compose", "stop", "redis"], check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) + time.sleep(2) + + c = Client() + try: + # Пытаемся получить профиль с фейковым токеном. + # Так как Redis лежит, сервер должен попытаться прочитать сессию, + # поймать ошибку RedisError и вернуть 503, а не упасть с 500. + c.call('GET', '/api/v1/users/me', 503, headers={'Authorization': 'Bearer fake_token'}) + print("PASS: Redis is down, API correctly returned 503") + except Failure as e: + print(f"FAIL: {e}") + sys.exit(1) + finally: + print("Starting Redis back...") + subprocess.run(["docker", "compose", "start", "redis"], check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/src/__init__.py b/src/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/__main__.py b/src/__main__.py new file mode 100644 index 0000000..04a4571 --- /dev/null +++ b/src/__main__.py @@ -0,0 +1,23 @@ +"""Entry point: uvicorn as PID 1 with env-driven host/port and graceful shutdown.""" +import os + +import uvicorn + +from .main import app + + +def main() -> None: + host = os.environ.get("APP_HOST", "0.0.0.0") + port = int(os.environ.get("APP_PORT", "8080")) + uvicorn.run( + app, + host=host, + port=port, + log_level="info", + access_log=True, + timeout_graceful_shutdown=5, + ) + + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/src/auth.py b/src/auth.py new file mode 100644 index 0000000..9cbee34 --- /dev/null +++ b/src/auth.py @@ -0,0 +1,27 @@ +import os +import secrets +import redis.asyncio as redis +from passlib.context import CryptContext + +pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto") +CACHE_URL = os.environ.get("CACHE_URL", "redis://localhost:6379/0") +SESSION_TTL_SECONDS = int(os.environ.get("SESSION_TTL_SECONDS", "3600")) + +redis_client = redis.from_url(CACHE_URL, decode_responses=True) + +def hash_password(password: str) -> str: + return pwd_context.hash(password) + +def verify_password(plain_password: str, hashed_password: str) -> bool: + return pwd_context.verify(plain_password, hashed_password) + +async def create_session(user_id: str) -> str: + token = secrets.token_urlsafe(32) + await redis_client.setex(f"session:{token}", SESSION_TTL_SECONDS, user_id) + return token + +async def get_user_id_by_token(token: str) -> str | None: + return await redis_client.get(f"session:{token}") + +async def delete_session(token: str) -> None: + await redis_client.delete(f"session:{token}") \ No newline at end of file diff --git a/src/db.py b/src/db.py new file mode 100644 index 0000000..6ae1574 --- /dev/null +++ b/src/db.py @@ -0,0 +1,55 @@ +import os +from datetime import datetime, timezone +from typing import List +from uuid import UUID, uuid4 + +from sqlalchemy import String, ForeignKey, DateTime, Index +from sqlalchemy.dialects.postgresql import UUID as PG_UUID +from sqlalchemy.ext.asyncio import create_async_engine, async_sessionmaker +from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column, relationship + +DATABASE_URL = os.environ.get("DATABASE_URL", "postgresql+asyncpg://user:password@localhost:5432/messenger") +engine = create_async_engine(DATABASE_URL, echo=False) +async_session = async_sessionmaker(engine, expire_on_commit=False) + +class Base(DeclarativeBase): + pass + +class User(Base): + __tablename__ = "users" + id: Mapped[UUID] = mapped_column(PG_UUID(as_uuid=True), primary_key=True, default=uuid4) + username: Mapped[str] = mapped_column(String(32), unique=True, index=True) + display_name: Mapped[str] = mapped_column(String(100)) + password_hash: Mapped[str] = mapped_column(String(255)) + created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), default=lambda: datetime.now(timezone.utc)) + +class Chat(Base): + __tablename__ = "chats" + id: Mapped[UUID] = mapped_column(PG_UUID(as_uuid=True), primary_key=True, default=uuid4) + title: Mapped[str] = mapped_column(String(100)) + created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), default=lambda: datetime.now(timezone.utc)) + members: Mapped[List["ChatMember"]] = relationship(back_populates="chat", lazy="selectin") + +class ChatMember(Base): + __tablename__ = "chat_members" + chat_id: Mapped[UUID] = mapped_column(PG_UUID(as_uuid=True), ForeignKey("chats.id", ondelete="CASCADE"), primary_key=True) + user_id: Mapped[UUID] = mapped_column(PG_UUID(as_uuid=True), ForeignKey("users.id", ondelete="CASCADE"), primary_key=True) + chat: Mapped["Chat"] = relationship(back_populates="members") + user: Mapped["User"] = relationship() + +class Message(Base): + __tablename__ = "messages" + id: Mapped[UUID] = mapped_column(PG_UUID(as_uuid=True), primary_key=True, default=uuid4) + chat_id: Mapped[UUID] = mapped_column(PG_UUID(as_uuid=True), ForeignKey("chats.id", ondelete="CASCADE"), index=True) + sender_id: Mapped[UUID] = mapped_column(PG_UUID(as_uuid=True), ForeignKey("users.id")) + text: Mapped[str] = mapped_column(String(4000)) + created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), default=lambda: datetime.now(timezone.utc)) + + # Составной индекс для быстрой курсорной пагинации (EXPLAIN покажет Index Scan) + __table_args__ = ( + Index('ix_messages_chat_created_id', 'chat_id', 'created_at', 'id'), + ) + +async def init_db(): + async with engine.begin() as conn: + await conn.run_sync(Base.metadata.create_all) \ No newline at end of file diff --git a/src/main.py b/src/main.py new file mode 100644 index 0000000..f1f982d --- /dev/null +++ b/src/main.py @@ -0,0 +1,296 @@ +from __future__ import annotations +import base64 +import re +import uuid +from contextlib import asynccontextmanager +from datetime import datetime, timezone, timedelta +from typing import Optional + +from fastapi import Depends, FastAPI, Request, Query +from fastapi.exceptions import RequestValidationError +from fastapi.responses import JSONResponse +from fastapi.security import HTTPBasic, HTTPBasicCredentials, HTTPBearer, HTTPAuthorizationCredentials +from pydantic import BaseModel, ConfigDict, Field +from sqlalchemy import select, and_, or_ +from sqlalchemy.exc import OperationalError +from starlette.exceptions import HTTPException as StarletteHTTPException +from redis.exceptions import RedisError + +from .db import init_db, async_session, User, Chat, ChatMember, Message +from .auth import hash_password, verify_password, create_session, get_user_id_by_token, delete_session + +USERNAME_RE = re.compile(r"^[a-z0-9_]{3,32}$") + +def now_iso(dt: datetime = None) -> str: + if not dt: + dt = datetime.now(timezone.utc) + return dt.strftime("%Y-%m-%dT%H:%M:%S.%f")[:-3] + "Z" + +def error_payload(request_id: str, code: str, message: str) -> dict: + return {"error": {"code": code, "message": message, "request_id": request_id}} + +class ApiError(Exception): + def __init__(self, status: int, code: str, message: str): + self.status = status + self.code = code + self.message = message + super().__init__(message) + +# --- Курсоры для пагинации (с точностью до микросекунд) --- +def _encode_cursor(scope: str, created_at: datetime, obj_id: uuid.UUID) -> str: + raw = f"{scope}|{created_at.isoformat()}|{obj_id}".encode("utf-8") + return base64.urlsafe_b64encode(raw).rstrip(b"=").decode("ascii") + +def _decode_cursor(cursor: str) -> tuple[str, datetime, uuid.UUID]: + try: + padded = cursor + "=" * (-len(cursor) % 4) + raw = base64.urlsafe_b64decode(padded).decode("utf-8") + scope, dt_str, obj_id_str = raw.split("|", 2) + dt = datetime.fromisoformat(dt_str) + return scope, dt, uuid.UUID(obj_id_str) + except Exception: + raise ApiError(400, "invalid_request", "invalid cursor") + +# --- Схемы --- +class CreateUser(BaseModel): + model_config = ConfigDict(extra="forbid") + username: str + display_name: str + password: str = Field(min_length=12, max_length=128) + +class CreateChat(BaseModel): + model_config = ConfigDict(extra="forbid") + title: str + member_ids: list[uuid.UUID] + +class CreateMessage(BaseModel): + model_config = ConfigDict(extra="forbid") + text: str = Field(min_length=1, max_length=4000) + +@asynccontextmanager +async def lifespan(app: FastAPI): + await init_db() + yield + +app = FastAPI(title="Messenger", version="1.2.0", lifespan=lifespan) +security_basic = HTTPBasic(auto_error=False) +security_bearer = HTTPBearer(auto_error=False) + +@app.middleware("http") +async def request_id_middleware(request: Request, call_next): + request_id = request.headers.get("X-Request-Id") or str(uuid.uuid4()) + request.state.request_id = request_id + response = await call_next(request) + response.headers["X-Request-Id"] = request_id + return response + +def _rid(request: Request) -> str: + return getattr(request.state, "request_id", None) or str(uuid.uuid4()) + +# --- Обработчики ошибок --- +@app.exception_handler(ApiError) +async def api_error_handler(request: Request, exc: ApiError): + headers = {} + if exc.status == 401: + if request.url.path == "/api/v1/auth/sessions": + headers["WWW-Authenticate"] = 'Basic realm="messenger", charset="UTF-8"' + else: + headers["WWW-Authenticate"] = 'Bearer realm="messenger"' + return JSONResponse(status_code=exc.status, content=error_payload(_rid(request), exc.code, exc.message), headers=headers) + +@app.exception_handler(RequestValidationError) +async def validation_error_handler(request: Request, exc: RequestValidationError): + return JSONResponse(status_code=400, content=error_payload(_rid(request), "invalid_request", "invalid request")) + +@app.exception_handler(StarletteHTTPException) +async def http_exception_handler(request: Request, exc: StarletteHTTPException): + return JSONResponse(status_code=exc.status_code, content=error_payload(_rid(request), "not_found", str(exc.detail))) + +@app.exception_handler(RedisError) +@app.exception_handler(OperationalError) +async def dependency_error_handler(request: Request, exc: Exception): + # Если упала БД или Redis - отдаем 503, как требует контракт + return JSONResponse(status_code=503, content=error_payload(_rid(request), "unavailable", "dependency unavailable")) + +@app.exception_handler(Exception) +async def generic_exception_handler(request: Request, exc: Exception): + return JSONResponse(status_code=500, content=error_payload(_rid(request), "internal_error", "internal error")) + +# --- Зависимости --- +async def get_actor(credentials: HTTPAuthorizationCredentials = Depends(security_bearer)) -> dict: + if not credentials: + raise ApiError(401, "unauthorized", "missing token") + + user_id_str = await get_user_id_by_token(credentials.credentials) + if not user_id_str: + raise ApiError(401, "unauthorized", "invalid or expired token") + + async with async_session() as session: + user = await session.get(User, uuid.UUID(user_id_str)) + if not user: + raise ApiError(401, "unauthorized", "user not found") + return {"id": str(user.id), "username": user.username, "display_name": user.display_name, "created_at": now_iso(user.created_at)} + +# --- Роуты --- +@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) +async def register_user(payload: CreateUser): + if not USERNAME_RE.match(payload.username): + raise ApiError(400, "invalid_request", "invalid username") + + async with async_session() as session: + existing = await session.scalar(select(User).where(User.username == payload.username)) + if existing: + raise ApiError(409, "conflict", "username already exists") + + user = User(username=payload.username, display_name=payload.display_name, password_hash=hash_password(payload.password)) + session.add(user) + try: + await session.commit() + except Exception: + await session.rollback() + raise ApiError(409, "conflict", "username already exists") + + return {"id": str(user.id), "username": user.username, "display_name": user.display_name, "created_at": now_iso(user.created_at)} + +@app.post("/api/v1/auth/sessions", status_code=201) +async def create_session_endpoint(credentials: HTTPBasicCredentials = Depends(security_basic)): + if not credentials: + raise ApiError(401, "unauthorized", "missing credentials") + + async with async_session() as session: + user = await session.scalar(select(User).where(User.username == credentials.username)) + if not user or not verify_password(credentials.password, user.password_hash): + raise ApiError(401, "unauthorized", "invalid credentials") + + token = await create_session(str(user.id)) + expires_at = datetime.now(timezone.utc) + timedelta(seconds=3600) + return { + "token": token, + "token_type": "Bearer", + "expires_at": now_iso(expires_at), + "user": {"id": str(user.id), "username": user.username, "display_name": user.display_name, "created_at": now_iso(user.created_at)} + } + +@app.delete("/api/v1/auth/sessions/current", status_code=204) +async def logout(credentials: HTTPAuthorizationCredentials = Depends(security_bearer)): + if not credentials: + raise ApiError(401, "unauthorized", "missing token") + + user_id = await get_user_id_by_token(credentials.credentials) + if not user_id: + raise ApiError(401, "unauthorized", "invalid or expired token") + + await delete_session(credentials.credentials) + +@app.get("/api/v1/users/me") +async def current_user(actor: dict = Depends(get_actor)): + return actor + +@app.post("/api/v1/chats", status_code=201) +async def create_chat(payload: CreateChat, actor: dict = Depends(get_actor)): + member_ids = [str(u) for u in payload.member_ids] + if actor["id"] not in member_ids: + raise ApiError(400, "invalid_request", "creator must be a member") + if len(set(member_ids)) != len(member_ids): + raise ApiError(400, "invalid_request", "duplicate members") + + async with async_session() as session: + users = await session.scalars(select(User.id).where(User.id.in_([uuid.UUID(m) for m in member_ids]))) + if len(list(users)) != len(set(member_ids)): + raise ApiError(400, "invalid_request", "unknown member") + + chat = Chat(title=payload.title) + session.add(chat) + await session.flush() + + for mid in member_ids: + session.add(ChatMember(chat_id=chat.id, user_id=uuid.UUID(mid))) + + await session.commit() + return {"id": str(chat.id), "title": chat.title, "member_ids": member_ids, "created_at": now_iso(chat.created_at)} + +@app.get("/api/v1/chats") +async def list_chats(limit: int = Query(50, ge=1, le=100), cursor: Optional[str] = None, actor: dict = Depends(get_actor)): + async with async_session() as session: + stmt = select(Chat).join(ChatMember).where(ChatMember.user_id == uuid.UUID(actor["id"])) + if cursor: + scope, c_dt, c_id = _decode_cursor(cursor) + if scope != "chats": + raise ApiError(400, "invalid_request", "invalid cursor scope") + stmt = stmt.where(or_( + Chat.created_at > c_dt, + and_(Chat.created_at == c_dt, Chat.id > c_id) + )) + + stmt = stmt.order_by(Chat.created_at.asc(), Chat.id.asc()).limit(limit + 1) + chats = (await session.scalars(stmt)).unique().all() + + has_more = len(chats) > limit + page = chats[:limit] + next_cursor = _encode_cursor("chats", page[-1].created_at, page[-1].id) if has_more and page else None + + items = [] + for c in page: + items.append({ + "id": str(c.id), + "title": c.title, + "created_at": now_iso(c.created_at), + "member_ids": [str(m.user_id) for m in c.members] # Теперь участники возвращаются корректно + }) + + return {"items": items, "next_cursor": next_cursor} + +@app.get("/api/v1/chats/{chat_id}") +async def get_chat(chat_id: uuid.UUID, actor: dict = Depends(get_actor)): + async with async_session() as session: + chat = await session.scalar(select(Chat).join(ChatMember).where(Chat.id == chat_id, ChatMember.user_id == uuid.UUID(actor["id"]))) + if not chat: + raise ApiError(404, "not_found", "chat not found") + return {"id": str(chat.id), "title": chat.title, "member_ids": [str(m.user_id) for m in chat.members], "created_at": now_iso(chat.created_at)} + +@app.post("/api/v1/chats/{chat_id}/messages", status_code=201) +async def post_message(chat_id: uuid.UUID, payload: CreateMessage, actor: dict = Depends(get_actor)): + async with async_session() as session: + member = await session.scalar(select(ChatMember).where(and_(ChatMember.chat_id == chat_id, ChatMember.user_id == uuid.UUID(actor["id"])))) + if not member: + raise ApiError(404, "not_found", "chat not found") + + msg = Message(chat_id=chat_id, sender_id=uuid.UUID(actor["id"]), text=payload.text) + session.add(msg) + await session.commit() + return {"id": str(msg.id), "chat_id": str(msg.chat_id), "sender_id": str(msg.sender_id), "text": msg.text, "created_at": now_iso(msg.created_at)} + +@app.get("/api/v1/chats/{chat_id}/messages") +async def get_messages(chat_id: uuid.UUID, limit: int = Query(50, ge=1, le=100), cursor: Optional[str] = None, actor: dict = Depends(get_actor)): + async with async_session() as session: + member = await session.scalar(select(ChatMember).where(and_(ChatMember.chat_id == chat_id, ChatMember.user_id == uuid.UUID(actor["id"])))) + if not member: + raise ApiError(404, "not_found", "chat not found") + + stmt = select(Message).where(Message.chat_id == chat_id) + if cursor: + scope, c_dt, c_id = _decode_cursor(cursor) + if scope != str(chat_id): + raise ApiError(400, "invalid_request", "invalid cursor scope") + stmt = stmt.where(or_( + Message.created_at > c_dt, + and_(Message.created_at == c_dt, Message.id > c_id) + )) + + stmt = stmt.order_by(Message.created_at.asc(), Message.id.asc()).limit(limit + 1) + messages = (await session.scalars(stmt)).all() + + has_more = len(messages) > limit + page = messages[:limit] + next_cursor = _encode_cursor(str(chat_id), page[-1].created_at, page[-1].id) if has_more and page else None + + items = [{"id": str(m.id), "chat_id": str(m.chat_id), "sender_id": str(m.sender_id), "text": m.text, "created_at": now_iso(m.created_at)} for m in page] + return {"items": items, "next_cursor": next_cursor} \ No newline at end of file diff --git a/student-tests/README.md b/student-tests/README.md new file mode 100644 index 0000000..fc93bb8 --- /dev/null +++ b/student-tests/README.md @@ -0,0 +1,12 @@ +# мои тесты (уровень 4) + +Требуют запущенного сервера. Одна команда: + + python student-tests/run.py --base-url http://localhost:8080 + +Проверяется: невалидный JSON и лишние поля; отсутствующий/несуществующий +X-User-Id; доступ к чужому чату и его истории; пустой/пробельный/слишком +длинный текст; дубликат username; member_ids без вызывающего / с дублями / +с неизвестным; многостраничный обход cursor без пропусков и повторов; +привязка cursor к чату; конкурентный тест 10×10 = 100 уникальных. + diff --git a/student-tests/run.py b/student-tests/run.py new file mode 100644 index 0000000..82c2745 --- /dev/null +++ b/student-tests/run.py @@ -0,0 +1,64 @@ +import sys +import threading +import uuid +from concurrent.futures import ThreadPoolExecutor +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[1] +sys.path.insert(0, str(ROOT / "tests")) + +from client import Client, Failure, arguments, check, run + +def t_wrong_password(c: Client) -> None: + # Создаем пользователя + u = c.user("wrongpass") + # Пытаемся войти с неверным паролем + import base64 + bad_cred = base64.b64encode((u['registration']['username'] + ':wrongpassword123').encode()).decode() + c.call('POST', '/api/v1/auth/sessions', 401, headers={'Authorization': 'Basic ' + bad_cred}) + +def t_logout(c: Client) -> None: + u = c.user("logout") + # Успешный logout + c.call('DELETE', '/api/v1/auth/sessions/current', 204, actor=u) + # Повторный запрос с отозванным токеном должен дать 401 + c.call('GET', '/api/v1/users/me', 401, actor=u) + +def t_race_registration(c: Client) -> None: + username = 'race_' + uuid.uuid4().hex[:6] + barrier = threading.Barrier(2) + results = [] + + def register(): + local = Client() + barrier.wait() + try: + local.call('POST', '/api/v1/users', 201, body={'username': username, 'display_name': 'Race', 'password': 'ValidPassword123'}) + results.append(201) + except Failure as e: + if 'expected [201]' in str(e): + results.append(409) + else: + raise + + with ThreadPoolExecutor(max_workers=2) as pool: + list(pool.map(lambda _: register(), range(2))) + + check(201 in results and 409 in results, f"Race condition failed: {results}") + +CASES = [ + ("wrong_password", t_wrong_password), + ("logout", t_logout), + ("race_registration", t_race_registration), +] + +def main() -> None: + args = arguments("Student tests for lab2") + client = Client(args.base_url, args.ca_file) + for name, fn in CASES: + fn(client) + print(f"PASS {name}") + print("PASS: lab2 student tests") + +if __name__ == "__main__": + run(main) \ No newline at end of file