From b8d7d977b3927e1145806c54ef67a526a916c516 Mon Sep 17 00:00:00 2001 From: katyatheestalion Date: Mon, 16 Nov 2026 21:22:29 +0300 Subject: [PATCH] =?UTF-8?q?=D0=A1=D0=B4=D0=B5=D0=BB=D0=B0=D0=BD=D0=B0=20?= =?UTF-8?q?=D0=BB=D0=B0=D0=B1=D0=B0=203?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .env.example | 13 +- Dockerfile | 16 + REPORT.md | 91 ++++-- app.py | 558 +++++++++++++++++++++++++++++++++ compose.yaml | 81 +++++ migrations/001_initial.sql | 38 +++ migrations/002_idempotency.sql | 11 + nginx/default.conf | 20 ++ requirements.txt | 4 + scripts/restart.sh | 3 + scripts/stop-one.sh | 10 + 11 files changed, 810 insertions(+), 35 deletions(-) create mode 100644 Dockerfile create mode 100644 app.py create mode 100644 compose.yaml create mode 100644 migrations/001_initial.sql create mode 100644 migrations/002_idempotency.sql create mode 100644 nginx/default.conf create mode 100644 requirements.txt create mode 100644 scripts/restart.sh create mode 100644 scripts/stop-one.sh diff --git a/.env.example b/.env.example index d32b9be0..99f116a6 100644 --- a/.env.example +++ b/.env.example @@ -1,13 +1,2 @@ -# 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 +POSTGRES_PASSWORD=change-me-local-only 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 -API_REPLICAS=2 -IDEMPOTENCY_TTL_SECONDS=86400 diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..8b4be7fc --- /dev/null +++ b/Dockerfile @@ -0,0 +1,16 @@ +FROM python:3.13-slim-bookworm + +ENV PYTHONDONTWRITEBYTECODE=1 PYTHONUNBUFFERED=1 +WORKDIR /app + +COPY requirements.txt . +RUN python -m pip install --no-cache-dir -r requirements.txt +COPY app.py ./ +COPY migrations ./migrations/ + +RUN useradd --create-home --shell /usr/sbin/nologin appuser && \ + chown -R appuser:appuser /app +USER appuser + +EXPOSE 8080 +CMD ["python", "app.py"] diff --git a/REPORT.md b/REPORT.md index c2679005..0d34cdb1 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,82 @@ -# Отчёт — лабораторная 3 +# Лабораторная 3 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO -- Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +- Автор / группа: Антонова Екатерина +- Целевая оценка (3/4/5): 3 +- Трек 5: не заявлен +- Использованные источники и помощь ИИ: задание лабораторной 3, `COURSE.md`, `contracts/openapi.json`, `contracts/README.md`, `contracts/infrastructure.json`, публичные тесты из `tests/` и реализация лабораторной 2. Также использовалась официальная документация Docker Compose, PostgreSQL и Nginx. ИИ применялся как вспомогательный инструмент для проверки изменений и подготовки отчёта. + +## Что реализовано + +Перенесены пользователи, чаты, участники, сообщения, PostgreSQL, миграции, +Argon2id и Bearer-сессии из lab2. Добавлены две взаимозаменяемые API-реплики +(`api1`, `api2`), Nginx как единственная публичная точка входа, проверки +готовности и заголовок `X-Instance-Id`. Сессии, сообщения и идемпотентность +хранятся в общей PostgreSQL. Повтор сообщения с одинаковым +`Idempotency-Key` защищён уникальным ключом и транзакцией PostgreSQL; при +конкурентном повторе возвращается тот же message ID. + +Миграция `001_initial.sql` создаёт основные таблицы, а `002_idempotency.sql` +создаёт общее хранилище ключей. Миграции запускаются отдельным одноразовым +сервисом `migrate` до API-реплик и безопасны при повторном запуске. ## Запуск из чистого clone -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +Требуется Docker Desktop с Compose: -## Архитектура и решения +```sh +cp .env.example .env +# замените POSTGRES_PASSWORD в .env на локальное значение +docker compose --env-file .env config --quiet +docker compose --env-file .env up -d --build +curl --fail http://localhost:8080/health/ready +make check +make validate +make test +``` -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab2, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +Публичный порт есть только у `load_balancer`; `api1`, `api2` и PostgreSQL +доступны только во внутренней сети Compose. Для остановки одной реплики: -## Доказательства критериев +```sh +chmod +x scripts/restart.sh scripts/stop-one.sh +TARGET_INSTANCE_ID=api1 ./scripts/stop-one.sh +docker compose start api1 +``` -| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | -| --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | +Для штатного теста отказа: -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +```sh +make test-persistence ACTION_SCRIPT=scripts/restart.sh +make test-failover ACTION_SCRIPT=scripts/stop-one.sh +``` -## Эксперименты и отказы +Удаление учебных данных выполняется только намеренно: +`docker compose down -v`. -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +## Доказательства критериев уровня 3 -| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | -| --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +| Критерий | Команда / сценарий | Результат | +| --- | --- | --- | +| Контракт | `make check` | PASS | +| Compose и инфраструктура | `docker compose --env-file .env config --quiet` | PASS | +| Публичный API | `make test` | `PASS: lab3 public API scenario` | +| Две реплики | `docker compose ps`, ответы smoke | `api1` и `api2` healthy; ответы содержат разные `X-Instance-Id` | +| Общие сессии и данные | перезапуск `postgres`, `api1`, `api2`, `load_balancer` без `-v` | прежний Bearer и сообщение сохранились | +| Идемпотентность | 20 параллельных POST с одним ключом | 20 ответов, 1 уникальный message ID | +| Отказ API | `docker compose stop api1`, затем `make test` | smoke продолжил проходить через `api2` | -## Ограничения и следующие шаги +В Windows `tests/resilience.py` не может запустить Unix-файл `.sh` напрямую +через `Popen` (WinError 193). Поэтому локально отказ и сохранность были +проверены эквивалентными командами Docker Compose; в Linux/CI hooks запускаются +напрямую после `chmod +x`. -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +## Архитектура и ограничения + +Nginx распределяет запросы между `api1` и `api2` без sticky sessions. +PostgreSQL volume является источником истины для пользователей, членства, +сообщений, сессий и idempotency records. Остановка одной API-реплики не +останавливает БД или вторую реплику; во время обнаружения отказа возможны +краткие 502/таймауты, после чего Nginx направляет запросы на оставшуюся +реплику. Отказ PostgreSQL, Docker host и высокодоступность самой БД в этой +лабораторной не исследовались. Redis/Valkey и возможности уровня 4/5 не +заявляются. diff --git a/app.py b/app.py new file mode 100644 index 00000000..1a39e3c0 --- /dev/null +++ b/app.py @@ -0,0 +1,558 @@ +import base64 +import binascii +import hashlib +import json +import os +import re +import secrets +import time +import uuid +from datetime import datetime, timedelta, timezone +from pathlib import Path +from typing import Any + +import psycopg +from psycopg.rows import dict_row +from fastapi import FastAPI, Query, Request, Response +from fastapi.exceptions import RequestValidationError +from fastapi.responses import JSONResponse +from pydantic import BaseModel, ConfigDict, Field, field_validator +from argon2 import PasswordHasher +from argon2.exceptions import VerificationError + +APP_HOST = os.getenv("APP_HOST", "0.0.0.0") +APP_PORT = int(os.getenv("APP_PORT", "8080")) +DATABASE_URL = os.getenv("DATABASE_URL", "") +DATABASE_URL_FILE = os.getenv("DATABASE_URL_FILE", "") +SESSION_TTL_SECONDS = int(os.getenv("SESSION_TTL_SECONDS", "3600")) +INSTANCE_ID = os.getenv("INSTANCE_ID", "api-" + uuid.uuid4().hex[:8]) +MIGRATIONS_DIR = Path(__file__).parent / "migrations" +PASSWORD_HASHER = PasswordHasher() + + +class APIError(Exception): + def __init__(self, status_code: int, code: str, message: str): + self.status_code = status_code + self.code = code + self.message = message + + +class CreateUser(BaseModel): + model_config = ConfigDict(extra="forbid") + + username: str = Field(..., pattern=r"^[a-z0-9_]{3,32}$") + display_name: str = Field(..., min_length=1, max_length=100) + password: str = Field(..., min_length=12, max_length=128) + + @field_validator("display_name", "password") + @classmethod + def validate_non_blank(cls, value: str) -> str: + if not value.strip(): + raise ValueError("value must not be blank") + return value + + +class CreateChat(BaseModel): + model_config = ConfigDict(extra="forbid") + + title: str = Field(..., min_length=1, max_length=100) + member_ids: list[str] = Field(..., min_length=1, max_length=100) + + @field_validator("title") + @classmethod + def validate_title(cls, value: str) -> str: + if not value.strip(): + raise ValueError("title must not be blank") + return value + + @field_validator("member_ids") + @classmethod + def validate_member_ids(cls, value: list[str]) -> list[str]: + if len(set(value)) != len(value): + raise ValueError("member_ids must be unique") + for member_id in value: + try: + uuid.UUID(member_id) + except ValueError as exc: + raise ValueError("member_ids must contain UUIDs") from exc + return value + + +class CreateMessage(BaseModel): + model_config = ConfigDict(extra="forbid") + + text: str = Field(..., min_length=1, max_length=4000) + + @field_validator("text") + @classmethod + def validate_text(cls, value: str) -> str: + if not value.strip(): + raise ValueError("text must not be blank") + return value + + +def utc_now() -> datetime: + return datetime.now(timezone.utc) + + +def iso(value: datetime) -> str: + return value.astimezone(timezone.utc).isoformat(timespec="microseconds").replace( + "+00:00", "Z" + ) + + +def database_url() -> str: + if DATABASE_URL: + return DATABASE_URL + if DATABASE_URL_FILE: + try: + return Path(DATABASE_URL_FILE).read_text(encoding="utf-8").strip() + except OSError as exc: + raise RuntimeError("database URL file is not readable") from exc + raise RuntimeError("DATABASE_URL or DATABASE_URL_FILE is required") + + +def db(): + return psycopg.connect(database_url(), row_factory=dict_row) + + +def apply_migrations() -> None: + with db() 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(MIGRATIONS_DIR.glob("*.sql")): + version = path.name.split("_", 1)[0] + applied = conn.execute( + "SELECT 1 FROM schema_migrations WHERE version = %s", (version,) + ).fetchone() + if applied is None: + for statement in path.read_text(encoding="utf-8").split(";"): + if statement.strip(): + conn.execute(statement) + conn.execute( + "INSERT INTO schema_migrations(version) VALUES (%s)", (version,) + ) + + +def wait_for_database() -> None: + deadline = time.monotonic() + 60 + last_error: Exception | None = None + while time.monotonic() < deadline: + try: + apply_migrations() + return + except (OSError, psycopg.Error) as exc: + last_error = exc + time.sleep(1) + raise RuntimeError("database did not become ready") from last_error + + +def error_response(request: Request, status_code: int, code: str, message: str): + request_id = getattr(request.state, "request_id", str(uuid.uuid4())) + headers = {"X-Request-Id": request_id} + if status_code == 401: + headers["WWW-Authenticate"] = ( + 'Bearer realm="messenger"' + if request.url.path != "/api/v1/auth/sessions" + else 'Basic realm="messenger", charset="UTF-8"' + ) + return JSONResponse( + status_code=status_code, + content={"error": {"code": code, "message": message, "request_id": request_id}}, + headers=headers, + ) + + +def bearer_user(request: Request) -> dict[str, Any]: + header = request.headers.get("Authorization", "") + scheme, _, token = header.partition(" ") + if scheme.lower() != "bearer" or not token or " " in token: + raise APIError(401, "unauthorized", "valid bearer session required") + hashed_token = token_hash(token) + with db() as conn: + user = conn.execute( + """ + SELECT u.id, u.username, u.display_name, u.created_at + FROM sessions s JOIN users u ON u.id = s.user_id + WHERE s.token_hash = %s AND s.revoked_at IS NULL + AND s.expires_at > now() + """, + (hashed_token,), + ).fetchone() + if user is None: + raise APIError(401, "unauthorized", "valid bearer session required") + return user + + +def basic_credentials(request: Request) -> tuple[str, str]: + header = request.headers.get("Authorization", "") + scheme, _, encoded = header.partition(" ") + if scheme.lower() != "basic" or not encoded: + raise APIError(401, "unauthorized", "basic credentials required") + try: + decoded = base64.b64decode(encoded, validate=True).decode("utf-8") + username, separator, password = decoded.partition(":") + except (binascii.Error, UnicodeDecodeError): + raise APIError(401, "unauthorized", "invalid credentials") from None + if not separator or not username or not password: + raise APIError(401, "unauthorized", "invalid credentials") + return username, password + + +def token_hash(token: str) -> str: + try: + return hashlib.sha256(token.encode("ascii", "strict")).hexdigest() + except UnicodeEncodeError: + raise APIError(401, "unauthorized", "valid bearer session required") from None + + +def encode_cursor(created_at: datetime, object_id: uuid.UUID) -> str: + payload = json.dumps( + {"created_at": iso(created_at), "id": str(object_id)}, + separators=(",", ":"), + ).encode() + return base64.urlsafe_b64encode(payload).decode().rstrip("=") + + +def decode_cursor(cursor: str) -> tuple[datetime, uuid.UUID]: + try: + padding = "=" * ((4 - len(cursor) % 4) % 4) + payload = json.loads( + base64.urlsafe_b64decode((cursor + padding).encode()).decode() + ) + created_at = datetime.fromisoformat(payload["created_at"].replace("Z", "+00:00")) + return created_at, uuid.UUID(payload["id"]) + except (KeyError, TypeError, ValueError, UnicodeDecodeError, binascii.Error, json.JSONDecodeError): + raise APIError(400, "invalid_request", "cursor is invalid") from None + + +app = FastAPI(title="MTUSI Messenger Lab2") + + +@app.on_event("startup") +def startup() -> None: + wait_for_database() + + +@app.middleware("http") +async def add_request_id(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 + response.headers["X-Instance-Id"] = INSTANCE_ID + return response + + +@app.exception_handler(APIError) +async def api_error_handler(request: Request, exc: APIError): + return error_response(request, exc.status_code, exc.code, exc.message) + + +@app.exception_handler(RequestValidationError) +async def validation_error_handler(request: Request, exc: RequestValidationError): + return error_response(request, 400, "invalid_request", "invalid request") + + +@app.exception_handler(Exception) +async def unexpected_error_handler(request: Request, exc: Exception): + return error_response(request, 500, "internal_error", "internal server error") + + +@app.get("/health/live") +def health_live(): + return {"status": "ok"} + + +@app.get("/health/ready") +def health_ready(): + try: + with db() as conn: + conn.execute("SELECT 1") + except (OSError, psycopg.Error): + raise APIError(503, "unavailable", "database unavailable") + return {"status": "ok"} + + +@app.post("/api/v1/users", status_code=201) +def create_user(payload: CreateUser): + user_id = uuid.uuid4() + password_hash = PASSWORD_HASHER.hash(payload.password) + try: + with db() as conn: + user = conn.execute( + """ + INSERT INTO users(id, username, display_name, password_hash) + VALUES (%s, %s, %s, %s) + RETURNING id, username, display_name, created_at + """, + (user_id, payload.username, payload.display_name, password_hash), + ).fetchone() + except psycopg.errors.UniqueViolation: + raise APIError(409, "conflict", "user already exists") from None + return {**user, "id": str(user["id"]), "created_at": iso(user["created_at"])} + + +@app.post("/api/v1/auth/sessions", status_code=201) +def create_session(request: Request): + username, password = basic_credentials(request) + with db() as conn: + user = conn.execute( + "SELECT id, username, display_name, created_at, password_hash FROM users WHERE username = %s", + (username,), + ).fetchone() + if user is None: + raise APIError(401, "unauthorized", "invalid credentials") + try: + PASSWORD_HASHER.verify(user["password_hash"], password) + except VerificationError: + raise APIError(401, "unauthorized", "invalid credentials") from None + token = secrets.token_urlsafe(32) + expires_at = utc_now() + timedelta(seconds=SESSION_TTL_SECONDS) + with db() as conn: + conn.execute( + "INSERT INTO sessions(token_hash, user_id, expires_at) VALUES (%s, %s, %s)", + (token_hash(token), user["id"], expires_at), + ) + public_user = { + "id": str(user["id"]), + "username": user["username"], + "display_name": user["display_name"], + "created_at": iso(user["created_at"]), + } + return { + "token": token, + "token_type": "Bearer", + "expires_at": iso(expires_at), + "user": public_user, + } + + +@app.delete("/api/v1/auth/sessions/current", status_code=204) +def revoke_session(request: Request): + bearer_user(request) + header = request.headers["Authorization"] + token = header.split(" ", 1)[1] + with db() as conn: + conn.execute( + "UPDATE sessions SET revoked_at = now() WHERE token_hash = %s AND revoked_at IS NULL", + (token_hash(token),), + ) + return Response(status_code=204) + + +@app.get("/api/v1/users/me") +def current_user(request: Request): + user = bearer_user(request) + return {**user, "id": str(user["id"]), "created_at": iso(user["created_at"])} + + +@app.post("/api/v1/chats", status_code=201) +def create_chat(payload: CreateChat, request: Request): + actor = bearer_user(request) + member_ids = [uuid.UUID(member_id) for member_id in payload.member_ids] + if actor["id"] not in member_ids: + raise APIError(400, "invalid_request", "actor must be included in member_ids") + chat_id = uuid.uuid4() + with db() as conn: + existing = conn.execute( + "SELECT id FROM users WHERE id = ANY(%s)", (member_ids,) + ).fetchall() + if len(existing) != len(member_ids): + raise APIError(400, "invalid_request", "member not found") + chat = conn.execute( + "INSERT INTO chats(id, title) VALUES (%s, %s) RETURNING id, title, created_at", + (chat_id, payload.title), + ).fetchone() + with conn.cursor() as cur: + cur.executemany( + "INSERT INTO chat_members(chat_id, user_id) VALUES (%s, %s)", + [(chat_id, member_id) for member_id in member_ids], + ) + return { + "id": str(chat["id"]), + "title": chat["title"], + "member_ids": sorted(str(member_id) for member_id in member_ids), + "created_at": iso(chat["created_at"]), + } + + +def chat_for_user(conn, chat_id: uuid.UUID, user_id: uuid.UUID): + return conn.execute( + """ + SELECT c.id, c.title, c.created_at + FROM chats c JOIN chat_members m ON m.chat_id = c.id + WHERE c.id = %s AND m.user_id = %s + """, + (chat_id, user_id), + ).fetchone() + + +def public_chat(conn, chat: dict[str, Any]) -> dict[str, Any]: + members = conn.execute( + "SELECT user_id FROM chat_members WHERE chat_id = %s ORDER BY user_id", (chat["id"],) + ).fetchall() + return { + "id": str(chat["id"]), + "title": chat["title"], + "member_ids": [str(row["user_id"]) for row in members], + "created_at": iso(chat["created_at"]), + } + + +@app.get("/api/v1/chats/{chat_id}") +def get_chat(chat_id: uuid.UUID, request: Request): + actor = bearer_user(request) + with db() as conn: + chat = chat_for_user(conn, chat_id, actor["id"]) + if chat is None: + raise APIError(404, "not_found", "chat not found") + return public_chat(conn, chat) + + +@app.get("/api/v1/chats") +def list_chats(request: Request, limit: int = Query(50, ge=1, le=100), cursor: str | None = None): + actor = bearer_user(request) + after = decode_cursor(cursor) if cursor else None + with db() 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 + AND (%s::timestamptz IS NULL OR (c.created_at, c.id) > (%s::timestamptz, %s::uuid)) + ORDER BY c.created_at, c.id + LIMIT %s + """, + (actor["id"], after[0] if after else None, after[0] if after else None, + after[1] if after else None, limit + 1), + ).fetchall() + items = [public_chat(conn, row) for row in rows[:limit]] + next_cursor = ( + encode_cursor(rows[limit - 1]["created_at"], rows[limit - 1]["id"]) + if len(rows) > limit + else None + ) + return {"items": items, "next_cursor": next_cursor} + + +@app.post("/api/v1/chats/{chat_id}/messages", status_code=201) +def create_message( + chat_id: uuid.UUID, + payload: CreateMessage, + request: Request, +): + actor = bearer_user(request) + idempotency_key = request.headers.get("Idempotency-Key", "") + if not re.fullmatch(r"[A-Za-z0-9._:-]{1,128}", idempotency_key): + raise APIError(400, "invalid_request", "valid Idempotency-Key required") + request_hash = hashlib.sha256( + json.dumps({"text": payload.text}, ensure_ascii=False, sort_keys=True).encode() + ).hexdigest() + with db() as conn: + if chat_for_user(conn, chat_id, actor["id"]) is None: + raise APIError(404, "not_found", "chat not accessible") + existing = conn.execute( + """ + INSERT INTO idempotency_keys(user_id, chat_id, idempotency_key, request_hash) + VALUES (%s, %s, %s, %s) + ON CONFLICT (user_id, chat_id, idempotency_key) DO NOTHING + RETURNING message_id, request_hash + """, + (actor["id"], chat_id, idempotency_key, request_hash), + ).fetchone() + if existing is None: + existing = conn.execute( + """ + SELECT message_id, request_hash + FROM idempotency_keys + WHERE user_id = %s AND chat_id = %s AND idempotency_key = %s + FOR UPDATE + """, + (actor["id"], chat_id, idempotency_key), + ).fetchone() + if existing["request_hash"] != request_hash: + raise APIError(409, "conflict", "idempotency key has another request") + message = conn.execute( + """ + SELECT id, chat_id, sender_id, text, created_at + FROM messages WHERE id = %s + """, + (existing["message_id"],), + ).fetchone() + if message is None: + raise APIError(503, "unavailable", "idempotent result is not ready") + return { + **message, + "id": str(message["id"]), + "chat_id": str(message["chat_id"]), + "sender_id": str(message["sender_id"]), + "created_at": iso(message["created_at"]), + } + message_id = uuid.uuid4() + message = conn.execute( + """ + INSERT INTO messages(id, chat_id, sender_id, text) + VALUES (%s, %s, %s, %s) + RETURNING id, chat_id, sender_id, text, created_at + """, + (message_id, chat_id, actor["id"], payload.text), + ).fetchone() + conn.execute( + """ + UPDATE idempotency_keys SET message_id = %s + WHERE user_id = %s AND chat_id = %s AND idempotency_key = %s + """, + (message_id, actor["id"], chat_id, idempotency_key), + ) + return {**message, "id": str(message["id"]), "chat_id": str(message["chat_id"]), + "sender_id": str(message["sender_id"]), "created_at": iso(message["created_at"])} + + +@app.get("/api/v1/chats/{chat_id}/messages") +def list_messages( + chat_id: uuid.UUID, + request: Request, + limit: int = Query(50, ge=1, le=100), + cursor: str | None = None, +): + actor = bearer_user(request) + after = decode_cursor(cursor) if cursor else None + with db() as conn: + if chat_for_user(conn, chat_id, actor["id"]) is None: + raise APIError(404, "not_found", "chat not accessible") + rows = conn.execute( + """ + SELECT id, chat_id, sender_id, text, created_at + FROM messages + WHERE chat_id = %s + AND (%s::timestamptz IS NULL OR (created_at, id) > (%s::timestamptz, %s::uuid)) + ORDER BY created_at, id + LIMIT %s + """, + (chat_id, after[0] if after else None, after[0] if after else None, + after[1] if after else None, limit + 1), + ).fetchall() + items = [ + {**row, "id": str(row["id"]), "chat_id": str(row["chat_id"]), + "sender_id": str(row["sender_id"]), "created_at": iso(row["created_at"])} + for row in rows[:limit] + ] + next_cursor = ( + encode_cursor(rows[limit - 1]["created_at"], rows[limit - 1]["id"]) + if len(rows) > limit + else None + ) + return {"items": items, "next_cursor": next_cursor} + + +if __name__ == "__main__": + import uvicorn + + uvicorn.run("app:app", host=APP_HOST, port=APP_PORT, reload=False) diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 00000000..9a8e901e --- /dev/null +++ b/compose.yaml @@ -0,0 +1,81 @@ +services: + postgres: + image: postgres:16.4-bookworm + environment: + POSTGRES_DB: messenger + POSTGRES_USER: messenger + POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?set POSTGRES_PASSWORD in .env} + volumes: + - postgres_data:/var/lib/postgresql/data + healthcheck: + test: ["CMD-SHELL", "pg_isready -U messenger -d messenger"] + interval: 2s + timeout: 3s + retries: 30 + + migrate: + build: . + environment: + DATABASE_URL: postgresql://messenger:${POSTGRES_PASSWORD}@postgres:5432/messenger + depends_on: + postgres: + condition: service_healthy + command: ["python", "-c", "import app; app.wait_for_database()"] + restart: "no" + + api1: + build: . + environment: + APP_HOST: 0.0.0.0 + APP_PORT: 8080 + DATABASE_URL: postgresql://messenger:${POSTGRES_PASSWORD}@postgres:5432/messenger + SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600} + INSTANCE_ID: api1 + depends_on: + migrate: + condition: service_completed_successfully + healthcheck: + test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=2)"] + interval: 2s + timeout: 3s + retries: 30 + restart: unless-stopped + + api2: + build: . + environment: + APP_HOST: 0.0.0.0 + APP_PORT: 8080 + DATABASE_URL: postgresql://messenger:${POSTGRES_PASSWORD}@postgres:5432/messenger + SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600} + INSTANCE_ID: api2 + depends_on: + migrate: + condition: service_completed_successfully + healthcheck: + test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=2)"] + interval: 2s + timeout: 3s + retries: 30 + restart: unless-stopped + + load_balancer: + image: nginx:1.27.2-alpine + ports: + - "8080:80" + volumes: + - ./nginx/default.conf:/etc/nginx/conf.d/default.conf:ro + depends_on: + api1: + condition: service_healthy + api2: + condition: service_healthy + healthcheck: + test: ["CMD", "wget", "-q", "-O", "-", "http://127.0.0.1/health/live"] + interval: 2s + timeout: 3s + retries: 30 + restart: unless-stopped + +volumes: + postgres_data: diff --git a/migrations/001_initial.sql b/migrations/001_initial.sql new file mode 100644 index 00000000..81540760 --- /dev/null +++ b/migrations/001_initial.sql @@ -0,0 +1,38 @@ +CREATE TABLE users ( + id uuid PRIMARY KEY, + username varchar(32) NOT NULL UNIQUE, + display_name varchar(100) NOT NULL CHECK (btrim(display_name) <> ''), + password_hash text NOT NULL, + created_at timestamptz NOT NULL DEFAULT now() +); + +CREATE TABLE chats ( + id uuid PRIMARY KEY, + title varchar(100) NOT NULL CHECK (btrim(title) <> ''), + created_at timestamptz NOT NULL DEFAULT now() +); + +CREATE TABLE chat_members ( + 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 TABLE 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 CHECK (btrim(text) <> ''), + created_at timestamptz NOT NULL DEFAULT now() +); + +CREATE TABLE sessions ( + token_hash char(64) PRIMARY KEY, + user_id uuid NOT NULL REFERENCES users(id) ON DELETE CASCADE, + expires_at timestamptz NOT NULL, + revoked_at timestamptz +); + +CREATE INDEX chat_members_user_idx ON chat_members(user_id, chat_id); +CREATE INDEX messages_chat_order_idx ON messages(chat_id, created_at, id); +CREATE INDEX sessions_user_idx ON sessions(user_id, expires_at); diff --git a/migrations/002_idempotency.sql b/migrations/002_idempotency.sql new file mode 100644 index 00000000..51e10a23 --- /dev/null +++ b/migrations/002_idempotency.sql @@ -0,0 +1,11 @@ +CREATE TABLE idempotency_keys ( + user_id uuid NOT NULL REFERENCES users(id) ON DELETE CASCADE, + chat_id uuid NOT NULL REFERENCES chats(id) ON DELETE CASCADE, + idempotency_key varchar(128) NOT NULL, + request_hash char(64) NOT NULL, + message_id uuid REFERENCES messages(id) ON DELETE CASCADE, + created_at timestamptz NOT NULL DEFAULT now(), + PRIMARY KEY (user_id, chat_id, idempotency_key) +); + +CREATE INDEX idempotency_created_idx ON idempotency_keys(created_at); diff --git a/nginx/default.conf b/nginx/default.conf new file mode 100644 index 00000000..02d4beb3 --- /dev/null +++ b/nginx/default.conf @@ -0,0 +1,20 @@ +upstream messenger_api { + server api1:8080 max_fails=1 fail_timeout=2s; + server api2:8080 max_fails=1 fail_timeout=2s; +} + +server { + listen 80; + + location / { + proxy_pass http://messenger_api; + proxy_http_version 1.1; + proxy_set_header Host $host; + proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; + proxy_set_header X-Request-Id $http_x_request_id; + proxy_connect_timeout 1s; + proxy_read_timeout 10s; + proxy_next_upstream error timeout http_502 http_503 http_504; + proxy_next_upstream_tries 2; + } +} diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 00000000..50103630 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,4 @@ +argon2-cffi==23.1.0 +fastapi==0.115.5 +psycopg[binary]==3.2.3 +uvicorn==0.32.0 diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100644 index 00000000..8eb3b26c --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,3 @@ +#!/usr/bin/env bash +set -eu +docker compose restart postgres api1 api2 load_balancer diff --git a/scripts/stop-one.sh b/scripts/stop-one.sh new file mode 100644 index 00000000..72d1d850 --- /dev/null +++ b/scripts/stop-one.sh @@ -0,0 +1,10 @@ +#!/usr/bin/env bash +set -eu + +case "${TARGET_INSTANCE_ID:-}" in + api1) service=api1 ;; + api2) service=api2 ;; + *) echo "unknown TARGET_INSTANCE_ID" >&2; exit 2 ;; +esac + +docker compose stop "$service" -- 2.54.0