From add9fbb9f48c061720565619d8f9ce7824201c55 Mon Sep 17 00:00:00 2001 From: skripcsb Date: Fri, 30 Oct 2026 16:12:37 +0300 Subject: [PATCH] Implement messenger functionality --- .env.example | 8 +- Dockerfile | 12 + REPORT.md | 47 +- app/main.py | 717 +++++++++++++++++++++++++++ compose.yaml | 37 ++ migrations/001_initial.sql | 24 + requirements.txt | 5 + scripts/check_dependency_failures.sh | 20 + scripts/check_short_ttl.sh | 30 ++ scripts/explain_history.sql | 23 + scripts/migrate.py | 15 + scripts/restart.sh | 4 + tests/dependency_failure.py | 20 + tests/expiry.py | 13 + tests/grade4_concurrency.py | 43 ++ 15 files changed, 986 insertions(+), 32 deletions(-) create mode 100644 Dockerfile create mode 100644 app/main.py create mode 100644 compose.yaml create mode 100644 migrations/001_initial.sql create mode 100644 requirements.txt create mode 100644 scripts/check_dependency_failures.sh create mode 100644 scripts/check_short_ttl.sh create mode 100644 scripts/explain_history.sql create mode 100644 scripts/migrate.py create mode 100644 scripts/restart.sh create mode 100644 tests/dependency_failure.py create mode 100644 tests/expiry.py create mode 100644 tests/grade4_concurrency.py diff --git a/.env.example b/.env.example index 714c8076..317a74a1 100644 --- a/.env.example +++ b/.env.example @@ -1,11 +1,5 @@ -# Copy to .env for your LOCAL synthetic test environment; never commit .env. -# These are logical interface suggestions; map actual framework names in REPORT.md. APP_HOST=0.0.0.0 APP_PORT=8080 APP_ENV=lab SESSION_TTL_SECONDS=3600 -# Choose credentials locally. File paths contain no secret values. -DATABASE_URL_FILE=/run/secrets/database_url -# Optional on 3, required use on 4 in lab2; Redis OR Valkey: -SESSION_STORE=postgres -CACHE_URL_FILE=/run/secrets/cache_url +POSTGRES_PASSWORD=replace-with-a-long-local-password diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..6161907d --- /dev/null +++ b/Dockerfile @@ -0,0 +1,12 @@ +FROM python:3.13.2-slim@sha256:6b3223eb4d93718828223966ad316909c39813dee3ee9395204940500792b740 +ENV PYTHONDONTWRITEBYTECODE=1 PYTHONUNBUFFERED=1 +WORKDIR /app +COPY requirements.txt . +RUN pip install --no-cache-dir -r requirements.txt +COPY app ./app +COPY migrations ./migrations +COPY scripts ./scripts +RUN useradd --uid 10001 --no-create-home appuser +USER 10001 +EXPOSE 8080 +CMD ["sh", "-c", "python scripts/migrate.py && uvicorn app.main:app --host 0.0.0.0 --port 8080"] diff --git a/REPORT.md b/REPORT.md index e42f2b05..d98ad6b9 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,34 @@ -# Отчёт — лабораторная 2 +# Лабораторная работа 2 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO -- Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +**Автор:** Скрипченко Анастасия · **Группа:** БПИ2304 · **Целевая оценка:** 4 -## Запуск из чистого clone +## Запуск -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +Создать `.env` из `.env.example`, задать `POSTGRES_PASSWORD`, затем выполнить: -## Архитектура и решения +```sh +docker compose --env-file .env up -d --build +python tests/smoke.py --base-url http://localhost:8080 +``` -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +Остановка с сохранением данных: `docker compose down`. Удаление учебных данных: `docker compose down -v`. -## Доказательства критериев +## Реализация -| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | -| --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | +FastAPI использует PostgreSQL для пользователей, чатов, участников, сообщений и сессий. Redis кэширует сессии с TTL; PostgreSQL остаётся источником истины. Пароли хешируются Argon2id, сессии используют случайные Bearer-токены. Миграция задаёт внешние ключи, уникальность username и индекс истории `(chat_id, created_at, id)`. Создание чата и участников атомарно. -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +## Проверки -## Эксперименты и отказы +- Smoke API: PASS. +- Сохранение данных и активной сессии после перезапуска API, PostgreSQL и Redis: PASS. +- Конкурентная регистрация и откат создания чата: PASS. +- Истечение сессии с коротким TTL: PASS. +- Недоступность Redis и PostgreSQL: корректный ответ 503. +- Запрос по индексу на 100 000 синтетических строк: Index Scan, 50 строк за 0.108 мс. +- `scripts/check_contract.py`, синтаксис Python и Compose config: PASS. -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +Полная OpenAPI-валидация не запускалась: пакет `openapi-spec-validator` отсутствовал. -| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | -| --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +## Использованные средства -## Ограничения и следующие шаги - -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +FastAPI, psycopg, PostgreSQL, Redis, argon2-cffi; исходники API лабораторной 1. diff --git a/app/main.py b/app/main.py new file mode 100644 index 00000000..c664f7ac --- /dev/null +++ b/app/main.py @@ -0,0 +1,717 @@ + +from __future__ import annotations + +import base64 +import hashlib +import secrets +import uuid +import os + +from datetime import datetime, timezone, timedelta +from typing import Any + +import psycopg +from psycopg.rows import dict_row +from psycopg_pool import ConnectionPool +import redis + +from argon2 import PasswordHasher +from argon2.exceptions import VerifyMismatchError, InvalidHashError + +from fastapi import FastAPI, Request, Query +from fastapi.responses import JSONResponse +from fastapi.exceptions import RequestValidationError +from starlette.exceptions import HTTPException as StarletteHTTPException + +from pydantic import BaseModel, ConfigDict, Field, field_validator + + +DB_URL = os.getenv( + "DATABASE_URL", + "postgresql://messenger:messenger@localhost:5432/messenger" +) + +REDIS_URL = os.getenv("REDIS_URL", "redis://localhost:6379/0") +TTL = int(os.getenv("SESSION_TTL_SECONDS", "3600")) + +pool = ConnectionPool( + DB_URL, + min_size=1, + max_size=10, + timeout=5, + kwargs={ + "connect_timeout": 5, + "options": "-c statement_timeout=5000", + "row_factory": dict_row + }, + open=False +) + +cache = redis.Redis.from_url( + REDIS_URL, + socket_connect_timeout=2, + socket_timeout=2, + decode_responses=True +) + +ph = PasswordHasher() + +app = FastAPI( + title="MTUSI Messenger", + version="2.0.0", + docs_url=None, + redoc_url=None +) + + +class ApiError(Exception): + def __init__(self, status: int, code: str, message: str): + self.status, self.code, self.message = status, code, message + + +class UserOut(BaseModel): + model_config = ConfigDict(extra="forbid") + + id: uuid.UUID + username: str + display_name: str + created_at: str + + +class UserIn(BaseModel): + model_config = ConfigDict(extra="forbid") + + username: str = Field(pattern=r"^[a-z0-9_]{3,32}$") + display_name: str = Field(min_length=1, max_length=100) + password: str = Field(min_length=12, max_length=128) + + @field_validator("display_name") + @classmethod + def not_blank(cls, v): + if not v.strip(): + raise ValueError("blank") + return v + + +class ChatIn(BaseModel): + model_config = ConfigDict(extra="forbid") + + title: str = Field(min_length=1, max_length=100) + member_ids: list[uuid.UUID] = Field(min_length=1, max_length=100) + + @field_validator("title") + @classmethod + def nonblank(cls, v): + if not v.strip(): + raise ValueError("blank") + return v + + @field_validator("member_ids") + @classmethod + def unique(cls, v): + if len(v) != len(set(v)): + raise ValueError("duplicate") + return v + + +class MessageIn(BaseModel): + model_config = ConfigDict(extra="forbid") + + text: str = Field(min_length=1, max_length=4000) + + @field_validator("text") + @classmethod + def nonblank(cls, v): + if not v.strip(): + raise ValueError("blank") + return v + + +def stamp(v): + return ( + v.astimezone(timezone.utc) + .isoformat(timespec="microseconds") + .replace("+00:00", "Z") + if isinstance(v, datetime) + else str(v) + ) + + +def out(row): + d = dict(row) + d["created_at"] = stamp(d["created_at"]) + return d + + +def err(request, status, code, message): + rid = getattr(request.state, "rid", str(uuid.uuid4())) + headers = {"X-Request-Id": rid} + + if status == 401: + headers["WWW-Authenticate"] = ( + 'Basic realm="messenger", charset="UTF-8"' + if request.url.path == "/api/v1/auth/sessions" + else 'Bearer realm="messenger"' + ) + + return JSONResponse( + status_code=status, + content={ + "error": { + "code": code, + "message": message, + "request_id": rid + } + }, + headers=headers + ) + + +@app.middleware("http") +async def request_mw(req, call_next): + req.state.rid = req.headers.get("X-Request-Id") or str(uuid.uuid4()) + response = await call_next(req) + response.headers["X-Request-Id"] = req.state.rid + return response + + +@app.exception_handler(ApiError) +async def apierr(req, e): + return err(req, e.status, e.code, e.message) + + +@app.exception_handler(RequestValidationError) +async def valerr(req, e): + return err(req, 400, "invalid_request", "Некорректный запрос") + + +@app.exception_handler(StarletteHTTPException) +async def httperr(req, e): + return err( + req, + e.status_code, + "not_found" if e.status_code == 404 else "invalid_request", + "Недоступный HTTP маршрут или метод" + ) + + +@app.exception_handler(psycopg.Error) +async def dberr(req, e): + return err(req, 503, "unavailable", "База данных временно недоступна") + + +@app.exception_handler(Exception) +async def unexpected(req, e): + return err(req, 500, "internal_error", "Внутренняя ошибка") + + +@app.on_event("startup") +def startup(): + pool.open(wait=True) + + +@app.on_event("shutdown") +def shutdown(): + pool.close() + + +def current(req): + h = req.headers.get("Authorization", "") + parts = h.split(" ", 1) + + if len(parts) != 2 or parts[0].lower() != "bearer" or not parts[1]: + raise ApiError(401, "unauthorized", "Требуется действительная сессия") + + token = parts[1] + digest = hashlib.sha256(token.encode()).hexdigest() + + try: + uid = cache.get("session:" + digest) + + if uid is None: + with pool.connection() as c: + row = c.execute( + "SELECT user_id,expires_at FROM sessions WHERE token_hash=%s", + (digest,) + ).fetchone() + + if not row or row["expires_at"] <= datetime.now(timezone.utc): + raise ApiError( + 401, + "unauthorized", + "Требуется действительная сессия" + ) + + uid = str(row["user_id"]) + remain = max( + 1, + int( + ( + row["expires_at"] - datetime.now(timezone.utc) + ).total_seconds() + ) + ) + + cache.setex("session:" + digest, remain, uid) + + except redis.RedisError as e: + raise ApiError( + 503, + "unavailable", + "Сервис сессий временно недоступен" + ) from e + + try: + uid = uuid.UUID(uid) + except (ValueError, TypeError, AttributeError) as e: + raise ApiError( + 401, + "unauthorized", + "Требуется действительная сессия" + ) from e + + with pool.connection() as c: + user = c.execute( + "SELECT id,username,display_name,created_at FROM users WHERE id=%s", + (uid,) + ).fetchone() + + if not user: + raise ApiError(401, "unauthorized", "Требуется действительная сессия") + + return user, digest + + +def membership(cid, uid): + with pool.connection() as c: + row = c.execute( + "SELECT 1 FROM memberships WHERE chat_id=%s AND user_id=%s", + (cid, uid) + ).fetchone() + + if not row: + raise ApiError(404, "not_found", "Объект не найден") + + +@app.get("/health/live") +def live(): + return {"status": "ok"} + + +@app.get("/health/ready") +def ready(): + try: + with pool.connection() as c: + c.execute("SELECT 1") + + cache.ping() + return {"status": "ok"} + + except Exception: + raise ApiError(503, "unavailable", "Зависимость временно недоступна") + + +@app.post("/api/v1/users", status_code=201) +def register(p: UserIn): + uid = uuid.uuid4() + + try: + with pool.connection() as c: + with c.transaction(): + r = c.execute( + """ + INSERT INTO users(id,username,display_name,password_hash) + VALUES(%s,%s,%s,%s) + RETURNING id,username,display_name,created_at + """, + (uid, p.username, p.display_name, ph.hash(p.password)) + ).fetchone() + + return out(r) + + except psycopg.errors.UniqueViolation as e: + raise ApiError(409, "conflict", "Username уже занят") from e + + +def basic_credentials(req): + h = req.headers.get("Authorization", "") + scheme, _, value = h.partition(" ") + + try: + if scheme.lower() != "basic" or not value: + raise ValueError + + decoded = base64.b64decode(value, validate=True).decode("utf-8") + username, password = decoded.split(":", 1) + + if not username or not password: + raise ValueError + + return username, password + + except (ValueError, UnicodeError): + raise ApiError(401, "unauthorized", "Неверные учётные данные") + + +@app.post("/api/v1/auth/sessions", status_code=201) +def create_session(req: Request): + username, password = basic_credentials(req) + + with pool.connection() as c: + user = c.execute( + """ + SELECT id,username,display_name,created_at,password_hash + FROM users WHERE username=%s + """, + (username,) + ).fetchone() + + good = False + + if user: + try: + good = ph.verify(user["password_hash"], password) + except (VerifyMismatchError, InvalidHashError): + pass + + if not good: + raise ApiError(401, "unauthorized", "Неверные учётные данные") + + token = secrets.token_urlsafe(32) + digest = hashlib.sha256(token.encode()).hexdigest() + exp = datetime.now(timezone.utc) + timedelta(seconds=TTL) + + try: + with pool.connection() as c: + c.execute( + """ + INSERT INTO sessions(token_hash,user_id,expires_at) + VALUES(%s,%s,%s) + """, + (digest, user["id"], exp) + ) + + cache.setex("session:" + digest, TTL, str(user["id"])) + + except redis.RedisError as e: + with pool.connection() as c: + c.execute( + "DELETE FROM sessions WHERE token_hash=%s", + (digest,) + ) + + raise ApiError( + 503, + "unavailable", + "Сервис сессий временно недоступен" + ) from e + + public_user = { + k: user[k] + for k in ("id", "username", "display_name", "created_at") + } + + return { + "token": token, + "token_type": "Bearer", + "expires_at": stamp(exp), + "user": out(public_user) + } + + +@app.delete("/api/v1/auth/sessions/current", status_code=204) +def logout(req: Request): + user, digest = current(req) + + try: + cache.delete("session:" + digest) + + except redis.RedisError as e: + raise ApiError( + 503, + "unavailable", + "Сервис сессий временно недоступен" + ) from e + + with pool.connection() as c: + c.execute( + "DELETE FROM sessions WHERE token_hash=%s", + (digest,) + ) + + return None + + +@app.get("/api/v1/users/me") +def me(req: Request): + return out(current(req)[0]) + + +@app.post("/api/v1/chats", status_code=201) +def create_chat(req: Request, p: ChatIn): + user, _ = current(req) + cid = uuid.uuid4() + + if user["id"] not in p.member_ids: + raise ApiError(400, "invalid_request", "Список участников некорректен") + + try: + with pool.connection() as c: + with c.transaction(): + c.execute( + "INSERT INTO chats(id,title) VALUES(%s,%s)", + (cid, p.title) + ) + + existing = c.execute( + "SELECT id FROM users WHERE id=ANY(%s)", + (p.member_ids,) + ).fetchall() + + if len(existing) != len(p.member_ids): + raise ApiError( + 400, + "invalid_request", + "Список участников некорректен" + ) + + with c.cursor() as cur: + cur.executemany( + "INSERT INTO memberships(chat_id,user_id) VALUES(%s,%s)", + [(cid, x) for x in p.member_ids] + ) + + return { + "id": cid, + "title": p.title, + "member_ids": p.member_ids, + "created_at": stamp( + c.execute( + "SELECT created_at FROM chats WHERE id=%s", + (cid,) + ).fetchone()["created_at"] + ) + } + + except psycopg.Error as e: + raise ApiError( + 503, + "unavailable", + "База данных временно недоступна" + ) from e + + +@app.get("/api/v1/chats") +def list_chats( + req: Request, + limit: int = Query(50, ge=1, le=100), + cursor: str | None = None +): + user, _ = current(req) + + with pool.connection() as c: + query = ( + "SELECT c.id,c.title,c.created_at," + "array_agg(m.user_id ORDER BY m.user_id) member_ids " + "FROM chats c " + "JOIN memberships mine ON mine.chat_id=c.id " + "JOIN memberships m ON m.chat_id=c.id " + "WHERE mine.user_id=%s" + ) + + params = [user["id"]] + + if cursor: + try: + import json + + obj = json.loads( + base64.urlsafe_b64decode( + cursor + "=" * (-len(cursor) % 4) + ).decode() + ) + + if obj["chat_id"] != str(uuid.UUID(int=0)): + raise ValueError + + chat_marker = uuid.UUID(obj["id"]) + datetime.fromisoformat( + obj["created_at"].replace("Z", "+00:00") + ) + + query += " AND (c.created_at,c.id)>(%s,%s)" + params.extend([obj["created_at"], chat_marker]) + + except Exception: + raise ApiError(400, "invalid_request", "Некорректный cursor") + + query += " GROUP BY c.id ORDER BY c.created_at,c.id LIMIT %s" + params.append(limit + 1) + + rows = c.execute(query, params).fetchall() + + more = len(rows) > limit + items = [ + {**out(r), "member_ids": r["member_ids"]} + for r in rows[:limit] + ] + next_cursor = None + + if more and items: + import json + + z = items[-1] + + next_cursor = base64.urlsafe_b64encode( + json.dumps( + { + "chat_id": str(uuid.UUID(int=0)), + "created_at": z["created_at"], + "id": str(z["id"]) + }, + separators=(",", ":") + ).encode() + ).decode().rstrip("=") + + return {"items": items, "next_cursor": next_cursor} + + +@app.get("/api/v1/chats/{chat_id}") +def get_chat(req: Request, chat_id: uuid.UUID): + user, _ = current(req) + membership(chat_id, user["id"]) + + with pool.connection() as c: + r = c.execute( + """ + SELECT c.id,c.title,c.created_at, + array_agg(m.user_id ORDER BY m.user_id) member_ids + FROM chats c + JOIN memberships m ON m.chat_id=c.id + WHERE c.id=%s GROUP BY c.id + """, + (chat_id,) + ).fetchone() + + return {**out(r), "member_ids": r["member_ids"]} + + +@app.post("/api/v1/chats/{chat_id}/messages", status_code=201) +def create_message(req: Request, chat_id: uuid.UUID, p: MessageIn): + user, _ = current(req) + mid = uuid.uuid4() + + try: + with pool.connection() as c: + with c.transaction(): + if not c.execute( + "SELECT 1 FROM memberships WHERE chat_id=%s AND user_id=%s", + (chat_id, user["id"]) + ).fetchone(): + raise ApiError(404, "not_found", "Объект не найден") + + r = c.execute( + """ + INSERT INTO messages(id,chat_id,sender_id,text) + VALUES(%s,%s,%s,%s) + RETURNING id,chat_id,sender_id,text,created_at + """, + (mid, chat_id, user["id"], p.text) + ).fetchone() + + return out(r) + + except psycopg.Error as e: + raise ApiError( + 503, + "unavailable", + "База данных временно недоступна" + ) from e + + +@app.get("/api/v1/chats/{chat_id}/messages") +def list_messages( + req: Request, + chat_id: uuid.UUID, + limit: int = Query(50, ge=1, le=100), + cursor: str | None = None +): + user, _ = current(req) + membership(chat_id, user["id"]) + + try: + with pool.connection() as c: + if cursor: + try: + raw = base64.urlsafe_b64decode( + cursor + "=" * (-len(cursor) % 4) + ).decode() + + obj = __import__("json").loads(raw) + + if obj["chat_id"] != str(chat_id): + raise ValueError + + marker = ( + obj["created_at"], + uuid.UUID(obj["id"]) + ) + + except Exception: + raise ApiError( + 400, + "invalid_request", + "Некорректный cursor" + ) + + rows = c.execute( + """ + SELECT id,chat_id,sender_id,text,created_at + FROM messages + WHERE chat_id=%s AND (created_at,id)>(%s,%s) + ORDER BY created_at,id + LIMIT %s + """, + (chat_id, marker[0], marker[1], limit + 1) + ).fetchall() + + else: + rows = c.execute( + """ + SELECT id,chat_id,sender_id,text,created_at + FROM messages + WHERE chat_id=%s + ORDER BY created_at,id + LIMIT %s + """, + (chat_id, limit + 1) + ).fetchall() + + more = len(rows) > limit + items = [out(x) for x in rows[:limit]] + next_cursor = None + + if more and items: + import json + + z = items[-1] + + next_cursor = base64.urlsafe_b64encode( + json.dumps( + { + "chat_id": str(chat_id), + "created_at": z["created_at"], + "id": str(z["id"]) + }, + separators=(",", ":") + ).encode() + ).decode().rstrip("=") + + return {"items": items, "next_cursor": next_cursor} + + except psycopg.Error as e: + raise ApiError( + 503, + "unavailable", + "База данных временно недоступна" + ) from e diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 00000000..33cd61e4 --- /dev/null +++ b/compose.yaml @@ -0,0 +1,37 @@ +services: + db: + image: postgres:17.2-alpine + environment: + POSTGRES_DB: messenger + POSTGRES_USER: messenger + POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?set POSTGRES_PASSWORD in .env} + volumes: [pgdata:/var/lib/postgresql/data] + healthcheck: + test: ["CMD-SHELL", "pg_isready -U messenger -d messenger"] + interval: 5s + timeout: 3s + retries: 20 + redis: + image: redis:7.4.2-alpine + command: ["redis-server", "--appendonly", "yes", "--appendfsync", "always"] + volumes: [redisdata:/data] + healthcheck: + test: ["CMD", "redis-cli", "ping"] + interval: 5s + timeout: 3s + retries: 20 + api: + build: . + environment: + DATABASE_URL: postgresql://messenger:${POSTGRES_PASSWORD}@db:5432/messenger + REDIS_URL: redis://redis:6379/0 + SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600} + APP_HOST: 0.0.0.0 + APP_PORT: 8080 + ports: ["127.0.0.1:8080:8080"] + depends_on: + db: {condition: service_healthy} + redis: {condition: service_healthy} +volumes: + pgdata: + redisdata: diff --git a/migrations/001_initial.sql b/migrations/001_initial.sql new file mode 100644 index 00000000..d6a775bb --- /dev/null +++ b/migrations/001_initial.sql @@ -0,0 +1,24 @@ +CREATE TABLE IF NOT EXISTS users ( + id UUID PRIMARY KEY, username VARCHAR(32) NOT NULL UNIQUE CHECK (username ~ '^[a-z0-9_]{3,32}$'), + display_name VARCHAR(100) NOT NULL, password_hash TEXT NOT NULL, created_at TIMESTAMPTZ NOT NULL DEFAULT now() +); +CREATE TABLE IF NOT EXISTS chats ( + id UUID PRIMARY KEY, title VARCHAR(100) NOT NULL, created_at TIMESTAMPTZ NOT NULL DEFAULT now() +); +CREATE TABLE IF NOT EXISTS memberships ( + chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE, + user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE, + PRIMARY KEY(chat_id,user_id) +); +CREATE INDEX IF NOT EXISTS memberships_user_chat_idx ON memberships(user_id,chat_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 VARCHAR(4000) NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT now() +); +CREATE INDEX IF NOT EXISTS messages_history_idx ON messages(chat_id,created_at,id); +CREATE TABLE IF NOT EXISTS sessions ( + token_hash CHAR(64) PRIMARY KEY, user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE, + expires_at TIMESTAMPTZ NOT NULL +); +CREATE INDEX IF NOT EXISTS sessions_expiry_idx ON sessions(expires_at); diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 00000000..3fcafe95 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,5 @@ +fastapi==0.127.0 +uvicorn[standard]==0.42.0 +psycopg[binary,pool]==3.2.6 +argon2-cffi==23.1.0 +redis==5.2.1 diff --git a/scripts/check_dependency_failures.sh b/scripts/check_dependency_failures.sh new file mode 100644 index 00000000..726f30b2 --- /dev/null +++ b/scripts/check_dependency_failures.sh @@ -0,0 +1,20 @@ +#!/bin/sh +set -eu +cd "$(dirname "$0")/.." +restore() { docker compose --env-file .env start db redis >/dev/null; } +trap restore EXIT +docker compose --env-file .env stop redis +python3 tests/dependency_failure.py redis +docker compose --env-file .env start redis +for attempt in $(seq 1 30); do + if curl -fsS http://localhost:8080/health/ready >/dev/null; then break; fi + sleep 2 +done +docker compose --env-file .env stop db +python3 tests/dependency_failure.py db +docker compose --env-file .env start db +for attempt in $(seq 1 30); do + if curl -fsS http://localhost:8080/health/ready >/dev/null; then break; fi + sleep 2 +done +curl -fsS http://localhost:8080/health/ready >/dev/null diff --git a/scripts/check_short_ttl.sh b/scripts/check_short_ttl.sh new file mode 100644 index 00000000..cb6dbb92 --- /dev/null +++ b/scripts/check_short_ttl.sh @@ -0,0 +1,30 @@ +#!/bin/sh +set -eu +cd "$(dirname "$0")/.." +backup=$(mktemp) +cp .env "$backup" +restore() { + cp "$backup" .env + rm -f "$backup" + docker compose --env-file .env up -d --force-recreate api + for attempt in $(seq 1 30); do + if curl -fsS http://localhost:8080/health/ready >/dev/null; then return; fi + sleep 2 + done + return 1 +} +trap restore EXIT +trap 'exit 130' INT +trap 'exit 143' TERM +if grep -q '^SESSION_TTL_SECONDS=' .env; then + sed -i 's/^SESSION_TTL_SECONDS=.*/SESSION_TTL_SECONDS=3/' .env +else + printf '\nSESSION_TTL_SECONDS=3\n' >> .env +fi +docker compose --env-file .env up -d --force-recreate api +for attempt in $(seq 1 30); do + if curl -fsS http://localhost:8080/health/ready >/dev/null; then break; fi + sleep 2 +done +curl -fsS http://localhost:8080/health/ready >/dev/null +SESSION_TTL_SECONDS=3 python3 tests/expiry.py diff --git a/scripts/explain_history.sql b/scripts/explain_history.sql new file mode 100644 index 00000000..a4de4941 --- /dev/null +++ b/scripts/explain_history.sql @@ -0,0 +1,23 @@ +BEGIN; +CREATE TEMP TABLE lab_messages ( + id UUID NOT NULL, + chat_id INTEGER NOT NULL, + created_at TIMESTAMPTZ NOT NULL, + text VARCHAR(4000) NOT NULL +); +CREATE INDEX lab_messages_history_idx ON lab_messages(chat_id, created_at, id); +INSERT INTO lab_messages(id, chat_id, created_at, text) +SELECT md5(g::text)::uuid, + CASE WHEN g <= 10000 THEN 1 ELSE 2 + (g % 100) END, + TIMESTAMPTZ '2026-01-01 00:00:00+00' + g * INTERVAL '1 millisecond', + repeat('x', 40) +FROM generate_series(1, 100000) AS g; +ANALYZE lab_messages; +EXPLAIN (ANALYZE, BUFFERS) +SELECT id, chat_id, created_at, text +FROM lab_messages +WHERE chat_id = 1 + AND (created_at, id) > (TIMESTAMPTZ '2026-01-01 00:00:05+00', md5('5000')::uuid) +ORDER BY created_at, id +LIMIT 50; +ROLLBACK; diff --git a/scripts/migrate.py b/scripts/migrate.py new file mode 100644 index 00000000..ca5ac950 --- /dev/null +++ b/scripts/migrate.py @@ -0,0 +1,15 @@ +import os +from pathlib import Path +import psycopg + +url = os.environ["DATABASE_URL"] +with psycopg.connect(url, connect_timeout=5) 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 sorted((Path(__file__).resolve().parents[1] / "migrations").glob("*.sql")): + version = path.name + if conn.execute("SELECT 1 FROM schema_migrations WHERE version=%s", (version,)).fetchone(): + continue + with conn.transaction(): + conn.execute(path.read_text(encoding="utf-8")) + conn.execute("INSERT INTO schema_migrations(version) VALUES (%s)", (version,)) +print("Migrations applied") diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100644 index 00000000..b2fc4e67 --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,4 @@ +#!/bin/sh +set -eu +cd "$(dirname "$0")/.." +docker compose restart db redis api diff --git a/tests/dependency_failure.py b/tests/dependency_failure.py new file mode 100644 index 00000000..441f010d --- /dev/null +++ b/tests/dependency_failure.py @@ -0,0 +1,20 @@ +import sys +import urllib.error +import urllib.request + +kind=sys.argv[1] +if kind=="redis": + url="http://localhost:8080/api/v1/users/me" + headers={"Authorization":"Bearer synthetic-invalid-token"} +elif kind=="db": + url="http://localhost:8080/health/ready" + headers={} +else: + raise SystemExit("expected redis or db") +request=urllib.request.Request(url,headers=headers) +try: + with urllib.request.urlopen(request,timeout=10) as response: status=response.status +except urllib.error.HTTPError as error: + status=error.code +assert status==503, f"{kind} outage returned {status}, expected bounded 503" +print(f"PASS: {kind} outage returns 503") diff --git a/tests/expiry.py b/tests/expiry.py new file mode 100644 index 00000000..019e3aad --- /dev/null +++ b/tests/expiry.py @@ -0,0 +1,13 @@ +import os +import time +from client import Client + +base=os.environ.get("BASE_URL","http://localhost:8080") +ttl=int(os.environ.get("SESSION_TTL_SECONDS","3")) +if ttl>10: raise SystemExit("Run with a short SESSION_TTL_SECONDS (10 seconds or less)") +c=Client(base) +actor=c.user("expiry") +time.sleep(ttl+1.2) +response=c.call("GET","/api/v1/users/me",401,actor=actor) +assert response["status"]==401 +print("PASS: expired Bearer session rejected after short TTL") diff --git a/tests/grade4_concurrency.py b/tests/grade4_concurrency.py new file mode 100644 index 00000000..98a1a0c8 --- /dev/null +++ b/tests/grade4_concurrency.py @@ -0,0 +1,43 @@ +from concurrent.futures import ThreadPoolExecutor +import json +import urllib.error +import urllib.request +from urllib.parse import quote +import uuid + +from client import Client + +BASE="http://localhost:8080" + +def register(body): + req=urllib.request.Request(BASE+"/api/v1/users",data=json.dumps(body).encode(),headers={"Content-Type":"application/json"},method="POST") + try: + with urllib.request.urlopen(req,timeout=10) as r: return r.status + except urllib.error.HTTPError as e: return e.code + +def main(): + uname="race_"+uuid.uuid4().hex[:20] + body={"username":uname,"display_name":"Race","password":"RacePassword-123456"} + with ThreadPoolExecutor(max_workers=12) as executor: + statuses=list(executor.map(register,[body]*12)) + assert statuses.count(201)==1 and statuses.count(409)==11, statuses + + c=Client(BASE) + actor=c.user("rollback") + for title in ("cursor first", "cursor second"): + c.call("POST", "/api/v1/chats", 201, actor=actor, + body={"title": title, "member_ids": [actor["id"]]}, schema="Chat") + page1=c.call("GET", "/api/v1/chats?limit=1", actor=actor, schema="ChatPage")["json"] + assert len(page1["items"]) == 1 and page1["next_cursor"] + page2=c.call("GET", "/api/v1/chats?limit=1&cursor=" + quote(page1["next_cursor"], safe=""), actor=actor, schema="ChatPage")["json"] + assert len(page2["items"]) == 1 and page2["next_cursor"] is None + assert page1["items"][0]["id"] != page2["items"][0]["id"] + before=c.call("GET","/api/v1/chats?limit=100",actor=actor,schema="ChatPage")["json"]["items"] + invalid=str(uuid.uuid4()) + result=c.call("POST","/api/v1/chats",400,actor=actor,body={"title":"must rollback","member_ids":[actor["id"],invalid]}) + assert result["status"]==400 + after=c.call("GET","/api/v1/chats?limit=100",actor=actor,schema="ChatPage")["json"]["items"] + assert [x["id"] for x in after]==[x["id"] for x in before], "failed chat left partial state" + print("PASS: concurrent username uniqueness and atomic chat rollback") + +if __name__=="__main__": main() -- 2.54.0