diff --git a/.env.example b/.env.example index 714c8076..657f862d 100644 --- a/.env.example +++ b/.env.example @@ -1,11 +1,16 @@ # Copy to .env for your LOCAL synthetic test environment; never commit .env. -# These are logical interface suggestions; map actual framework names in REPORT.md. APP_HOST=0.0.0.0 APP_PORT=8080 APP_ENV=lab SESSION_TTL_SECONDS=3600 -# Choose credentials locally. File paths contain no secret values. +SESSION_STORE=redis +# Compose mounts these secret files into the API container: DATABASE_URL_FILE=/run/secrets/database_url -# Optional on 3, required use on 4 in lab2; Redis OR Valkey: -SESSION_STORE=postgres CACHE_URL_FILE=/run/secrets/cache_url +# Optional direct URLs for host-side tools (scripts/explain_messages.py): +# DATABASE_URL=postgresql://messenger:PASSWORD@127.0.0.1:5432/messenger +# CACHE_URL=redis://127.0.0.1:6379/0 +DB_CONNECT_TIMEOUT=5 +DB_POOL_MIN=1 +DB_POOL_MAX=10 +REDIS_SOCKET_TIMEOUT=3 diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..9b8bed51 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,27 @@ +# Закреплённый runtime-образ (Python интерпретируемый — один stage). +FROM python:3.12.7-slim-bookworm + +ENV PYTHONDONTWRITEBYTECODE=1 \ + PYTHONUNBUFFERED=1 \ + APP_HOST=0.0.0.0 \ + APP_PORT=8080 + +WORKDIR /app + +RUN groupadd --system app && useradd --system --gid app --home /app --shell /usr/sbin/nologin app + +COPY requirements.txt . +RUN pip install --no-cache-dir -r requirements.txt + +COPY app ./app +COPY migrations ./migrations + +USER app + +EXPOSE 8080 + +HEALTHCHECK --interval=5s --timeout=3s --start-period=15s --retries=5 \ + CMD python -c "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=2)" + +# PID 1 = uvicorn; SIGTERM обрабатывается lifespan'ом приложения. +CMD ["python", "-m", "uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8080"] diff --git a/Makefile b/Makefile index 9ecb223e..55b5b24d 100644 --- a/Makefile +++ b/Makefile @@ -4,10 +4,10 @@ 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 test-own load test-persistence secrets up down help: - @echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes" + @echo "check: offline structure; validate: OpenAPI; test: smoke; test-own: student; test-persistence: restart hook" check: $(PYTHON) scripts/check_contract.py @@ -18,9 +18,21 @@ validate: test: $(PYTHON) tests/smoke.py --base-url "$(BASE_URL)" $(TLS_ARGS) +test-own: + $(PYTHON) tests/own.py --base-url "$(BASE_URL)" $(TLS_ARGS) + load: $(PYTHON) tests/load.py --base-url "$(BASE_URL)" $(TLS_ARGS) 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) + +secrets: + @echo "Run: powershell -File scripts/make_secrets.ps1 OR sh scripts/make_secrets.sh" + +up: + docker compose --env-file .env up -d --build + +down: + docker compose --env-file .env down diff --git a/REPORT.md b/REPORT.md index e42f2b05..340075d2 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,112 @@ # Отчёт — лабораторная 2 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO -- Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +- Автор, группа: Соболев Даниил Романович, БПИ2302 +- Целевая оценка; выбранный трек 5, если нужен: 4 +- Commit/PR: 3c5af42f24 +- Использованные источники, библиотеки и помощь ИИ: FastAPI, Uvicorn, Pydantic, psycopg3+pool, redis-py, argon2-cffi; контракт курса; помощь ИИ при переносе на PostgreSQL/сессии/Redis ## Запуск из чистого clone -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +**Prerequisites:** Docker / Docker Compose; Python 3.9+ для `make test` / `make test-own` (stdlib). + +```sh +cp .env.example .env +# Windows: +powershell -File scripts/make_secrets.ps1 +# Unix: +# sh scripts/make_secrets.sh + +docker compose --env-file .env config --quiet +docker compose --env-file .env up -d --build +``` + +Ожидание готовности: `GET http://localhost:8080/health/ready` → `{"status":"ok"}` (миграции применяются при старте API). + +```sh +make test +# Windows: py -3 tests\smoke.py --base-url http://localhost:8080 +make test-own +# Unix / Git Bash: +# chmod +x scripts/restart.sh && make test-persistence ACTION_SCRIPT=scripts/restart.sh +# Windows (cmd): +py -3 tests\resilience.py --mode persistence --action-script scripts\restart.cmd --base-url http://localhost:8080 +``` + +Проверка expiry (отдельный прогон с коротким TTL): + +```sh +# SESSION_TTL_SECONDS=5 в env-файле, затем recreate api и: +# SESSION_TTL_SECONDS=5 py -3 tests\own.py +# или: py -3 scripts\test_expiry_raw.py +``` + +EXPLAIN индекса истории (≥10 000 сообщений): + +```sh +# из secrets/database_url заменить хост postgres → 127.0.0.1 +set DATABASE_URL=postgresql://messenger:PASSWORD@127.0.0.1:15432/messenger +set CACHE_URL=redis://127.0.0.1:6379/0 +py -3 scripts/explain_messages.py +# результат: evidence/explain.txt +``` + +Безопасная остановка (volumes сохраняются): + +```sh +docker compose --env-file .env stop +# или down без -v +docker compose --env-file .env down +``` + +Намеренное удаление учебных данных: + +```sh +docker compose --env-file .env down -v +``` + +Версии: `python:3.12.7-slim-bookworm`, `postgres:16.4-bookworm`, `redis:7.4.1-bookworm`; зависимости в `requirements.txt`. ## Архитектура и решения -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +``` +Клиент → API (FastAPI) → PostgreSQL (источник истины: users/chats/members/messages) + → Redis (opaque Bearer-сессии, TTL + AOF everysec) +``` + +- **Перенос из lab1:** контракт users/chats/messages, keyset-cursor, формат ошибок, non-root Dockerfile, X-Request-Id. +- **Изменения lab2:** `password` + Argon2id; `POST /auth/sessions` (Basic); Bearer вместо `X-User-Id`; сессии в Redis. +- **Источник истины данных:** PostgreSQL. Сессии — Redis (единственное хранилище сессий) с AOF, чтобы переживать `compose restart`. +- **Транзакции:** создание чата = `INSERT chats` + `INSERT chat_members` в одной транзакции; при неизвестном участнике — rollback. +- **Пул/таймауты:** `psycopg_pool.ConnectionPool` (min/max), `connect_timeout`; Redis `socket_connect_timeout` / `socket_timeout`. +- **Индекс истории:** `messages (chat_id, created_at, id)` под keyset `WHERE chat_id=$1 AND (created_at,id)>($2,$3) ORDER BY created_at,id LIMIT n`. +- **Ready:** live = процесс; ready = accepting + ping Postgres + ping Redis. +- **Конфиг:** `.env` + secret-файлы `DATABASE_URL_FILE` / `CACHE_URL_FILE` (см. `.env.example`). ## Доказательства критериев | Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | | --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | - -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +| Публичный smoke | `make test` | PASS: lab2 public API scenario | `evidence/smoke.txt` | +| Persistence + сессия | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | PASS: token и сообщение после restart | `evidence/persistence.txt` | +| Собственные тесты 4 | `make test-own` | wrong password, logout, race username, concurrency, redis-down | `evidence/own.txt` | +| Expiry короткого TTL | `SESSION_TTL_SECONDS=2` + `make test-own` | 401 после TTL | `evidence/own.txt` | +| EXPLAIN ≥10k | `scripts/explain_messages.py` | Index Scan по `messages_chat_created_id_idx` | `evidence/explain.txt` | +| Миграции идемпотентны | повторный `up` / restart API | без дублей schema_migrations | логи API | ## Эксперименты и отказы -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. - | Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | | --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +| `scripts/restart.sh` (API+Postgres+Redis, volumes) | те же данные и Bearer | persistence PASS | до готовности ≤90 с; без потери при сохранённых volumes | +| `docker compose stop redis` | ready 503; нет анонимного доступа | own redis-down PASS | после `start redis` ready снова ok | +| Гонка 8× одинаковый username | 1×201 + 7×409 | own username race PASS | без дублей username | +| 10×10 POST сообщений | 100 уникальных | own concurrency PASS | без потери подтверждённых | + +Ограничения измерения: closed-loop smoke/own на localhost; `tests/load.py` — throughput HTTP-подтверждений, не точный счётчик COMMIT. ## Ограничения и следующие шаги -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +- Один Docker-host: нет HA Postgres/Redis/API. +- Сессии только в Redis: flush/AOF-сбой без Postgres-backup сессий = повторный login (данные чатов в PG сохраняются). +- Нет lab3 LB/идемпотентности, вложений, TLS. +- Следующий шаг курса: горизонтальное масштабирование и общий session store. diff --git a/app/__init__.py b/app/__init__.py new file mode 100644 index 00000000..3fca08ca --- /dev/null +++ b/app/__init__.py @@ -0,0 +1 @@ +"""Messenger API lab2: PostgreSQL + Bearer sessions + Redis.""" diff --git a/app/api.py b/app/api.py new file mode 100644 index 00000000..3bd7c33e --- /dev/null +++ b/app/api.py @@ -0,0 +1,169 @@ +"""HTTP-слой: тонкие обработчики (SRP: только транспорт).""" +import logging +from typing import Optional + +from fastapi import APIRouter, Depends, Header, Query, Request, Response + +from app.auth import require_actor +from app.db import Database +from app.errors import unavailable, unsupported_media +from app.schemas import CreateChatBody, CreateMessageBody, CreateUserBody +from app.services import AuthService, ChatService, MessageService, UserService +from app.sessions import SessionStore + +logger = logging.getLogger("messenger") + +router = APIRouter() + + +def _state(request: Request): + db: Database = request.app.state.db + sessions: SessionStore = request.app.state.sessions + return db, sessions + + +def require_json_content_type(request: Request) -> None: + content_type = request.headers.get("content-type", "") + media = content_type.split(";")[0].strip().lower() + if media != "application/json": + raise unsupported_media() + + +def _require_accepting(db: Database) -> None: + if not db.accepting: + raise unavailable("Сервер завершает работу") + + +@router.get("/health/live") +def live(): + return {"status": "ok"} + + +@router.get("/health/ready") +def ready(request: Request): + db, sessions = _state(request) + if not db.ready or not db.accepting: + raise unavailable("Не готов принимать трафик") + if not db.ping() or not sessions.ping(): + raise unavailable("Зависимость недоступна") + return {"status": "ok"} + + +@router.post("/api/v1/users", status_code=201) +def create_user( + request: Request, + body: CreateUserBody, + _: None = Depends(require_json_content_type), +): + db, _sessions = _state(request) + _require_accepting(db) + return UserService(db).create(body.model_dump()) + + +@router.post("/api/v1/auth/sessions", status_code=201) +def create_session( + request: Request, + authorization: Optional[str] = Header(default=None), +): + db, sessions = _state(request) + _require_accepting(db) + return AuthService(db, sessions).create_session(authorization) + + +@router.delete("/api/v1/auth/sessions/current", status_code=204) +def revoke_session( + request: Request, + authorization: Optional[str] = Header(default=None), +): + db, sessions = _state(request) + _require_accepting(db) + _actor, token = require_actor(db, sessions, authorization) + AuthService(db, sessions).logout(token) + return Response(status_code=204) + + +@router.get("/api/v1/users/me") +def current_user( + request: Request, + authorization: Optional[str] = Header(default=None), +): + db, sessions = _state(request) + _require_accepting(db) + actor, _token = require_actor(db, sessions, authorization) + return actor.to_dict() + + +@router.post("/api/v1/chats", status_code=201) +def create_chat( + request: Request, + body: CreateChatBody, + authorization: Optional[str] = Header(default=None), + _: None = Depends(require_json_content_type), +): + db, sessions = _state(request) + _require_accepting(db) + actor, _token = require_actor(db, sessions, authorization) + return ChatService(db).create(actor, body.model_dump()) + + +@router.get("/api/v1/chats") +def list_chats( + request: Request, + authorization: Optional[str] = Header(default=None), + limit: Optional[str] = Query(default=None), + cursor: Optional[str] = Query(default=None), +): + db, sessions = _state(request) + _require_accepting(db) + actor, _token = require_actor(db, sessions, authorization) + return ChatService(db).list_for_user(actor, limit, cursor) + + +@router.get("/api/v1/chats/{chat_id}") +def get_chat( + chat_id: str, + request: Request, + authorization: Optional[str] = Header(default=None), +): + db, sessions = _state(request) + _require_accepting(db) + actor, _token = require_actor(db, sessions, authorization) + return ChatService(db).get_for_member(actor, chat_id).to_dict() + + +@router.post("/api/v1/chats/{chat_id}/messages", status_code=201) +def create_message( + chat_id: str, + request: Request, + body: CreateMessageBody, + authorization: Optional[str] = Header(default=None), + _: None = Depends(require_json_content_type), +): + db, sessions = _state(request) + _require_accepting(db) + actor, _token = require_actor(db, sessions, authorization) + chats = ChatService(db) + chat = chats.get_for_member(actor, chat_id) + result = MessageService(db).create(actor, chat, body.model_dump()) + logger.info( + "message created chat_id=%s sender_id=%s message_id=%s", + chat.id, + actor.id, + result["id"], + ) + return result + + +@router.get("/api/v1/chats/{chat_id}/messages") +def list_messages( + chat_id: str, + request: Request, + authorization: Optional[str] = Header(default=None), + limit: Optional[str] = Query(default=None), + cursor: Optional[str] = Query(default=None), +): + db, sessions = _state(request) + _require_accepting(db) + actor, _token = require_actor(db, sessions, authorization) + chat = ChatService(db).get_for_member(actor, chat_id) + return MessageService(db).list_for_chat(chat, limit, cursor) diff --git a/app/auth.py b/app/auth.py new file mode 100644 index 00000000..a7b8e3c2 --- /dev/null +++ b/app/auth.py @@ -0,0 +1,64 @@ +"""Разбор Basic/Bearer и проверка сессии.""" +from __future__ import annotations + +import base64 +import binascii +from typing import Optional, Tuple + +from app.db import Database +from app.errors import unauthorized +from app.models import User +from app.sessions import SessionStore +from app.validation import USERNAME_RE + +BASIC_CHALLENGE = 'Basic realm="messenger", charset="UTF-8"' +BEARER_CHALLENGE = 'Bearer realm="messenger"' + + +def parse_basic(authorization: Optional[str]) -> Tuple[str, str]: + if not authorization or not authorization.startswith("Basic "): + raise unauthorized("Требуется Basic-аутентификация", challenge=BASIC_CHALLENGE) + raw = authorization[6:].strip() + if not raw: + raise unauthorized("Требуется Basic-аутентификация", challenge=BASIC_CHALLENGE) + try: + decoded = base64.b64decode(raw, validate=True).decode("utf-8") + except (binascii.Error, UnicodeDecodeError, ValueError) as exc: + raise unauthorized("Неверные учётные данные", challenge=BASIC_CHALLENGE) from exc + if ":" not in decoded: + raise unauthorized("Неверные учётные данные", challenge=BASIC_CHALLENGE) + username, password = decoded.split(":", 1) + if not USERNAME_RE.fullmatch(username): + raise unauthorized("Неверные учётные данные", challenge=BASIC_CHALLENGE) + n = len(password) + if n < 12 or n > 128: + raise unauthorized("Неверные учётные данные", challenge=BASIC_CHALLENGE) + return username, password + + +def parse_bearer(authorization: Optional[str]) -> str: + if not authorization: + raise unauthorized(challenge=BEARER_CHALLENGE) + if authorization.startswith("Basic "): + raise unauthorized(challenge=BEARER_CHALLENGE) + if not authorization.startswith("Bearer "): + raise unauthorized(challenge=BEARER_CHALLENGE) + token = authorization[7:].strip() + if not token: + raise unauthorized(challenge=BEARER_CHALLENGE) + return token + + +def require_actor( + db: Database, + sessions: SessionStore, + authorization: Optional[str], +) -> Tuple[User, str]: + token = parse_bearer(authorization) + user_id = sessions.resolve(token) + if user_id is None: + raise unauthorized(challenge=BEARER_CHALLENGE) + user = db.get_user(user_id) + if user is None: + raise unauthorized(challenge=BEARER_CHALLENGE) + return user, token diff --git a/app/config.py b/app/config.py new file mode 100644 index 00000000..110b32df --- /dev/null +++ b/app/config.py @@ -0,0 +1,35 @@ +"""Конфигурация из окружения и secret-файлов.""" +from __future__ import annotations + +import os +from pathlib import Path + + +def _read_secret(file_env: str, direct_env: str) -> str: + path = os.environ.get(file_env, "").strip() + if path: + return Path(path).read_text(encoding="utf-8").strip() + value = os.environ.get(direct_env, "").strip() + if value: + return value + raise RuntimeError(f"Задайте {file_env} или {direct_env}") + + +class Settings: + def __init__(self) -> None: + self.host = os.environ.get("APP_HOST", "0.0.0.0") + self.port = int(os.environ.get("APP_PORT", "8080")) + self.env = os.environ.get("APP_ENV", "lab") + self.session_ttl_seconds = int(os.environ.get("SESSION_TTL_SECONDS", "3600")) + if self.session_ttl_seconds < 1: + raise RuntimeError("SESSION_TTL_SECONDS должен быть >= 1") + self.session_store = os.environ.get("SESSION_STORE", "redis").strip().lower() + self.database_url = _read_secret("DATABASE_URL_FILE", "DATABASE_URL") + self.cache_url = _read_secret("CACHE_URL_FILE", "CACHE_URL") + self.db_connect_timeout = float(os.environ.get("DB_CONNECT_TIMEOUT", "5")) + self.db_pool_min = int(os.environ.get("DB_POOL_MIN", "1")) + self.db_pool_max = int(os.environ.get("DB_POOL_MAX", "10")) + self.redis_socket_timeout = float(os.environ.get("REDIS_SOCKET_TIMEOUT", "3")) + + +settings = Settings() diff --git a/app/cursor.py b/app/cursor.py new file mode 100644 index 00000000..8b95223e --- /dev/null +++ b/app/cursor.py @@ -0,0 +1,27 @@ +"""Непрозрачный keyset-cursor: (created_at, id), привязан к ресурсу.""" +import base64 +import json + +from app.errors import invalid_request + + +def encode(resource_id: str, created_at: str, item_id: str) -> str: + payload = {"r": resource_id, "t": created_at, "i": item_id} + raw = json.dumps(payload, separators=(",", ":")).encode("utf-8") + return base64.urlsafe_b64encode(raw).decode("ascii") + + +def decode(cursor: str, expected_resource_id: str) -> tuple: + try: + raw = base64.urlsafe_b64decode(cursor.encode("ascii")) + payload = json.loads(raw.decode("utf-8")) + resource_id = payload["r"] + created_at = payload["t"] + item_id = payload["i"] + if not isinstance(resource_id, str) or not isinstance(created_at, str) or not isinstance(item_id, str): + raise ValueError("bad types") + except Exception as exc: + raise invalid_request("Неверный cursor") from exc + if resource_id != expected_resource_id: + raise invalid_request("Cursor относится к другому ресурсу") + return created_at, item_id diff --git a/app/db.py b/app/db.py new file mode 100644 index 00000000..e9e35f80 --- /dev/null +++ b/app/db.py @@ -0,0 +1,376 @@ +"""PostgreSQL pool, миграции и параметризованные запросы.""" +from __future__ import annotations + +import logging +from pathlib import Path +from typing import List, Optional, Sequence + +from psycopg import OperationalError +from psycopg.errors import UniqueViolation +from psycopg.rows import dict_row +from psycopg_pool import ConnectionPool + +from app.config import settings +from app.errors import unavailable +from app.models import Chat, Message, User +from app.timefmt import format_utc + +logger = logging.getLogger("messenger") + +MIGRATIONS_DIR = Path(__file__).resolve().parent.parent / "migrations" + + +class Database: + def __init__(self) -> None: + self.pool: Optional[ConnectionPool] = None + self.accepting = True + self.ready = False + + def open(self) -> None: + self.pool = ConnectionPool( + conninfo=settings.database_url, + min_size=settings.db_pool_min, + max_size=settings.db_pool_max, + timeout=settings.db_connect_timeout, + kwargs={ + "connect_timeout": max(1, int(settings.db_connect_timeout)), + "row_factory": dict_row, + }, + open=True, + ) + self.apply_migrations() + self.ready = True + logger.info("postgres pool ready; migrations applied") + + def close(self) -> None: + self.ready = False + self.accepting = False + if self.pool is not None: + self.pool.close() + self.pool = None + + def begin_shutdown(self) -> None: + self.accepting = False + self.ready = False + + def _require_pool(self) -> ConnectionPool: + if self.pool is None: + raise unavailable("База данных недоступна") + return self.pool + + def ping(self) -> bool: + try: + pool = self._require_pool() + with pool.connection() as conn: + conn.execute("SELECT 1") + return True + except Exception: + return False + + @staticmethod + def _split_sql(script: str) -> List[str]: + statements: List[str] = [] + buf: List[str] = [] + for line in script.splitlines(): + stripped = line.strip() + if not stripped or stripped.startswith("--"): + continue + buf.append(line) + if stripped.endswith(";"): + stmt = "\n".join(buf).strip() + if stmt: + statements.append(stmt) + buf = [] + tail = "\n".join(buf).strip() + if tail: + statements.append(tail) + return statements + + def apply_migrations(self) -> None: + pool = self._require_pool() + files = sorted(MIGRATIONS_DIR.glob("*.sql")) + with pool.connection() as conn: + conn.execute( + """ + CREATE TABLE IF NOT EXISTS schema_migrations ( + version TEXT PRIMARY KEY, + applied_at TIMESTAMPTZ NOT NULL DEFAULT now() + ) + """ + ) + for path in files: + version = path.name + row = conn.execute( + "SELECT 1 FROM schema_migrations WHERE version = %s", + (version,), + ).fetchone() + if row: + continue + statements = self._split_sql(path.read_text(encoding="utf-8")) + with conn.transaction(): + for stmt in statements: + conn.execute(stmt) + conn.execute( + "INSERT INTO schema_migrations (version) VALUES (%s)", + (version,), + ) + logger.info("applied migration %s", version) + + def _user_from_row(self, row: dict) -> User: + return User( + id=str(row["id"]), + username=row["username"], + display_name=row["display_name"], + created_at=format_utc(row["created_at"]), + password_hash=row.get("password_hash", ""), + ) + + def add_user(self, user: User) -> None: + pool = self._require_pool() + try: + with pool.connection() as conn: + conn.execute( + """ + INSERT INTO users (id, username, display_name, password_hash, created_at) + VALUES (%s, %s, %s, %s, %s::timestamptz) + """, + ( + user.id, + user.username, + user.display_name, + user.password_hash, + user.created_at, + ), + ) + except UniqueViolation as exc: + raise KeyError("username") from exc + except OperationalError as exc: + raise unavailable("База данных недоступна") from exc + + def get_user(self, user_id: str) -> Optional[User]: + pool = self._require_pool() + try: + with pool.connection() as conn: + row = conn.execute( + """ + SELECT id, username, display_name, password_hash, created_at + FROM users WHERE id = %s + """, + (user_id,), + ).fetchone() + except OperationalError as exc: + raise unavailable("База данных недоступна") from exc + return self._user_from_row(row) if row else None + + def get_user_by_username(self, username: str) -> Optional[User]: + pool = self._require_pool() + try: + with pool.connection() as conn: + row = conn.execute( + """ + SELECT id, username, display_name, password_hash, created_at + FROM users WHERE username = %s + """, + (username,), + ).fetchone() + except OperationalError as exc: + raise unavailable("База данных недоступна") from exc + return self._user_from_row(row) if row else None + + def users_exist(self, user_ids: Sequence[str]) -> bool: + if not user_ids: + return True + pool = self._require_pool() + try: + with pool.connection() as conn: + row = conn.execute( + "SELECT COUNT(*) AS c FROM users WHERE id = ANY(%s::uuid[])", + (list(user_ids),), + ).fetchone() + except OperationalError as exc: + raise unavailable("База данных недоступна") from exc + return int(row["c"]) == len(set(user_ids)) + + def add_chat(self, chat: Chat) -> None: + """Атомарно: чат + участники в одной транзакции.""" + pool = self._require_pool() + try: + with pool.connection() as conn: + with conn.transaction(): + # Повторная проверка участников внутри транзакции. + row = conn.execute( + "SELECT COUNT(*) AS c FROM users WHERE id = ANY(%s::uuid[])", + (list(chat.member_ids),), + ).fetchone() + if int(row["c"]) != len(set(chat.member_ids)): + raise ValueError("unknown member") + conn.execute( + """ + INSERT INTO chats (id, title, created_at) + VALUES (%s, %s, %s::timestamptz) + """, + (chat.id, chat.title, chat.created_at), + ) + for mid in chat.member_ids: + conn.execute( + """ + INSERT INTO chat_members (chat_id, user_id) + VALUES (%s, %s) + """, + (chat.id, mid), + ) + except ValueError: + raise + except OperationalError as exc: + raise unavailable("База данных недоступна") from exc + + def get_chat(self, chat_id: str) -> Optional[Chat]: + pool = self._require_pool() + try: + with pool.connection() as conn: + row = conn.execute( + "SELECT id, title, created_at FROM chats WHERE id = %s", + (chat_id,), + ).fetchone() + if not row: + return None + members = conn.execute( + """ + SELECT user_id FROM chat_members + WHERE chat_id = %s + ORDER BY user_id + """, + (chat_id,), + ).fetchall() + except OperationalError as exc: + raise unavailable("База данных недоступна") from exc + return Chat( + id=str(row["id"]), + title=row["title"], + member_ids=[str(m["user_id"]) for m in members], + created_at=format_utc(row["created_at"]), + ) + + def list_chats_for(self, user_id: str) -> List[Chat]: + pool = self._require_pool() + try: + with pool.connection() as conn: + rows = conn.execute( + """ + SELECT c.id, c.title, c.created_at + FROM chats c + JOIN chat_members m ON m.chat_id = c.id + WHERE m.user_id = %s + ORDER BY c.created_at ASC, c.id ASC + """, + (user_id,), + ).fetchall() + result: List[Chat] = [] + for row in rows: + members = conn.execute( + """ + SELECT user_id FROM chat_members + WHERE chat_id = %s + ORDER BY user_id + """, + (row["id"],), + ).fetchall() + result.append( + Chat( + id=str(row["id"]), + title=row["title"], + member_ids=[str(m["user_id"]) for m in members], + created_at=format_utc(row["created_at"]), + ) + ) + return result + except OperationalError as exc: + raise unavailable("База данных недоступна") from exc + + def add_message(self, message: Message) -> Message: + pool = self._require_pool() + try: + with pool.connection() as conn: + conn.execute( + """ + INSERT INTO messages (id, chat_id, sender_id, text, created_at) + VALUES (%s, %s, %s, %s, %s::timestamptz) + """, + ( + message.id, + message.chat_id, + message.sender_id, + message.text, + message.created_at, + ), + ) + except OperationalError as exc: + raise unavailable("База данных недоступна") from exc + return message + + def list_messages_page( + self, + chat_id: str, + limit: int, + after_created_at: Optional[str] = None, + after_id: Optional[str] = None, + ) -> List[Message]: + """Keyset page using index (chat_id, created_at, id).""" + pool = self._require_pool() + try: + with pool.connection() as conn: + if after_created_at is None: + rows = conn.execute( + """ + SELECT id, chat_id, sender_id, text, created_at + FROM messages + WHERE chat_id = %s + ORDER BY created_at ASC, id ASC + LIMIT %s + """, + (chat_id, limit), + ).fetchall() + else: + rows = conn.execute( + """ + SELECT id, chat_id, sender_id, text, created_at + FROM messages + WHERE chat_id = %s + AND (created_at, id) > (%s::timestamptz, %s::uuid) + ORDER BY created_at ASC, id ASC + LIMIT %s + """, + (chat_id, after_created_at, after_id, limit), + ).fetchall() + except OperationalError as exc: + raise unavailable("База данных недоступна") from exc + return [ + Message( + id=str(r["id"]), + chat_id=str(r["chat_id"]), + sender_id=str(r["sender_id"]), + text=r["text"], + created_at=format_utc(r["created_at"]), + ) + for r in rows + ] + + def explain_messages_page(self, chat_id: str, limit: int = 50) -> str: + pool = self._require_pool() + with pool.connection() as conn: + rows = conn.execute( + """ + EXPLAIN (ANALYZE, BUFFERS, FORMAT TEXT) + SELECT id, chat_id, sender_id, text, created_at + FROM messages + WHERE chat_id = %s + ORDER BY created_at ASC, id ASC + LIMIT %s + """, + (chat_id, limit), + ).fetchall() + # EXPLAIN text rows come as single-column dicts + lines = [] + for r in rows: + lines.append(next(iter(r.values()))) + return "\n".join(lines) diff --git a/app/errors.py b/app/errors.py new file mode 100644 index 00000000..57982dd1 --- /dev/null +++ b/app/errors.py @@ -0,0 +1,54 @@ +"""Единый формат ошибок API.""" +from typing import Optional + + +class AppError(Exception): + def __init__( + self, + status: int, + code: str, + message: str, + headers: Optional[dict] = None, + ) -> None: + self.status = status + self.code = code + self.message = message + self.headers = headers or {} + super().__init__(message) + + +def invalid_request(message: str = "Неверный запрос") -> AppError: + return AppError(400, "invalid_request", message) + + +def unauthorized( + message: str = "Требуется идентификация", + *, + challenge: str = 'Bearer realm="messenger"', +) -> AppError: + return AppError( + 401, + "unauthorized", + message, + headers={"WWW-Authenticate": challenge}, + ) + + +def not_found(message: str = "Объект не найден") -> AppError: + return AppError(404, "not_found", message) + + +def conflict(message: str = "Конфликт") -> AppError: + return AppError(409, "conflict", message) + + +def unsupported_media(message: str = "Неподдерживаемый Content-Type") -> AppError: + return AppError(415, "unsupported_media_type", message) + + +def unavailable(message: str = "Сервис недоступен") -> AppError: + return AppError(503, "unavailable", message) + + +def error_body(code: str, message: str, request_id: str) -> dict: + return {"error": {"code": code, "message": message, "request_id": request_id}} diff --git a/app/main.py b/app/main.py new file mode 100644 index 00000000..ae12c8aa --- /dev/null +++ b/app/main.py @@ -0,0 +1,112 @@ +"""Точка входа HTTP-приложения lab2.""" +import logging +import uuid +from contextlib import asynccontextmanager + +from fastapi import FastAPI, Request +from fastapi.exceptions import RequestValidationError +from fastapi.responses import JSONResponse +from starlette.middleware.base import BaseHTTPMiddleware + +from app.api import router +from app.db import Database +from app.errors import AppError, error_body +from app.sessions import SessionStore + +logging.basicConfig( + level=logging.INFO, + format="%(asctime)s %(levelname)s %(name)s %(message)s", +) +logger = logging.getLogger("messenger") + +db = Database() +sessions = SessionStore() + + +@asynccontextmanager +async def lifespan(_app: FastAPI): + logger.info("server starting; connecting to postgres/redis") + db.open() + sessions.open() + _app.state.db = db + _app.state.sessions = sessions + logger.info("dependencies ready") + yield + db.begin_shutdown() + sessions.close() + db.close() + logger.info("SIGTERM/shutdown: stop accepting, ready=false") + + +app = FastAPI(title="MTUSI Messenger lab2", lifespan=lifespan) +app.state.db = db +app.state.sessions = sessions +app.include_router(router) + + +class RequestIdMiddleware(BaseHTTPMiddleware): + async def dispatch(self, 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 + logger.info( + "%s %s -> %s request_id=%s", + request.method, + request.url.path, + response.status_code, + request_id, + ) + return response + + +app.add_middleware(RequestIdMiddleware) + + +@app.exception_handler(AppError) +async def app_error_handler(request: Request, exc: AppError): + request_id = getattr(request.state, "request_id", None) or str(uuid.uuid4()) + headers = {"X-Request-Id": request_id} + headers.update(exc.headers) + return JSONResponse( + status_code=exc.status, + content=error_body(exc.code, exc.message, request_id), + headers=headers, + ) + + +@app.exception_handler(RequestValidationError) +async def validation_handler(request: Request, _exc: RequestValidationError): + request_id = getattr(request.state, "request_id", None) or str(uuid.uuid4()) + return JSONResponse( + status_code=400, + content=error_body("invalid_request", "Неверный запрос", request_id), + headers={"X-Request-Id": request_id}, + ) + + +@app.exception_handler(Exception) +async def internal_handler(request: Request, exc: Exception): + request_id = getattr(request.state, "request_id", None) or str(uuid.uuid4()) + logger.exception("unhandled error request_id=%s", request_id) + return JSONResponse( + status_code=500, + content=error_body("internal_error", "Внутренняя ошибка", request_id), + headers={"X-Request-Id": request_id}, + ) + + +def run() -> None: + import uvicorn + from app.config import settings + + uvicorn.run( + "app.main:app", + host=settings.host, + port=settings.port, + log_level="info", + ) + + +if __name__ == "__main__": + run() diff --git a/app/models.py b/app/models.py new file mode 100644 index 00000000..9e4f08fc --- /dev/null +++ b/app/models.py @@ -0,0 +1,58 @@ +"""Доменные сущности (данные, без HTTP и без бизнес-правил).""" +import uuid +from dataclasses import dataclass +from typing import List + + +@dataclass +class User: + id: str + username: str + display_name: str + created_at: str + password_hash: str = "" + + def to_dict(self) -> dict: + return { + "id": self.id, + "username": self.username, + "display_name": self.display_name, + "created_at": self.created_at, + } + + +@dataclass +class Chat: + id: str + title: str + member_ids: List[str] + created_at: str + + def to_dict(self) -> dict: + return { + "id": self.id, + "title": self.title, + "member_ids": list(self.member_ids), + "created_at": self.created_at, + } + + +@dataclass +class Message: + id: str + chat_id: str + sender_id: str + text: str + created_at: str + + def to_dict(self) -> dict: + return { + "id": self.id, + "chat_id": self.chat_id, + "sender_id": self.sender_id, + "text": self.text, + "created_at": self.created_at, + } + + def sort_key(self): + return (self.created_at, uuid.UUID(self.id).int) diff --git a/app/password.py b/app/password.py new file mode 100644 index 00000000..6a72d3d7 --- /dev/null +++ b/app/password.py @@ -0,0 +1,18 @@ +"""Password KDF: Argon2id (библиотечный).""" +from argon2 import PasswordHasher +from argon2.exceptions import VerifyMismatchError + +_hasher = PasswordHasher() + + +def hash_password(password: str) -> str: + return _hasher.hash(password) + + +def verify_password(password_hash: str, password: str) -> bool: + try: + return _hasher.verify(password_hash, password) + except VerifyMismatchError: + return False + except Exception: + return False diff --git a/app/schemas.py b/app/schemas.py new file mode 100644 index 00000000..08e2110e --- /dev/null +++ b/app/schemas.py @@ -0,0 +1,28 @@ +"""Схемы тел запросов для OpenAPI / Swagger (валидация домена — в services).""" +from typing import List + +from pydantic import BaseModel, ConfigDict, Field + + +class CreateUserBody(BaseModel): + model_config = ConfigDict(extra="forbid") + + username: str = Field(..., examples=["alice"]) + display_name: str = Field(..., examples=["Алиса"]) + password: str = Field(..., examples=["Example-only-not-a-real-secret-123"]) + + +class CreateChatBody(BaseModel): + model_config = ConfigDict(extra="forbid") + + title: str = Field(..., examples=["Проект по ВНП"]) + member_ids: List[str] = Field( + ..., + examples=[["11111111-1111-4111-8111-111111111111"]], + ) + + +class CreateMessageBody(BaseModel): + model_config = ConfigDict(extra="forbid") + + text: str = Field(..., examples=["Привет, Боб!"]) diff --git a/app/services.py b/app/services.py new file mode 100644 index 00000000..309385fd --- /dev/null +++ b/app/services.py @@ -0,0 +1,187 @@ +"""Бизнес-логика lab2 (DIP: зависит от Database/SessionStore).""" +from __future__ import annotations + +import uuid +from typing import List, Optional + +from app import cursor as cursor_util +from app.auth import BASIC_CHALLENGE, parse_basic +from app.db import Database +from app.errors import conflict, invalid_request, not_found, unauthorized +from app.models import Chat, Message, User +from app.password import hash_password, verify_password +from app.sessions import SessionStore +from app.timefmt import now_utc +from app.validation import ( + parse_limit, + parse_uuid, + reject_unknown, + require_display_name, + require_keys, + require_message_text, + require_object, + require_password, + require_title, + require_username, +) + + +class UserService: + def __init__(self, db: Database) -> None: + self.db = db + + def create(self, body: object) -> dict: + data = require_object(body) + reject_unknown(data, {"username", "display_name", "password"}) + require_keys(data, ("username", "display_name", "password")) + username = require_username(data["username"]) + display_name = require_display_name(data["display_name"]) + password = require_password(data["password"]) + user = User( + id=str(uuid.uuid4()), + username=username, + display_name=display_name, + created_at=now_utc(), + password_hash=hash_password(password), + ) + try: + self.db.add_user(user) + except KeyError as exc: + raise conflict("username уже занят") from exc + return user.to_dict() + + +class AuthService: + def __init__(self, db: Database, sessions: SessionStore) -> None: + self.db = db + self.sessions = sessions + + def create_session(self, authorization: Optional[str]) -> dict: + username, password = parse_basic(authorization) + user = self.db.get_user_by_username(username) + if user is None or not verify_password(user.password_hash, password): + raise unauthorized("Неверные учётные данные", challenge=BASIC_CHALLENGE) + token, expires_at = self.sessions.create(user.id) + return { + "token": token, + "token_type": "Bearer", + "expires_at": expires_at, + "user": user.to_dict(), + } + + def logout(self, token: str) -> None: + self.sessions.revoke(token) + + +class ChatService: + def __init__(self, db: Database) -> None: + self.db = db + + def create(self, actor: User, body: object) -> dict: + data = require_object(body) + reject_unknown(data, {"title", "member_ids"}) + require_keys(data, ("title", "member_ids")) + title = require_title(data["title"]) + raw_members = data["member_ids"] + if not isinstance(raw_members, list): + raise invalid_request("member_ids должен быть массивом") + if len(raw_members) < 1 or len(raw_members) > 100: + raise invalid_request("member_ids: от 1 до 100 участников") + member_ids: List[str] = [] + seen = set() + for item in raw_members: + mid = parse_uuid(item, "member_ids") + if mid in seen: + raise invalid_request("member_ids содержит дубликаты") + seen.add(mid) + member_ids.append(mid) + if actor.id not in seen: + raise invalid_request("Вызывающий должен быть в member_ids") + if not self.db.users_exist(member_ids): + raise invalid_request("Неизвестный участник") + chat = Chat( + id=str(uuid.uuid4()), + title=title, + member_ids=member_ids, + created_at=now_utc(), + ) + try: + self.db.add_chat(chat) + except ValueError as exc: + raise invalid_request("Неизвестный участник") from exc + return chat.to_dict() + + def get_for_member(self, actor: User, chat_id: str) -> Chat: + cid = parse_uuid(chat_id, "chat_id") + chat = self.db.get_chat(cid) + if chat is None or actor.id not in chat.member_ids: + raise not_found() + return chat + + def list_for_user(self, actor: User, limit_raw: Optional[str], cursor_raw: Optional[str]) -> dict: + limit = parse_limit(limit_raw) + chats = self.db.list_chats_for(actor.id) + start = 0 + if cursor_raw: + created_at, item_id = cursor_util.decode(cursor_raw, actor.id) + start = 0 + for i, chat in enumerate(chats): + if (chat.created_at, chat.id) > (created_at, item_id): + start = i + break + else: + start = len(chats) + page = chats[start : start + limit] + next_cursor = None + if start + limit < len(chats) and page: + last = page[-1] + next_cursor = cursor_util.encode(actor.id, last.created_at, last.id) + return {"items": [c.to_dict() for c in page], "next_cursor": next_cursor} + + +class MessageService: + def __init__(self, db: Database) -> None: + self.db = db + + def create(self, actor: User, chat: Chat, body: object) -> dict: + data = require_object(body) + reject_unknown(data, {"text"}) + require_keys(data, ("text",)) + text = require_message_text(data["text"]) + message = Message( + id=str(uuid.uuid4()), + chat_id=chat.id, + sender_id=actor.id, + text=text, + created_at=now_utc(), + ) + self.db.add_message(message) + return message.to_dict() + + def list_for_chat( + self, + chat: Chat, + limit_raw: Optional[str], + cursor_raw: Optional[str], + ) -> dict: + limit = parse_limit(limit_raw) + after_created_at = None + after_id = None + if cursor_raw: + created_at, item_id = cursor_util.decode(cursor_raw, chat.id) + parse_uuid(item_id, "cursor.id") + after_created_at = created_at + after_id = item_id + # Fetch limit+1 to detect next page without scanning all history. + rows = self.db.list_messages_page( + chat.id, + limit + 1, + after_created_at=after_created_at, + after_id=after_id, + ) + page = rows[:limit] + next_cursor = None + if len(rows) > limit and page: + last = page[-1] + next_cursor = cursor_util.encode(chat.id, last.created_at, last.id) + return {"items": [m.to_dict() for m in page], "next_cursor": next_cursor} diff --git a/app/sessions.py b/app/sessions.py new file mode 100644 index 00000000..6fdb9668 --- /dev/null +++ b/app/sessions.py @@ -0,0 +1,93 @@ +"""Opaque Bearer-сессии в Redis с TTL и AOF-persistence на стороне Redis.""" +from __future__ import annotations + +import json +import logging +import secrets +from datetime import datetime, timedelta, timezone +from typing import Optional, Tuple + +import redis + +from app.config import settings +from app.errors import unavailable +from app.timefmt import format_utc, parse_rfc3339 + +logger = logging.getLogger("messenger") + +TOKEN_PREFIX = "session:" + + +class SessionStore: + def __init__(self) -> None: + self.client: Optional[redis.Redis] = None + + def open(self) -> None: + self.client = redis.Redis.from_url( + settings.cache_url, + decode_responses=True, + socket_connect_timeout=settings.redis_socket_timeout, + socket_timeout=settings.redis_socket_timeout, + ) + self.client.ping() + logger.info("redis session store ready") + + def close(self) -> None: + if self.client is not None: + self.client.close() + self.client = None + + def _require(self) -> redis.Redis: + if self.client is None: + raise unavailable("Хранилище сессий недоступно") + return self.client + + def ping(self) -> bool: + try: + return bool(self._require().ping()) + except Exception: + return False + + def create(self, user_id: str) -> Tuple[str, str]: + """Возвращает (token, expires_at).""" + client = self._require() + token = secrets.token_urlsafe(32) # ≥256 бит + expires = datetime.now(timezone.utc) + timedelta(seconds=settings.session_ttl_seconds) + expires_at = format_utc(expires) + payload = json.dumps({"user_id": user_id, "expires_at": expires_at}, separators=(",", ":")) + try: + client.setex(TOKEN_PREFIX + token, settings.session_ttl_seconds, payload) + except redis.RedisError as exc: + raise unavailable("Хранилище сессий недоступно") from exc + return token, expires_at + + def resolve(self, token: str) -> Optional[str]: + """user_id или None, если нет/истекла. 503 при недоступности Redis.""" + client = self._require() + try: + raw = client.get(TOKEN_PREFIX + token) + except redis.RedisError as exc: + raise unavailable("Хранилище сессий недоступно") from exc + if not raw: + return None + try: + data = json.loads(raw) + user_id = data["user_id"] + expires_at = parse_rfc3339(data["expires_at"]) + except Exception: + return None + if expires_at <= datetime.now(timezone.utc): + try: + client.delete(TOKEN_PREFIX + token) + except redis.RedisError: + pass + return None + return str(user_id) + + def revoke(self, token: str) -> bool: + client = self._require() + try: + deleted = client.delete(TOKEN_PREFIX + token) + except redis.RedisError as exc: + raise unavailable("Хранилище сессий недоступно") from exc + return bool(deleted) diff --git a/app/timefmt.py b/app/timefmt.py new file mode 100644 index 00000000..58734b42 --- /dev/null +++ b/app/timefmt.py @@ -0,0 +1,20 @@ +"""Форматирование времени в RFC 3339 UTC с миллисекундами и Z.""" +from datetime import datetime, timezone + + +def now_utc() -> str: + return format_utc(datetime.now(timezone.utc)) + + +def format_utc(value: datetime) -> str: + if value.tzinfo is None: + value = value.replace(tzinfo=timezone.utc) + else: + value = value.astimezone(timezone.utc) + return value.strftime("%Y-%m-%dT%H:%M:%S.%f")[:-3] + "Z" + + +def parse_rfc3339(value: str) -> datetime: + if value.endswith("Z"): + value = value[:-1] + "+00:00" + return datetime.fromisoformat(value) diff --git a/app/validation.py b/app/validation.py new file mode 100644 index 00000000..dc6cba80 --- /dev/null +++ b/app/validation.py @@ -0,0 +1,102 @@ +"""Проверки входных данных по контракту lab2.""" +import re +import uuid +from typing import Any, Iterable, Optional, Set + +from app.errors import invalid_request + +USERNAME_RE = re.compile(r"^[a-z0-9_]{3,32}$") + + +def require_object(body: Any) -> dict: + if not isinstance(body, dict): + raise invalid_request("Тело запроса должно быть JSON-объектом") + return body + + +def reject_unknown(body: dict, allowed: Set[str]) -> None: + extra = set(body) - allowed + if extra: + raise invalid_request("Лишние поля в запросе") + + +def require_keys(body: dict, keys: Iterable[str]) -> None: + for key in keys: + if key not in body: + raise invalid_request(f"Поле {key} обязательно") + + +def parse_uuid(value: Any, field: str = "id") -> str: + if not isinstance(value, str): + raise invalid_request(f"Поле {field} должно быть UUID-строкой") + try: + return str(uuid.UUID(value)) + except ValueError as exc: + raise invalid_request(f"Неверный UUID: {field}") from exc + + +def code_points(text: str) -> int: + return len(text) + + +def require_username(value: Any) -> str: + if not isinstance(value, str): + raise invalid_request("username должен быть строкой") + if not USERNAME_RE.fullmatch(value): + raise invalid_request("username: только [a-z0-9_] длиной 3–32") + return value + + +def require_display_name(value: Any) -> str: + if not isinstance(value, str): + raise invalid_request("display_name должен быть строкой") + if value.strip() == "": + raise invalid_request("display_name не может быть пустым") + n = code_points(value) + if n < 1 or n > 100: + raise invalid_request("display_name: 1–100 символов Unicode") + return value + + +def require_password(value: Any) -> str: + if not isinstance(value, str): + raise invalid_request("password должен быть строкой") + if value.strip() == "": + raise invalid_request("password не может быть пустым") + n = code_points(value) + if n < 12 or n > 128: + raise invalid_request("password: 12–128 символов Unicode") + return value + + +def require_title(value: Any) -> str: + if not isinstance(value, str): + raise invalid_request("title должен быть строкой") + if value.strip() == "": + raise invalid_request("title не может быть пустым") + n = code_points(value) + if n < 1 or n > 100: + raise invalid_request("title: 1–100 символов Unicode") + return value + + +def require_message_text(value: Any) -> str: + if not isinstance(value, str): + raise invalid_request("text должен быть строкой") + if value.strip() == "": + raise invalid_request("text не может быть пустым") + if code_points(value) > 4000: + raise invalid_request("text: максимум 4000 символов Unicode") + return value + + +def parse_limit(raw: Optional[str], default: int = 50) -> int: + if raw is None or raw == "": + return default + try: + value = int(raw) + except ValueError as exc: + raise invalid_request("limit должен быть целым числом") from exc + if value < 1 or value > 100: + raise invalid_request("limit должен быть от 1 до 100") + return value diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 00000000..fb32dc84 --- /dev/null +++ b/compose.yaml @@ -0,0 +1,95 @@ +# Runnable lab2 stand: API + PostgreSQL + Redis (sessions with AOF). +x-lab-number: 2 + +services: + postgres: + image: postgres:16.4-bookworm + environment: + POSTGRES_USER: messenger + POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password + POSTGRES_DB: messenger + ports: + - "127.0.0.1:15432:5432" + secrets: + - postgres_password + volumes: + - pg_data:/var/lib/postgresql/data + healthcheck: + test: ["CMD-SHELL", "pg_isready -U messenger -d messenger"] + interval: 5s + timeout: 3s + retries: 10 + restart: unless-stopped + + redis: + image: redis:7.4.1-bookworm + command: + - redis-server + - --appendonly + - "yes" + - --appendfsync + - everysec + - --dir + - /data + ports: + - "127.0.0.1:6379:6379" + volumes: + - redis_data:/data + healthcheck: + test: ["CMD", "redis-cli", "ping"] + interval: 5s + timeout: 3s + retries: 10 + restart: unless-stopped + + api: + build: + context: . + dockerfile: Dockerfile + ports: + - "127.0.0.1:8080:8080" + environment: + APP_HOST: 0.0.0.0 + APP_PORT: "8080" + APP_ENV: lab + SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600} + SESSION_STORE: redis + DATABASE_URL_FILE: /run/secrets/database_url + CACHE_URL_FILE: /run/secrets/cache_url + DB_CONNECT_TIMEOUT: "5" + DB_POOL_MIN: "1" + DB_POOL_MAX: "10" + REDIS_SOCKET_TIMEOUT: "3" + secrets: + - database_url + - cache_url + 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=2)", + ] + interval: 5s + timeout: 3s + start_period: 20s + retries: 10 + restart: unless-stopped + +volumes: + pg_data: + redis_data: + +secrets: + postgres_password: + file: ./secrets/postgres_password + database_url: + file: ./secrets/database_url + cache_url: + file: ./secrets/cache_url diff --git a/evidence/README.md b/evidence/README.md index 8df70015..ac79a130 100644 --- a/evidence/README.md +++ b/evidence/README.md @@ -1,5 +1,4 @@ -# Доказательства +# Evidence -Храните небольшие обезличенные результаты: команды и stdout проверок, JSON/CSV агрегатов нагрузки, EXPLAIN, dashboard JSON, текст разбора отказа. Укажите дату, commit, аппаратные лимиты и профиль нагрузки. - -Не добавляйте .env, session tokens, cookies, приватные ключи, credentials, реальные сообщения, raw dumps и signed URLs. Для скриншотов скрывайте секреты. Большие логи/бинарные traces сохраняйте отдельно по правилам преподавателя; одного скриншота без методики недостаточно. +Сюда складываются текстовые выводы прогонов (`smoke.txt`, `own.txt`, `persistence.txt`, `explain.txt`). +Не коммитьте токены, пароли и полные connection strings. diff --git a/evidence/expiry.txt b/evidence/expiry.txt new file mode 100644 index 00000000..603b0090 Binary files /dev/null and b/evidence/expiry.txt differ diff --git a/evidence/explain.txt b/evidence/explain.txt new file mode 100644 index 00000000..985cdfb0 --- /dev/null +++ b/evidence/explain.txt @@ -0,0 +1,11 @@ +chat_id=2f9b61cc-21fd-473b-80c1-0bb95c3814ec messages=10000 + +Limit (cost=0.29..5.61 rows=50 width=65) (actual time=0.007..0.014 rows=50 loops=1) + Buffers: shared hit=3 + -> Index Scan using messages_chat_created_id_idx on messages (cost=0.29..1013.57 rows=9523 width=65) (actual time=0.006..0.010 rows=50 loops=1) + Index Cond: (chat_id = '2f9b61cc-21fd-473b-80c1-0bb95c3814ec'::uuid) + Buffers: shared hit=3 +Planning: + Buffers: shared hit=34 +Planning Time: 0.138 ms +Execution Time: 0.041 ms diff --git a/evidence/own.txt b/evidence/own.txt new file mode 100644 index 00000000..c6ff6d29 Binary files /dev/null and b/evidence/own.txt differ diff --git a/evidence/persistence.txt b/evidence/persistence.txt new file mode 100644 index 00000000..c25cebac Binary files /dev/null and b/evidence/persistence.txt differ diff --git a/evidence/smoke.txt b/evidence/smoke.txt new file mode 100644 index 00000000..04938cf4 Binary files /dev/null and b/evidence/smoke.txt differ diff --git a/migrations/001_init.sql b/migrations/001_init.sql new file mode 100644 index 00000000..4894343b --- /dev/null +++ b/migrations/001_init.sql @@ -0,0 +1,37 @@ +-- Lab2 schema: users, chats, membership, messages. + +CREATE TABLE IF NOT EXISTS users ( + id UUID PRIMARY KEY, + username TEXT NOT NULL, + display_name TEXT NOT NULL, + password_hash TEXT NOT NULL, + created_at TIMESTAMPTZ NOT NULL +); + +CREATE UNIQUE INDEX IF NOT EXISTS users_username_uq ON users (username); + +CREATE TABLE IF NOT EXISTS chats ( + id UUID PRIMARY KEY, + title TEXT NOT NULL, + created_at TIMESTAMPTZ NOT NULL +); + +CREATE TABLE IF NOT EXISTS chat_members ( + chat_id UUID NOT NULL REFERENCES chats (id) ON DELETE CASCADE, + user_id UUID NOT NULL REFERENCES users (id), + PRIMARY KEY (chat_id, user_id) +); + +CREATE INDEX IF NOT EXISTS chat_members_user_id_idx ON chat_members (user_id); + +CREATE TABLE IF NOT EXISTS messages ( + id UUID PRIMARY KEY, + chat_id UUID NOT NULL REFERENCES chats (id) ON DELETE CASCADE, + sender_id UUID NOT NULL REFERENCES users (id), + text TEXT NOT NULL, + created_at TIMESTAMPTZ NOT NULL +); + +-- Keyset history: (chat_id, created_at, id) — without full table scan per page. +CREATE INDEX IF NOT EXISTS messages_chat_created_id_idx + ON messages (chat_id, created_at, id); diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 00000000..ed10c331 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,7 @@ +fastapi==0.115.6 +uvicorn==0.32.1 +pydantic==2.10.3 +starlette==0.41.3 +psycopg[binary,pool]==3.2.3 +redis==5.2.1 +argon2-cffi==23.1.0 diff --git a/scripts/explain_messages.py b/scripts/explain_messages.py new file mode 100644 index 00000000..c5ef191d --- /dev/null +++ b/scripts/explain_messages.py @@ -0,0 +1,65 @@ +#!/usr/bin/env python3 +"""Seed ≥10k messages and print EXPLAIN (ANALYZE, BUFFERS) for keyset page query.""" +from __future__ import annotations + +import os +import sys +import uuid +from pathlib import Path + +# Allow running against a live API + direct DB for EXPLAIN. +ROOT = Path(__file__).resolve().parents[1] +sys.path.insert(0, str(ROOT)) + +from app.config import settings # noqa: E402 +from app.db import Database # noqa: E402 +from app.models import Chat, Message, User # noqa: E402 +from app.password import hash_password # noqa: E402 +from app.timefmt import now_utc # noqa: E402 + + +def main() -> int: + count = int(os.environ.get("EXPLAIN_MESSAGES", "10000")) + db = Database() + db.open() + user = User( + id=str(uuid.uuid4()), + username="explain_" + uuid.uuid4().hex[:10], + display_name="Explain", + created_at=now_utc(), + password_hash=hash_password("Explain-password-12"), + ) + db.add_user(user) + chat = Chat( + id=str(uuid.uuid4()), + title="EXPLAIN chat", + member_ids=[user.id], + created_at=now_utc(), + ) + db.add_chat(chat) + for i in range(count): + db.add_message( + Message( + id=str(uuid.uuid4()), + chat_id=chat.id, + sender_id=user.id, + text="bulk-%d" % i, + created_at=now_utc(), + ) + ) + if (i + 1) % 2000 == 0: + print("inserted", i + 1, flush=True) + plan = db.explain_messages_page(chat.id, limit=50) + out = ROOT / "evidence" / "explain.txt" + out.write_text( + "chat_id=%s messages=%d\n\n%s\n" % (chat.id, count, plan), + encoding="utf-8", + ) + print(plan) + print("wrote", out) + db.close() + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/scripts/make_secrets.ps1 b/scripts/make_secrets.ps1 new file mode 100644 index 00000000..5ff91a1f --- /dev/null +++ b/scripts/make_secrets.ps1 @@ -0,0 +1,13 @@ +# Creates local synthetic secrets for compose (never commit secrets/). +$ErrorActionPreference = "Stop" +$root = Split-Path -Parent $PSScriptRoot +$secrets = Join-Path $root "secrets" +New-Item -ItemType Directory -Force -Path $secrets | Out-Null + +$password = "lab2-pg-pass-" + [guid]::NewGuid().ToString("N").Substring(0, 12) +Set-Content -Path (Join-Path $secrets "postgres_password") -Value $password -NoNewline +# URL for the API container (service DNS name "postgres" / "redis"). +$dbUrl = "postgresql://messenger:${password}@postgres:5432/messenger" +Set-Content -Path (Join-Path $secrets "database_url") -Value $dbUrl -NoNewline +Set-Content -Path (Join-Path $secrets "cache_url") -Value "redis://redis:6379/0" -NoNewline +Write-Host "Wrote secrets/postgres_password, secrets/database_url, secrets/cache_url" diff --git a/scripts/make_secrets.sh b/scripts/make_secrets.sh new file mode 100644 index 00000000..95d5697c --- /dev/null +++ b/scripts/make_secrets.sh @@ -0,0 +1,9 @@ +#!/bin/sh +set -eu +ROOT="$(CDPATH= cd -- "$(dirname "$0")/.." && pwd)" +mkdir -p "$ROOT/secrets" +PASSWORD="lab2-pg-pass-$(openssl rand -hex 6)" +printf '%s' "$PASSWORD" > "$ROOT/secrets/postgres_password" +printf '%s' "postgresql://messenger:${PASSWORD}@postgres:5432/messenger" > "$ROOT/secrets/database_url" +printf '%s' "redis://redis:6379/0" > "$ROOT/secrets/cache_url" +echo "Wrote secrets/postgres_password, secrets/database_url, secrets/cache_url" diff --git a/scripts/restart.cmd b/scripts/restart.cmd new file mode 100644 index 00000000..c8dfe7fb --- /dev/null +++ b/scripts/restart.cmd @@ -0,0 +1,5 @@ +@echo off +REM Restart API and all state stores without removing volumes (Windows host). +cd /d "%~dp0.." +docker compose --env-file .env restart +exit /b %ERRORLEVEL% diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100644 index 00000000..17fb8eed --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,6 @@ +#!/bin/sh +set -eu +# Restart API and all state stores (postgres, redis) without removing volumes. +cd "$(dirname "$0")/.." +docker compose --env-file .env restart +exit 0 diff --git a/scripts/test_expiry_raw.py b/scripts/test_expiry_raw.py new file mode 100644 index 00000000..0bf3c6d3 --- /dev/null +++ b/scripts/test_expiry_raw.py @@ -0,0 +1,56 @@ +#!/usr/bin/env python3 +"""Raw expiry check without OpenAPI schema validation overhead.""" +import base64 +import json +import time +import urllib.error +import urllib.request +import uuid + +base = "http://127.0.0.1:8080" +username = "u_raw_" + uuid.uuid4().hex[:10] +password = "T3st-" + uuid.uuid4().hex +body = json.dumps( + {"username": username, "display_name": "Raw", "password": password} +).encode() +req = urllib.request.Request( + base + "/api/v1/users", + data=body, + headers={"Content-Type": "application/json", "Accept": "application/json"}, + method="POST", +) +with urllib.request.urlopen(req, timeout=30) as r: + user = json.loads(r.read()) + print("user", user["id"]) + +cred = base64.b64encode((username + ":" + password).encode()).decode() +req = urllib.request.Request( + base + "/api/v1/auth/sessions", + data=b"", + headers={"Authorization": "Basic " + cred, "Accept": "application/json"}, + method="POST", +) +with urllib.request.urlopen(req, timeout=30) as r: + session = json.loads(r.read()) + print("token_prefix", session["token"][:16], "exp", session["expires_at"]) + +req = urllib.request.Request( + base + "/api/v1/users/me", + headers={"Authorization": "Bearer " + session["token"], "Accept": "application/json"}, +) +with urllib.request.urlopen(req, timeout=10) as r: + print("me", json.loads(r.read())["id"]) + +time.sleep(6) +req = urllib.request.Request( + base + "/api/v1/users/me", + headers={"Authorization": "Bearer " + session["token"], "Accept": "application/json"}, +) +try: + urllib.request.urlopen(req, timeout=10) + raise SystemExit("FAIL still valid") +except urllib.error.HTTPError as exc: + print("after wait status", exc.code) + if exc.code != 401: + raise SystemExit("expected 401") + print("PASS: session expired after short TTL") diff --git a/tests/own.py b/tests/own.py new file mode 100644 index 00000000..3b30132d --- /dev/null +++ b/tests/own.py @@ -0,0 +1,335 @@ +#!/usr/bin/env python3 +"""Собственные проверки lab2 (оценка 4): auth, гонки, expiry, отказ Redis/DB.""" +import base64 +import os +import subprocess +import threading +import time +import uuid +from concurrent.futures import ThreadPoolExecutor +from pathlib import Path +from urllib.parse import quote + +from client import Client, Failure, arguments, check, run + +ROOT = Path(__file__).resolve().parents[1] + + +def _password(): + return "T3st-" + uuid.uuid4().hex + + +def test_invalid_json(c: Client): + resp = c.call( + "POST", + "/api/v1/users", + 400, + raw=b"{not-json", + headers={"Content-Type": "application/json"}, + schema="Error", + ) + check(resp["json"]["error"]["code"] == "invalid_request", "expected invalid_request for bad JSON") + + +def test_wrong_password(c: Client): + alice = c.user("wp") + bad = base64.b64encode( + (alice["registration"]["username"] + ":wrong-password-xx").encode() + ).decode() + resp = c.call( + "POST", + "/api/v1/auth/sessions", + 401, + headers={"Authorization": "Basic " + bad}, + schema="Error", + ) + check(resp["json"]["error"]["code"] == "unauthorized", "wrong password must be 401") + check( + resp["headers"].get("WWW-Authenticate", "").lower().startswith("basic"), + "WWW-Authenticate Basic required", + ) + + +def test_logout(c: Client): + alice = c.user("lo") + c.call("DELETE", "/api/v1/auth/sessions/current", 204, actor=alice) + c.call("GET", "/api/v1/users/me", 401, actor=alice, schema="Error") + + +def test_duplicate_username(c: Client): + name = "dup_" + uuid.uuid4().hex[:10] + password = _password() + body = {"username": name, "display_name": "Один", "password": password} + c.call("POST", "/api/v1/users", 201, body=body, schema="User") + resp = c.call("POST", "/api/v1/users", 409, body=body, schema="Error") + check(resp["json"]["error"]["code"] == "conflict", "expected conflict") + + +def test_username_race(c: Client): + """Гонка регистрации одинакового username → ровно один 201, остальные 409.""" + name = "race_" + uuid.uuid4().hex[:10] + password = _password() + body = {"username": name, "display_name": "Гонка", "password": password} + barrier = threading.Barrier(8) + results = [] + + def worker(): + local = Client(c.base, timeout=20) + barrier.wait() + try: + resp = local.call("POST", "/api/v1/users", [201, 409], body=body) + results.append(resp["status"]) + except Failure as exc: + results.append(str(exc)) + + with ThreadPoolExecutor(max_workers=8) as pool: + list(pool.map(lambda _: worker(), range(8))) + ok = [r for r in results if r == 201] + conflicted = [r for r in results if r == 409] + check(len(ok) == 1, "expected exactly one successful registration, got %r" % (results,)) + check(len(conflicted) == 7, "expected seven conflicts, got %r" % (results,)) + + +def test_foreign_chat(c: Client): + alice = c.user("own_a") + eve = c.user("own_e") + chat = c.call( + "POST", + "/api/v1/chats", + 201, + actor=alice, + body={"title": "Секрет", "member_ids": [alice["id"]]}, + schema="Chat", + )["json"] + path = "/api/v1/chats/" + chat["id"] + c.call("GET", path, 404, actor=eve, schema="Error") + c.call("GET", path + "/messages", 404, actor=eve, schema="Error") + c.call("POST", path + "/messages", 404, actor=eve, body={"text": "взлом"}, schema="Error") + + +def test_empty_message(c: Client): + alice = c.user("own_empty") + chat = c.call( + "POST", + "/api/v1/chats", + 201, + actor=alice, + body={"title": "Тест", "member_ids": [alice["id"]]}, + schema="Chat", + )["json"] + for text in ("", " ", "\n\t"): + resp = c.call( + "POST", + "/api/v1/chats/" + chat["id"] + "/messages", + 400, + actor=alice, + body={"text": text}, + schema="Error", + ) + check(resp["json"]["error"]["code"] == "invalid_request", "empty text must be 400") + + +def test_pagination_pages(c: Client): + alice = c.user("page_a") + chat = c.call( + "POST", + "/api/v1/chats", + 201, + actor=alice, + body={"title": "Страницы", "member_ids": [alice["id"]]}, + schema="Chat", + )["json"] + created = [] + for i in range(5): + created.append(c.message(alice, chat, "msg-%d" % i)["json"]) + path = "/api/v1/chats/" + chat["id"] + "/messages" + collected = [] + cursor = None + pages = 0 + while True: + q = path + "?limit=2" + if cursor: + q += "&cursor=" + quote(cursor, safe="") + page = c.call("GET", q, actor=alice, schema="MessagePage")["json"] + pages += 1 + collected.extend(page["items"]) + cursor = page["next_cursor"] + if cursor is None: + break + check(pages >= 3, "expected several pages with limit=2 over 5 messages") + check(len(collected) == 5, "pagination must return all messages once") + from client import timestamp + + expected = sorted(created, key=lambda m: (timestamp(m["created_at"]), uuid.UUID(m["id"]).int)) + check(collected == expected, "pagination must return keyset order") + + +def test_session_expiry(c: Client): + """Без schema-валидации клиента: иначе OpenAPI-parse съедает короткий TTL.""" + import json + import urllib.error + import urllib.request + + ttl = int(os.environ.get("SESSION_TTL_SECONDS", "3600")) + if ttl > 5: + print("SKIP expiry: set SESSION_TTL_SECONDS<=5 on server and re-run") + return + username = "ttl_" + uuid.uuid4().hex[:10] + password = _password() + body = json.dumps( + {"username": username, "display_name": "TTL", "password": password} + ).encode() + req = urllib.request.Request( + c.base + "/api/v1/users", + data=body, + headers={"Content-Type": "application/json", "Accept": "application/json"}, + method="POST", + ) + with urllib.request.urlopen(req, timeout=30) as resp: + check(resp.status == 201, "register for expiry") + cred = base64.b64encode((username + ":" + password).encode()).decode() + req = urllib.request.Request( + c.base + "/api/v1/auth/sessions", + data=b"", + headers={"Authorization": "Basic " + cred, "Accept": "application/json"}, + method="POST", + ) + with urllib.request.urlopen(req, timeout=30) as resp: + session = json.loads(resp.read()) + token = session["token"] + req = urllib.request.Request( + c.base + "/api/v1/users/me", + headers={"Authorization": "Bearer " + token, "Accept": "application/json"}, + ) + with urllib.request.urlopen(req, timeout=10) as resp: + check(resp.status == 200, "session must work before expiry") + time.sleep(ttl + 1.5) + try: + urllib.request.urlopen(req, timeout=10) + raise Failure("session still valid after TTL") + except urllib.error.HTTPError as exc: + check(exc.code == 401, "expected 401 after TTL, got %s" % exc.code) + print("PASS: session expired after TTL=%d" % ttl) + + +def _compose(*args: str) -> None: + cmd = ["docker", "compose", "--env-file", str(ROOT / ".env"), "-f", str(ROOT / "compose.yaml"), *args] + subprocess.check_call(cmd, cwd=str(ROOT), stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) + + +def test_redis_down_recovers(c: Client): + """При недоступности Redis — 503, без «анонимного» доверия; после старта снова ready.""" + try: + _compose("stop", "redis") + except (subprocess.CalledProcessError, FileNotFoundError) as exc: + print("SKIP redis-down: docker compose unavailable (%s)" % exc) + return + try: + deadline = time.monotonic() + 30 + saw_503 = False + while time.monotonic() < deadline: + try: + c.call("GET", "/health/ready", 503, schema="Error") + saw_503 = True + break + except Failure: + time.sleep(0.5) + check(saw_503, "ready must become 503 when redis is down") + alice = None + # Protected path must not succeed as anonymous / must not 200. + try: + # Re-login impossible without redis; any bearer must fail closed. + c.call( + "GET", + "/api/v1/users/me", + [401, 503], + headers={"Authorization": "Bearer deadbeefdeadbeefdeadbeefdeadbeef"}, + schema="Error", + ) + except Failure as exc: + raise Failure("protected endpoint must fail closed when redis down: %s" % exc) from exc + finally: + _compose("start", "redis") + deadline = time.monotonic() + 60 + while True: + try: + c.call("GET", "/health/ready", schema="Health") + break + except Failure: + check(time.monotonic() < deadline, "stack did not recover after redis start") + time.sleep(0.5) + print("PASS: redis down -> 503, then recovery") + + +def test_concurrency_100(c: Client): + alice = c.user("race_a") + bob = c.user("race_b") + chat = c.call( + "POST", + "/api/v1/chats", + 201, + actor=alice, + body={"title": "Гонка", "member_ids": [alice["id"], bob["id"]]}, + schema="Chat", + )["json"] + barrier = threading.Barrier(10) + errors = [] + + def worker(worker_id: int): + local = Client(c.base, timeout=20) + actor = alice if worker_id % 2 == 0 else bob + barrier.wait() + for i in range(10): + try: + local.message(actor, chat, "race-%d-%d" % (worker_id, i)) + except Failure as exc: + errors.append(str(exc)) + + with ThreadPoolExecutor(max_workers=10) as pool: + list(pool.map(worker, range(10))) + check(not errors, "concurrency errors: " + "; ".join(errors[:3])) + path = "/api/v1/chats/" + chat["id"] + "/messages" + collected = [] + cursor = None + while True: + q = path + "?limit=100" + if cursor: + q += "&cursor=" + quote(cursor, safe="") + page = c.call("GET", q, actor=alice, schema="MessagePage")["json"] + collected.extend(page["items"]) + cursor = page["next_cursor"] + if cursor is None: + break + check(len(collected) == 100, "expected 100 messages, got %d" % len(collected)) + check(len(set(m["id"] for m in collected)) == 100, "expected 100 unique ids") + + +def main(): + args = arguments("Own lab2 tests: auth, races, expiry, redis failure") + c = Client(args.base_url, args.ca_file, timeout=20) + c.call("GET", "/health/ready", schema="Health") + test_invalid_json(c) + print("PASS: invalid JSON") + test_wrong_password(c) + print("PASS: wrong password") + test_logout(c) + print("PASS: logout") + test_duplicate_username(c) + print("PASS: duplicate username") + test_username_race(c) + print("PASS: username registration race") + test_foreign_chat(c) + print("PASS: foreign chat -> 404") + test_empty_message(c) + print("PASS: empty message") + test_pagination_pages(c) + print("PASS: multi-page pagination") + test_concurrency_100(c) + print("PASS: concurrency 100") + test_session_expiry(c) + test_redis_down_recovers(c) + print("PASS: all own lab2 tests") + + +if __name__ == "__main__": + run(main)